मुझे एक सरणी पर x संख्याओं की खोजों को मुद्रित करने की आवश्यकता है। अभी, मेरा प्रोग्राम हमेशा खोजों की संख्या के लिए 50,000 प्रिंट कर रहा है। मुझे पता है कि यह 50,000 प्रिंट करता है क्योंकि मैं सीधे NUMBER_SEARCHES पर कॉल कर रहा हूं, लेकिन मैं चाहता हूं कि यह खोजों की वास्तविक संख्या को प्रिंट करे। मैं इसे कैसे ठीक/कर सकता हूं? क्या मुझे एक नया चर बनाने की आवश्यकता होगी? पहली पंक्ति कुछ इस तरह दिखनी चाहिए: "इसमें 0.224 सेकंड का समय लगा 990 संख्याओं को आकार की एक सरणी पर खोजने के लिए: 20000।" मेरा कार्यक्रम अभी प्रत्येक सरणी के लिए 50,000 खोजता है।

यहाँ मेरा कोड है:

import java.util.Arrays;

public class ProgramSearches {
    static final int MAX_VALUE = 1000000;
    static final int MAX_ARRAY_SIZE = 100000;
    static final int ARRAY_INCREMENT = 20000;
    static final int NUMBER_SEARCHES = 50000;
    public static void main(String[] args) {
        demoLinearSearchUnsorted();
        demoLinearSearchSorted();
        demoBinarySearchSelectionSort();
        demoBinarySearchFastSort();
    }
    public static void demoLinearSearchUnsorted() {
        System.out.println("testing Linear Search Unsorted");

        for (int i = ARRAY_INCREMENT; i < MAX_ARRAY_SIZE; i += ARRAY_INCREMENT) {
            int array[] = generateNumbers(i, MAX_VALUE);
            long startTime = System.currentTimeMillis();
            for (int j = 0; j < NUMBER_SEARCHES; j++) {
                int num = (int) (Math.random() * MAX_VALUE);
                boolean search = linearSearch(array, num);
            }
            long endTime = System.currentTimeMillis();
            double seconds = (double) (endTime - startTime) / 1000.0;
            System.out.println("It took " + seconds + " seconds to search "
                    + NUMBER_SEARCHES + " numbers on an array of size: " + i);
        }
    }
    public static void demoLinearSearchSorted() {
        System.out.println("testing Linear Search Sorted");
        for (int i = ARRAY_INCREMENT; i < MAX_ARRAY_SIZE; i += ARRAY_INCREMENT) {
            int array[] = generateNumbers(i, MAX_VALUE);
            long startTime = System.currentTimeMillis();
            selectionSort(array);
            for (int j = 0; j < NUMBER_SEARCHES; j++) {
                int num = (int) (Math.random() * MAX_VALUE);
                boolean search = linearSearch(array, num);
            }
            long endTime = System.currentTimeMillis();
            double seconds = (double) (endTime - startTime) / 1000.0;
            System.out.println("It took " + seconds + " seconds to search "
                    + NUMBER_SEARCHES + " numbers on an array of size: " + i);
        }
    }
    public static void demoBinarySearchSelectionSort() {
        System.out.println("testing Binary Search using Selection Sort");
        for (int i = ARRAY_INCREMENT; i < MAX_ARRAY_SIZE; i += ARRAY_INCREMENT) {
            int array[] = generateNumbers(i, MAX_VALUE);
            long startTime = System.currentTimeMillis();
            selectionSort(array);
            for (int j = 0; j < NUMBER_SEARCHES; j++) {
                int num = (int) (Math.random() * MAX_VALUE);
                boolean search = binarySearch(array, num);
            }
            long endTime = System.currentTimeMillis();
            double seconds = (double) (endTime - startTime) / 1000.0;
            System.out.println("It took " + seconds + " seconds to search "
                    + NUMBER_SEARCHES + " numbers on an array of size: " + i);
        }
    }
    public static void demoBinarySearchFastSort() {
        System.out.println("testing Binary Search using built-in sort method");
        for (int i = ARRAY_INCREMENT; i < MAX_ARRAY_SIZE; i += ARRAY_INCREMENT) {
            int array[] = generateNumbers(i, MAX_VALUE);
            long startTime = System.currentTimeMillis();
            Arrays.sort(array);
            for (int j = 0; j < NUMBER_SEARCHES; j++) {
                int num = (int) (Math.random() * MAX_VALUE);
                boolean search = binarySearch(array, num);
            }
            long endTime = System.currentTimeMillis();
            double seconds = (double) (endTime - startTime) / 1000.0;
            System.out.println("It took " + seconds + " seconds to search "
                    + NUMBER_SEARCHES + " numbers on an array of size: " + i);
        }
    }
    public static int[] generateNumbers(int howMany, int maxValue) {
        if (howMany < 0) {
            return null;
        }
        int array[] = new int[howMany];
        for (int i = 0; i < howMany; i++) {
            array[i] = (int) (Math.random() * maxValue);
        }
        return array;
    }

    public static boolean linearSearch(int[] data, int search) {
        for (int i = 0; i < data.length; i++) {
            if (data[i] == search) {
                return true;
            }
        }
        return false;
    }
    public static boolean binarySearch(int[] data, int search) {
        int low = 0;
        int high = data.length - 1;
        int mid = 0;
        while (low <= high) {
            mid = (low + high) / 2;
            if (data[mid] == search) {
                return true;
            } else if (data[mid] < search) {
                low = mid + 1;
            } else {
                high = mid - 1;
            }
        }
        return false;
    }

    public static void selectionSort(int[] data) {
        int n = data.length;
        for (int i = 0; i < n - 1; i++) {
            int index_min = i;
            for (int j = i + 1; j < n; j++)
                if (data[j] < data[index_min])
                    index_min = j;
            int temp = data[index_min];
            data[index_min] = data[i];
            data[i] = temp;
        }
    }
}
-1
John Ferrier 13 फरवरी 2020, 22:08
2
क्या आप समझा सकते हैं कि आपका कोड क्या कर रहा है? वैसे, यह बहुत सारा कोड है, क्या इस प्रश्न के लिए यह सब आवश्यक है? देखें: न्यूनतम प्रतिलिपि प्रस्तुत करने योग्य उदाहरण
 – 
AMC
14 फरवरी 2020, 04:17
प्रश्न, मेरे उत्तर में मैं एक सरणी में एक संख्या की तलाश कर रहा हूं (क्रमबद्ध या नहीं) लेकिन आपके प्रश्न को दोबारा पढ़ रहा हूं, ऐसा लगता है कि आपके पास खोजने के लिए संख्याओं की एक सरणी है। वे नंबर कहां से आ रहे हैं?
 – 
blurfus
14 फरवरी 2020, 23:43
टिप्पणी: जब आप पूर्णांक की एक सरणी को केवल array नाम देते हैं, तो दूसरों के लिए यह बताना कठिन होता है कि सामग्री किस लिए है। परिवर्तनीय नाम उपयोगी होते हैं यदि वे वर्णन करते हैं कि वे क्या हैं, इसके बजाय वे क्या हैं। अर्थात। generatedNumbers, intArray से बेहतर है क्योंकि यह आपके कोड में अधिक पठनीयता जोड़ता है
 – 
blurfus
15 फरवरी 2020, 00:09

1 उत्तर

यदि आप इसका पुन: उपयोग करना चाहते हैं तो आप प्रत्येक विधि पर या विश्व स्तर पर एक स्थानीय चर जोड़ सकते हैं लेकिन सावधान रहें कि अन्य विधियां इसे ओवरराइड न करें। और हर बार जब संबंधित विधि का पुनरावृत्ति होता है तो वेरिएबल में +1 जोड़ें, खोज के अंत में यह खोजों की कुल संख्या वापस प्राप्त करेगा।

कुछ इस तरह:

public void searchMethod(.. ..){
  int counter=0;
  for(.. .. ..){
     ...
     ...
     counter++;
  }
  System.out.println("This is the total number of searches: "+counter);
  //if variable is declared globally reset it after each method counter=0;
}

0
Rattenfengar 13 फरवरी 2020, 22:18
क्या वह स्थानीय चर के लिए काम करेगा? मैं थोड़ा उलझन में हूं, इस मामले में लूप के अंदर क्या होगा?
 – 
John Ferrier
13 फरवरी 2020, 23:56
लूप के अंदर वह खोज विधि जाएगी जिसका आप उपयोग कर रहे हैं। यह स्थानीय चर के साथ काम करता है लेकिन इसे प्रत्येक खोज विधि में परिभाषित किया जाना है। आपकी खोज पद्धति में प्रत्येक पुनरावृति का अर्थ है एक नई "खोज", खोज पद्धति जितनी कम कदम उतनी ही अधिक कुशल होती है।
 – 
Rattenfengar
14 फरवरी 2020, 01:00
यह केवल खोज में +1 जोड़ता है। तो अब मुझे 50,001 मिल रहे हैं।
 – 
John Ferrier
14 फरवरी 2020, 01:43
मुझे लगता है कि आप NUMBER_SEARCHES नामक चर का उपयोग कर रहे हैं जो अंतिम है, इसलिए, हर बार जब काउंटर +1 जोड़ने का प्रयास करता है तो यह 50,001 "फाइनल" को हटा देता है, फिर से प्रयास करें, और सुनिश्चित करें कि आप काउंटर को सही जगह पर रख रहे हैं। प्रत्येक पुनरावृत्ति का अर्थ है एक नई खोज।
 – 
Rattenfengar
14 फरवरी 2020, 19:31