为什么在这种情况下快速排序的经过时间如此不规则，而应该严格增加？

Question

快速排序算法的平均时间复杂度是 O(nlogn)。这意味着它应该随着 n 值的增加而严格增加。 但是为什么在这种情况下时间是增加 - 减少 - 增加。 为什么它随着n值的增加而减小

我正在使用 java 的函数生成随机输入

解决办法是什么？

public class Qsort {
static Scanner sc = new Scanner(System.in);
public static void main(String args[]) throws IOException {
File file = new File("Qtest.txt");
PrintWriter output = new PrintWriter(file);
int n,i;
System.out.println("Enter the times of iteration");
n = sc.nextInt();
for(int j=1000;j<=n*1000;j=j+1000)
{
    Random r = new Random();
    int array[];
    array = new int[j];
    for(i=0;i<j;i++)
    {
        array[i] = r.nextInt(2000);
    }
    long startTime = System.nanoTime();
    Qsort(array,0,j-1);
    long endTime = System.nanoTime();
    output.println(j + " " + (endTime-startTime));
    System.out.println("After sorting the time elapsed is " +(endTime-startTime));
}
output.close();
}

快速排序的排序功能

public static void Qsort(int A[],int start,int end)
{
    if(start>=end)  return;
    int p = partition(A,start,end);
    Qsort(A,start,p-1);
    Qsort(A,p+1,end);
}
public static int partition(int A[],int start,int end)
{
    int pivot = A[end];
    int p = start;
    for(int i =start;i<end;i++)
    {
        if(A[i]<=pivot)
        {
            int temp = A[i];
            A[i] = A[p];
            A[p] = temp;
            p++;
        }
    }
    int temp = A[p];
    A[p] = A[end];
    A[end] = temp;
    return p;
}
}

我得到的输出：

输入迭代次数 10

对于 1000 个输入：排序后经过的时间为 779133

对于 2000 个输入：排序后经过的时间是 8350639

对于 3000 个输入：排序后经过的时间为 607856

对于 4000 个输入：排序后经过的时间是 833593

对于 5000 个输入：排序后经过的时间是 1042426

对于 6000 个输入：排序后经过的时间是 1283195

对于 7000 个输入：排序后经过的时间为 1497488

对于 8000 个输入：排序后经过的时间是 1261182

对于 9000 个输入：排序后经过的时间为 1207128

对于 10000 个输入：排序后经过的时间为 1427456

Answer 1

您的问题包含两件事：衡量算法复杂性和微基准测试。

算法时间复杂度适用于操作数。您正在测量的是快速排序所花费的时间 - 这使其成为微基准测试。

微基准测试很难。在第一次运行时，您很可能会看到 JVM 预热时间。在第二次下降时，它可能是指令缓存或 JIT 编译。我建议以在运行之前对 10000 个元素进行排序的方式重新运行测试！其他因素也可能会影响结果，例如您的机器中的 CPU 利用率、阵列中的随机性（有时交换发生有时它不会）——这通常需要微基准测试多次运行每个“实验”并得出结论以统计方式，使用标准误差、百分位数等，而不是从单个实验中得出。

底线：预热确实有助于消除一些 JVM 特定的噪音，并且操作数是时间复杂度的更精确度量。

下面的代码是您的代码的一个版本，用于计算操作次数并进行预热：

public class QSort {
    private static int numOps = 0;
    static Scanner sc = new Scanner(System.in);

    public static void main(String args[]) throws IOException {
        File file = new File("Qtest.txt");
        PrintWriter output = new PrintWriter(file);
        int n, i;
        System.out.println("warming up...");
        Qsort(randomInts(1000000), 0, 100000-1);
        System.out.println("Enter the times of iteration");
        n = sc.nextInt();
        for (int j = 1000; j <= n * 1000; j = j + 1000) {
            int[] array = randomInts(j);
            long startTime = System.nanoTime();
            numOps = 0;
            Qsort(array, 0, j - 1);
            long endTime = System.nanoTime();
            output.println(j + " " + (endTime - startTime) + " " + numOps);
            System.out.println("After sorting the time elapsed is " + (endTime - startTime) + " numOps: " + numOps);
        }
        output.close();
    }

    private static int[] randomInts(int j) {
        int i;Random r = new Random();
        int array[];
        array = new int[j];
        for (i = 0; i < j; i++) {
            array[i] = r.nextInt(2000);
        }
        return array;
    }

    public static void Qsort(int A[], int start, int end) {
        if (start >= end) return;
        int p = partition(A, start, end);
        Qsort(A, start, p - 1);
        Qsort(A, p + 1, end);
    }

    public static int partition(int A[], int start, int end) {
        int pivot = A[end];
        int p = start;
        for (int i = start; i < end; i++) {
            if (A[i] <= pivot) {
                int temp = A[i];
                A[i] = A[p];
                A[p] = temp;
                p++;
                numOps++;
            }
        }
        int temp = A[p];
        A[p] = A[end];
        A[end] = temp;
        return p;
    }
}

输出：

warming up...
Enter the times of iteration
20
After sorting the time elapsed is 94206 numOps: 5191
After sorting the time elapsed is 150524 numOps: 12718
After sorting the time elapsed is 232478 numOps: 20359
After sorting the time elapsed is 314819 numOps: 31098
After sorting the time elapsed is 475933 numOps: 38483
After sorting the time elapsed is 500866 numOps: 55114
After sorting the time elapsed is 614642 numOps: 57251
After sorting the time elapsed is 693324 numOps: 68683
After sorting the time elapsed is 738800 numOps: 83332
After sorting the time elapsed is 798644 numOps: 83057
After sorting the time elapsed is 899891 numOps: 99975
After sorting the time elapsed is 987163 numOps: 113854
After sorting the time elapsed is 1059323 numOps: 124735
After sorting the time elapsed is 1103815 numOps: 143278
After sorting the time elapsed is 1192974 numOps: 164740
After sorting the time elapsed is 1276277 numOps: 166781
After sorting the time elapsed is 1344138 numOps: 180460
After sorting the time elapsed is 1439943 numOps: 204095
After sorting the time elapsed is 1593336 numOps: 209483
After sorting the time elapsed is 1644561 numOps: 225523