Java 为什么3种算法的平均时间为负？

我必须使用大小从10000到50000的数组，步长为10000，为所有三种算法提供相同的输入，对于每个输入，重复执行100次，以纳秒为单位测量执行 （使用System.nanoTime（）），并以毫秒为单位报告平均时间。 这就是我在下面所做的，但有些平均值是负数，我不知道为什么

import java.util.Arrays;

public class Sort{

   public static void main(String[]args){

      double[] arr5 = new double[50000];

      for(int i=0;i<arr5.length;i++)
         arr5[i] = Math.random();

      selectionSort(arr5,10000);
      bubbleSort(arr5,10000);
      quickSort(arr5,10000);

      selectionSort(arr5,20000);
      bubbleSort(arr5,20000);
      quickSort(arr5,20000);

      selectionSort(arr5,30000);
      bubbleSort(arr5,30000);
      quickSort(arr5,30000);

      selectionSort(arr5,40000);
      bubbleSort(arr5,40000);
      quickSort(arr5,40000);

      selectionSort(arr5,50000);
      bubbleSort(arr5,50000);
      quickSort(arr5,50000);
   }

   public static void selectionSort(double [] A,int n){
      int sum = 0;
      System.out.println("Algorithm 1");
      for(int s=0;s<100;s++){
         long arr[] = new long[100];

         long startTime = System.nanoTime();

         for(int i=0;i<n-1;i++){
            int min = i;
            for(int j=i+1;j<n;j++){
               if(A[j] < A[min])
                  min=j;}
            double tmp = A[i];
            A[i] = A[min];
            A[min]=tmp;}

         long endTime = System.nanoTime();

         arr[s] = endTime - startTime;
      //System.out.println(arr[s]);
         sum+=arr[s];
      }
      System.out.println("Average:" + ((sum/100)*Math.pow(10,-6)));

   }

   public static void bubbleSort(double A [],int n){
      int sum = 0;
      System.out.println("\nAlgorithm 2");
      for(int s=0;s<100;s++){
         long[] arr = new long[100];

         long startTime = System.nanoTime();

         for(int i=0;i<n-1;i++){
            for(int j=0;j<n-1-i;j++){
               if(A[j]<A[j+1]){
                  double tmp = A[j];
                  A[j] = A[j+1];
                  A[j+1] = tmp;}}}

         long endTime = System.nanoTime();

         arr[s] = endTime - startTime;
      //System.out.println(arr[s]);
         sum+=arr[s];
      }
      System.out.println("Average:" + ((sum/100)*Math.pow(10,-6)));

   }

//algorithm 3
   public static void quickSort(double A [],int n){
      int sum = 0;
      System.out.println("\nAlgorithm 3");
      long[] arr = new long[100];

      for(int i=0;i<100;i++){
         long startTime = System.nanoTime();

         Arrays.sort(A,0,n-1);

         long endTime = System.nanoTime();

         arr[i] = endTime - startTime;
      //System.out.println(arr[i]);
         sum+=arr[i];
      }
      System.out.println("Average:" + ((sum/100)*Math.pow(10,-6)));

   }

}

导入java.util.array；
公共类排序{
公共静态void main（字符串[]args）{
double[]arr5=新的double[50000]；
对于（int i=0；i用于计算的变量
sum
类型为
int
。随着
sum
的增加，由于
endTime-startTime
的结果是一个相当大的值，因此它会溢出。当
sum
发生溢出时，它的值会返回到最小值（为负值）并继续增加

Fix：将
sum
的类型更改为
long

另一条评论

称为
arr
的数组似乎是冗余的，因为它们不用于计算，并且在每个循环中都会重置

例如，在
bubbleSort（）
方法中。在
For
循环中声明并初始化数组
long[]arr=new long[100]；
For（int s=0；s用于计算的变量
sum
类型为
int
。当您增加
sum
时，由于
endTime-startTime
的结果是一个相当大的值，它会溢出。当
sum
发生溢出时，它的值会返回到最小值（为负值）并继续增加

Fix：将
sum
的类型更改为
long

另一条评论

称为
arr
的数组似乎是冗余的，因为它们不用于计算，并且在每个循环中都会重置

例如，在
bubbleSort（）
方法中。在
For
循环中声明并初始化数组
long[]arr=new long[100]；
For（int s=0；sYea我刚刚发现int错误，但我不明白你所说的重置每个循环的意思你建议我做什么？@user7150641请阅读完整答案，他建议使用
long
是的，我刚刚发现int错误，但我不明白你所说的重置每个循环的意思你建议我做什么？@user7150641请阅读en答案是，他建议使用
long
另一个问题是您正在创建数组：
long arr[]=new long[100]；
在for循环内部…另一个问题是您正在创建数组：
long arr[]=new long[100]；
在for循环内部。。。
for (int i = 0; i < 5; i++) {
    int[] arr = new int[5];
    arr[i] = (i + 1);
    System.out.println(Arrays.toString(arr));
}

[1, 0, 0, 0, 0]
[0, 2, 0, 0, 0]
[0, 0, 3, 0, 0]
[0, 0, 0, 4, 0]
[0, 0, 0, 0, 5]

int[] arr = new int[5];
for (int i = 0; i < 5; i++) {
    arr[i] = (i + 1);
    System.out.println(Arrays.toString(arr));
}

[1, 0, 0, 0, 0]
[1, 2, 0, 0, 0]
[1, 2, 3, 0, 0]
[1, 2, 3, 4, 0]
[1, 2, 3, 4, 5]