搜索數組10次，並計算每次搜索的時間

Question

我想創建一個1000萬的數字從1到1000萬的數組。我正在使用循環來填充數組（1的增量）。現在我想用第二個數組數組搜索第一個數組10次（創建一個循環來搜索10次）（例如int arr2 [] = {10，20，...}）然後我想計算時間所花費的每一次檢索，平均值和標準偏差，然後打印出結果在表 表我只是用「\ t」的 打印這是我到目前爲止有：

public class LinearBinearySearch { 

    public static void main(String[] args) { 

     System.out.println("By linear search:\n" + check[k] + " found at index " + found +"\t"); 
     System.out.println("Table below shows result:"); 
     System.out.print("First run\tSecond run\tThird run\tFourth run\tFifth run\tSixth run\tSeventh run\tEight run\tNinth run\tTenth run\tAverage \tStandard deviation\n"); 

     arrPoplte(); 

     linSrch(); 


     loopCheck(); 
    } 


static int i = 0; 
static int k = 0; 
static int[]Arr = new int[10000000]; 
static int[]check = {500, 10000, 100000, 1000000, 5000000, 7000000, 10000000}; 
public static void loopCheck(){ 


} 

public static void arrPoplte(){ 
    for(int i = 0; i < Arr.length; i ++){ 
     Arr[i] = i + 1; 

    } 

} 
static int found = 0; 
static long start; 
static long end; 
public static void linSrch(){ 



    long sum = 0; 
    long sumSquare = 0; 

     for(int c = 0; c < 10 ; c++){ 

     start = System.nanoTime(); 
     while(Arr[i]<check.length){ 
      if(Arr[i]==check[i]) 
       System.out.print(Arr[i]); 
      end = System.nanoTime(); 
      sum += end - start; 
       sumSquare += Math.pow(end - start, 2); 
     } 









    System.out.print((end - start) +"\t\t"); 
     } 
     double average = (sum * 1D)/10; 
     double variance = (sumSquare * 1D)/10 - Math.pow(average, 2); 
     double std = Math.sqrt(variance); 
     System.out.print(average +"\t\t" + std + "\n");  

但是1.我認爲它的代碼太多，2.我無法循環訪問第二個數組以使用第一個數值

這是我期望的輸出： 500被發現在任何索引 1st ru n第二輪運行.............第十輪運行平均標準開發。 x ms y ms z ms av ms無論它是什麼

如何調整我的代碼以產生所需的輸出。

我提前道歉了這麼長的問題，我希望有人能幫助我 謝謝

Answer 1

說得很簡單，有很多東西你的代碼錯誤。首先，它不能在我的電腦上工作（甚至不會編譯，因爲你粘貼到SO上）。

因此，我重寫了它，因爲我無法對正在發生的事情做正面或反面。我還包括了我希望有幫助的評論。

import java.util.Random; 

public class SearchBenchmark { 

    public static void main(String[] args) { 
     SearchBenchmark sBenchmark = new SearchBenchmark(); // I don't like the word 'static'. You can disregard all of 
                   // this 
     sBenchmark.init(); // Execute the meat of the program 
    } 

    private void init() { 

     int maxAttempts = 10; // Set how many times we're doing this 

     long[] times = new long[maxAttempts]; // Create something to hold the times which we want to run this 
     int[] range = populateArray(10000000); // Initialise the array with the given range 

     Random rand = new Random(); // Create random integer generator 
     int[] target = new int[maxAttempts]; // Create an array filled with the target of our searches 

     // Populate target with random integers, since having preselected ones will bias your sample. 
     for (int x = 0; x < target.length; x++) { 
      target[x] = rand.nextInt((10000000 - 1) + 1) + 1; 
     } 

     // Execute the attempts 
     for (int attempt = 0; attempt < maxAttempts; attempt++) { 

      long startTime = System.nanoTime(); // Starting time 

      int result = search(range, target[attempt]); // Find it 
      if (result == 0) { 
       throw new RuntimeException("It's not in the range."); // Make sure we actually have it 
      } 

      long endTime = System.nanoTime(); // Ending time 
      long elapsed = endTime - startTime; // Difference 
      times[attempt] = elapsed; // Save the elapsed time 
     } 

     // ==== Summarisation section ==== 

     // Print out times and produce a sum 
     int sum = 0; 
     for (int attempt = 0; attempt < maxAttempts; attempt++) { 
      sum = (int) (sum + times[attempt]); 
      System.out.println("Attempt " + attempt + " took " + times[attempt] + " nanoseconds"); 
     } 

     // Print out average 
     int average = sum/maxAttempts; 
     System.out.println("Average time: " + average + " nanoseconds"); 

     // Create and print the standard deviation 
     int sumSquares = 0; 
     for (int x = 0; x < maxAttempts; x++) { 
      sumSquares = (int) (sumSquares + Math.pow(times[x] - average, 2)); 
     } 

     int std = (int) Math.sqrt(sumSquares/maxAttempts); 
     System.out.println("Standard deviation: " + std + " nanoseconds"); 
    } 

    /** 
    * Searches for the target within a range of integers 
    * 
    * @param range to search within 
    * @param target to find 
    * @return the target if it exists, otherwise, 0 
    */ 
    private int search(int[] range, int target) { 
     for (int x : range) { // Iterate through the entire range 
      if (x == target) { return x; } // If you found it, return it and stop searching 
     } 

     return 0; // If we can't find it, return 0 
    } 

    /** 
    * Creates and populates an array from 0 to a variable <code>i</code> 
    * 
    * @param i the maximum amount to which the array should be populated 
    * @return an array with the range contained within 
    */ 
    private int[] populateArray(int i) { 
     int[] array = new int[i]; // Create an array of the size indicated 
     for (int x = 0; x < i; x++) { // Populate that array with the range desired 
      array[x] = x; 
     } 
     return array; // Give it back 
    } 
}