Java 为什么我的不同排序算法会导致相同的运行时间？

对于CS作业，我要用java创建大小不断增加的随机数组，并将它们的运行时间绘制在一个图表上。但是，我的Insert、Merge和Quick sort实现在使用相同输入运行时似乎具有相同的运行时间。我多次以不同的方式实现了它们，但仍然得到相同的结果。这是我的密码：

import java.util.*; import java.util.Random;

public class Complexity {

public static void main(String[] args) {
    // TODO Auto-generated method stub
    Scanner input= new Scanner(System.in);
    System.out.println("Enter the array size: ");
    int a = input.nextInt(); 
    System.out.println("Enter the number size: ");
    int n = input.nextInt();

    int[] arr = newArr(a, n);
    int[] arr2 = arr.clone();
    int[] arr3 = arr.clone();

//INSERT SORT
    long startTime = System.nanoTime();
    insertSort(arr);
    long endTime = System.nanoTime();
    long duration = (endTime - startTime)/1000000;
    System.out.println("Insert Sort Time:" + duration + "ms");

//MERGE SORT
    long start = System.nanoTime();
    mergeSort(arr2, 0, a-1);
    long end = System.nanoTime();
    long dur = (end - start)/1000000;
    System.out.println("Merge Sort Time:" + duration + "ms");

//QUICK SORT
    long s = System.nanoTime();
    quickSort(arr3, 0, a-1);
    long e = System.nanoTime();
    long d = (e - s);
    System.out.println("Quick Sort Time:" + duration + "ms");
}


public static int[] newArr(int a, int n) {
    Random rand = new Random();
    int newArray[] = new int[a];
     for (int i = 0; i < a; i++) {
         int number= rand.nextInt(n);
         newArray[i]=number;
     }
    return newArray;
}

public static void quickSort(int[] arr, int low, int high) {
    if(low<high) {
        int pivotIndex = findPivot(arr, low, high);
        quickSort(arr, low, pivotIndex-1);
        quickSort(arr, pivotIndex+1, high);
    }
}

public static int findPivot(int[] arr, int low, int high) {
    int pivot = arr[high];
    int nextSmallest = (low-1);
    for(int currentIndex = low; currentIndex < high; currentIndex++) {
        if(arr[currentIndex] <= pivot) {
            nextSmallest++;
            int temp = arr[nextSmallest];
            arr[nextSmallest] = arr[currentIndex];
            arr[currentIndex] = temp;
        }
    }
    int temp = arr[nextSmallest+1];
    arr[nextSmallest+1] = arr[high];
    arr[high] = temp;
    return nextSmallest+1;
}

public static void mergeSort(int[] arr, int left, int right){
    if(left<right) {
        int middle = (left + right) / 2;
        mergeSort(arr, left, middle);
        mergeSort(arr, middle+1, right);
        merge(arr, left, middle, right);
    }
}

public static void merge(int[] arr, int left, int middle, int right){
    int leftLength = middle - left + 1;
    int rightLength = right - middle;
    int newL[] = new int [leftLength];
    int newR[] = new int [rightLength];
    for (int i=0; i<leftLength; ++i)
        newL[i] = arr[left + i];
    for (int j=0; j<rightLength; ++j)
        newR[j] = arr[middle + 1+ j];
    int i = 0, j = 0;
    int k = left;
    while (i < leftLength && j < rightLength) {
        if (newL[i] <= newR[j]) {
            arr[k] = newL[i];
            i++;
        }
        else {
            arr[k] = newR[j];
            j++;
        }
        k++;
    }
    while (i < leftLength) {
        arr[k] = newL[i];
        i++;
        k++;
    }
    while (j < rightLength) {
        arr[k] = newR[j];
        j++;
        k++;
    }
}

static void printArray(int arr[], String methodName) {
        System.out.print(methodName);
    int n = arr.length;
    for (int i=0; i<n; ++i)
        System.out.print(arr[i] + " ");
    System.out.println();
}

public static void insertSort(int[] arr){
    int temp;
    for(int i = 0; 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;
            }
        }
    }
}
}

import java.util.*；导入java.util.Random；
公共类复杂性{
公共静态void main（字符串[]args）{
//TODO自动生成的方法存根
扫描仪输入=新扫描仪（System.in）；
System.out.println（“输入数组大小：”）；
int a=input.nextInt（）；
System.out.println（“输入数字大小：”）；
int n=input.nextInt（）；
int[]arr=newArr（a，n）；
int[]arr2=arr.clone（）；
int[]arr3=arr.clone（）；
//插入排序
long startTime=System.nanoTime（）；
插入排序（arr）；
long-endTime=System.nanoTime（）；
长持续时间=（结束时间-开始时间）/1000000；
System.out.println（“插入排序时间：“+持续时间+”毫秒”）；
//合并排序
长启动=System.nanoTime（）；
合并排序（arr2，0，a-1）；
long end=System.nanoTime（）；
长dur=（结束-开始）/1000000；
System.out.println（“合并排序时间：“+持续时间+”毫秒”）；
//快速排序
long s=System.nanoTime（）；
快速排序（arr3，0，a-1）；
long e=System.nanoTime（）；
长d=（e-s）；
System.out.println（“快速排序时间：“+持续时间+”毫秒”）；
}
公共静态int[]newArr（int a，int n）{
Random rand=新的Random（）；
int newArray[]=新int[a]；
for（int i=0；i如果（低您的每个打印语句都从插入排序而不是从
dur
打印
duration
，
d
，您的每个打印语句都从插入排序而不是从
dur
打印
duration
，
d
打印
dur
而不是
dur
，
d
，很可能您正在制作的数组太小，无法产生不同的结果。）nce。此外，您正在删除整数，这会截断微秒。输入有多大？请记住，时间复杂度是渐进的，因此输入需要很大才能产生任何差异。相关：似乎您可以声明变量
long start、end、duration；
并重用它们，而不是声明ne每次都有新名称的w个变量。您忘记了除以1000000进行快速排序。很可能是因为数组太小而无法产生差异。此外，您正在删除整数，这会截断微秒。输入有多大？请记住，时间复杂度是渐进的，因此输入需要更大似乎你可以声明你的变量
长的开始、结束、持续时间；
然后重用它们，而不是每次用新的名称声明新的变量。而且你忘记了除以1000000进行快速排序。