Java I'；m合并排序长度为10000到75000的整数数组。我的时间越来越奇怪了。为什么会这样？

我正在为我的算法类做一个赋值，我必须证明内部合并排序的时间复杂度为O（n logn）。为此，我制作了长度从10000个元素到75000个元素的数组。然后，我加载随机数低于10000的数组，并将数组长度输出到控制台，其中包含排序所需的时间

奇怪的结果是，有些数组需要约15毫秒的给定或获取时间，而另一些数组则需要0毫秒，即使数组的长度超过数万个整数。你知道为什么会这样吗？我可以上传我的输出的屏幕截图，但需要有人批准，因为我没有足够的“声誉”。我已经检查了阵列。调用

mergeSort（）

方法后，它们看起来确实被排序了

public static void main(String[] args){
    int[] dataLength = { 10_000, 15_000, 20_000, 25_000, 30_000,
                         35_000, 40_000, 45_000, 50_000, 55_000,
                         60_000, 65_000, 70_000, 75_000 };
    // internal merge sort
    for (int i = 0; i < dataLength.length; i++) {
        int[] input = new int[dataLength[i]];
        for (int j = 0; j < input.length; j++) {
            input[j] = random.nextInt(10000);
        }

        long startTime = System.currentTimeMillis();
        mergeSort(input, 0, input.length);
        long endTime = System.currentTimeMillis();

        System.out.println("Length of array is: " + input.length + ". The sorted array: " +
                           Arrays.toString(input));
        System.out.println("Internal sort with " + dataLength[i] + " items took: " +
                           (endTime - startTime) + " milliseconds");
    }
}

public static void mergeSort(int[] input, int start, int end) {
    if (end - start < 2) {
        return;
    }

    int mid = (start + end) / 2;
    mergeSort(input, start, mid);
    mergeSort(input, mid, end);
    merge(input, start, mid, end);
    return;
}

public static void merge(int[] input, int start, int mid, int end) {
    if (input[mid - 1] <= input[mid]) {
        return;
    }
 //        index of "left" array
    int i = start;
 //        index of "right" array
    int j = mid;
    int tempIndex = 0;
    int[] temp = new int[end - start];

    while (i < mid && j < end) {
        temp[tempIndex++] = input[i] <= input[j] ? input[i++] : input[j++];
    }
 //        optimizes the merge. If there are elements in the left array we just copy them back
 //        into the input array instead of merging them with the temp array first
    System.arraycopy(input, i, input, start + tempIndex, mid - i);
    System.arraycopy(temp, 0, input, start, tempIndex);
    return;
}

publicstaticvoidmain（字符串[]args）{
int[]数据长度={10_000，15_000，20_000，25_000，30_000，
35_000, 40_000, 45_000, 50_000, 55_000,
60_000, 65_000, 70_000, 75_000 };
//内部合并排序
for（int i=0；i如果（输入[mid-1]可能只是热点预热时间。我建议使用JMH进行性能测试。如果您在表格中显示实际结果，这将非常有用，例如，在表格中，您还可以在运行排序之前显示数组的顺序，这需要编写一个小函数来测试有多少元素在开始排序时出现错误因为一个75000项的数组已经大部分排序，它的排序速度要比一个10000项的数组快得多，而10000项数组完全没有顺序，但是在你验证之前，你是在让人们猜测。猜测并不是答案。我认为@TomHawtin tackline指的是热点JVM的启动成本。你不希望这段时间成为一个变量w在进行测试时。@VM的选择在解释代码和编译之间进行交换。不仅解释的性能和编译的性能之间存在显著差异，而且编译也需要时间。另一件事是，在如此短的时间内，时钟可能没有足够的精度。
System.nanoTime
sh会更好的。