将数组传递到分类方法以找到其执行时间

Question

我分配了这个项目，我需要在其中找到不同数组的执行时间。我的代码工作完全很好，除了我的数组从选择排序到气泡，从气泡到插入和合并时的部分。问题是当我的数组之间的数组之间的1-1000之间的随机数传递给了选择排序，然后将其分类，然后将排序的数组传递给其余的排序方法。我尝试再次浏览我的代码，但找不到问题。我应该填充一个数组吗？

任何帮助都将受到赞赏

package sorting;
import java.util.Arrays;
import java.util.Random;
import java.lang.Math;
import java.io.*;
import java.util.*;
public class sorting {
public static void main(String[] args) {
    double[] arr1 = getArray(10000);
    double[] arr2 = getArray(20000);
    double[] arr3 = getArray(40000);
    double[] arr4 = getArray(80000);
    System.out.println("Problem 1: Selection sort, Bubble sort, Insertion sort, and Merge sort with thier execution time");
    System.out.println("");
    System.out.printf("%12s%15s%15s%17s%13sn", "Number of Elements |", "Selection Sort", "Bubble Sort", "Insertion Sort", "Merge Sort");
    System.out.println("--------------------------------------------------------------------------------");
    long b = System.currentTimeMillis();
    long startTime = System.currentTimeMillis();
    selectionSort(arr1);
    long endTime = System.currentTimeMillis();
    long executionTime = endTime - startTime;
    System.out.printf("%11s", arr1.length);
    System.out.printf("%18s%2s", executionTime, " ms");

    startTime = System.currentTimeMillis();
    bubbleSort(arr1);
    endTime = System.currentTimeMillis();
    executionTime = endTime - startTime;
    System.out.printf("%12s%2s", executionTime, " ms");
    startTime = System.currentTimeMillis();
    insertionSort(arr1);
    endTime = System.currentTimeMillis();
    executionTime = endTime - startTime;
    System.out.printf("%12s%2s", executionTime, " ms");
    startTime = System.currentTimeMillis();
    (new MergeSort()).mergeSort(arr1);
    endTime = System.currentTimeMillis();
    executionTime = endTime - startTime;
    System.out.printf("%12s%2sn", executionTime, " ms");
    System.out.printf("%11s", arr2.length);
    startTime = System.currentTimeMillis();
    selectionSort(arr2);
    endTime = System.currentTimeMillis();
    executionTime = endTime - startTime;
    System.out.printf("%18s%2s", executionTime, " ms");
    startTime = System.currentTimeMillis();
    bubbleSort(arr2);
    endTime = System.currentTimeMillis();
    executionTime = endTime - startTime;
    System.out.printf("%12s%2s", executionTime, " ms");
    startTime = System.currentTimeMillis();
    insertionSort(arr2);
    endTime = System.currentTimeMillis();
    executionTime = endTime - startTime;
    System.out.printf("%12s%2s", executionTime, " ms");
    startTime = System.currentTimeMillis();
    (new MergeSort()).mergeSort(arr2);
    endTime = System.currentTimeMillis();
    executionTime = endTime - startTime;
    System.out.printf("%12s%2sn", executionTime, " ms");
    System.out.printf("%11s", arr3.length);
    startTime = System.currentTimeMillis();
    bubbleSort(arr3);
    endTime = System.currentTimeMillis();
    executionTime = endTime - startTime;
    System.out.printf("%18s%2s", executionTime, " ms");
    startTime = System.currentTimeMillis();
    bubbleSort(arr3);
    endTime = System.currentTimeMillis();
    executionTime = endTime - startTime;
    System.out.printf("%12s%2s", executionTime, " ms");
    startTime = System.currentTimeMillis();
    insertionSort(arr3);
    endTime = System.currentTimeMillis();
    executionTime = endTime - startTime;
    System.out.printf("%12s%2s", executionTime, " ms");
    startTime = System.currentTimeMillis();
    (new MergeSort()).mergeSort(arr3);
    endTime = System.currentTimeMillis();
    executionTime = endTime - startTime;
    System.out.printf("%12s%2sn", executionTime, " ms");
    System.out.printf("%11s", arr4.length);
    startTime = System.currentTimeMillis();
    bubbleSort(arr4);
    endTime = System.currentTimeMillis();
    executionTime = endTime - startTime;
    System.out.printf("%18s%2s", executionTime, " ms");
    startTime = System.currentTimeMillis();
    bubbleSort(arr4);
    endTime = System.currentTimeMillis();
    executionTime = endTime - startTime;
    System.out.printf("%12s%2s", executionTime, " ms");
    startTime = System.currentTimeMillis();
    insertionSort(arr4);
    endTime = System.currentTimeMillis();
    executionTime = endTime - startTime;
    System.out.printf("%12s%2s", executionTime, " ms");
    startTime = System.currentTimeMillis();
    (new MergeSort()).mergeSort(arr4);
    endTime = System.currentTimeMillis();
    executionTime = endTime - startTime;
    System.out.printf("%12s%2sn", executionTime, " ms");

}
 public static double[] getArray(int n){
    double[] arr = new double[n];
    for(int i=0; i<n; i++){
        arr[i] = ((double)(Math.random()*1000));
    }
    return arr;
}

public static void selectionSort(double[] arr) {
    for (int i = 0; i < arr.length - 1; i++) {
        double min = arr[i];
        int currentMin = i;
        for (int j = i + 1; j < arr.length; j++) {
            if (min > arr[j]) {
                min = arr[j];
                currentMin = j;
            }
        }
        if (currentMin != i) {
            arr[currentMin] = arr[i];
            arr[i] = min;
        }
    }
}
public static double[] insertionSort(double[] arr) {
    double temp;
    for (int i = 1; i < arr.length; i++) {
        for (int j = i; j > 0; j--) {
            if (arr[j] < arr[j - 1]) {
                temp = arr[j];
                arr[j] = arr[j - 1];
                arr[j - 1] = temp;
            }
        }
    }
    return arr;
}
public static double[] bubbleSort(double[] arr) {
    double temp;
    for (int i = 0; i < arr.length; i++) {
        // bubble up
        for (int j = 0; j < arr.length - 1 - i; j++) {
            if (arr[j] > arr[j + 1]) {
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
    return arr;
}
public static class MergeSort {
    private double[] array;
    private double[] temp;
    private int length;
    public double[] mergeSort(double[] arr) {
        this.array = arr;
        this.length = arr.length;
        this.temp = new double[length];
        merge1(0, length - 1);
        return arr;
    }
    private void merge1(int left, double right) {
        if (left < right) {
            double middle = left + (right - left) / 2;
            merge1(left, middle);
            merge1((int) (middle + 1), right);
            merge2(left, middle, right);
        }
    }
    private void merge2(int left, double middle, double right) {
        for (int i = left; i <= right; i++) {
            temp[i] = array[i];
        }
        int i = left;
        int j = (int) (middle + 1);
        int k = left;
        while (i <= middle && j <= right) {
            if (temp[i] <= temp[j]) {
                array[k] = temp[i];
                i++;
            } else {
                array[k] = temp[j];
                j++;
            }
            k++;
        }
        while (i <= middle) {
            array[k] = temp[i];
            k++;
            i++;
        }
    }
}
}

这就是我要输出的问题1：选择排序，泡泡排序，插入排序，并合并到其执行时间

Number of Elements | Selection Sort    Bubble Sort   Insertion Sort   Merge 
Sort
----------------------------------------------------------------------------
  10000                85 ms          31 ms          31 ms          16 ms
  20000               385 ms         100 ms         123 ms          10 ms
  40000              3085 ms         401 ms         347 ms           8 ms
  80000             13231 ms        1972 ms        1484 ms          35 ms

Answer 1

问题是当我的数组之间的数组在1-1000之间 通过选择排序，然后将其排序 数组将传递给其余的排序方法

您将发现原因的根源是java'通过"逐次参考"。或＆quot" by-value"？

对您来说，这是因为您在调用

时传递了数组arr1的值

selectionSort(arr1); 

在这种情况下，对arr1进行的操作更新了arr1。下次您将其传递给

bubbleSort(arr1); // this uses the updated array.

---

您可以更新代码以使用现有方法的随机生成数组：

selectionSort(getArray(10000)); // similarily for other cases