搜索数组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 
    } 
}