使用 Javascript 进行快速排序的大 O 问题

Question

我正在使用 QuickSort，我在 LeetCode 上为this problem 测试了这两种算法。两种算法都有效，但一种似乎比另一种快得多，我不明白为什么。

这个超出了 LeetCode 的时限：

function quickSort(array) {
    quickSortHelper(array, 0, array.length - 1);
    return array;
}

function quickSortHelper(array, start, end) {
    // Edge case
    if(start >= end) return;
    // Always choose the pivot index at the beginning of the array.
    const pivot = start;
    // The left index is next to the pivot on the right.
    let left = start + 1;
    let right = end;

    while (right >= left) {
        if (array[left] > array[right] && array[right] < array[pivot])
            swap(left, right, array);
        if (array[left] < array[pivot]) left += 1;
        if (array[right] > array[pivot]) right -= 1;
    }

    swap(pivot, right, array);

    // Always sort the smaller sub-array first
    const leftIsSmaller = right - 1 - start < end - (right + 1);

    if (leftIsSmaller) {
        quickSort(array, start, right - 1);
        quickSort(array, right + 1, end);
    }
    else {
        quickSort(array, right + 1, end);
        quickSort(array, start, right - 1);
    }
}

function swap(a, b, array) {
    [array[a], array[b]] = [array[b], array[a]];
    return array;
}

大O：

• 最差：时间 = O(n^2)，因为如果主元不断被交换到未排序部分的末尾，那么我们每次都有 O(n - 1) ~ O(n) = O(n*n )
• 最佳：当枢轴将数组分成两半时，时间 = O(nlog(n))。
• 平均：时间 = O(nlog(n))
• Space = O(log(n))，因为递归使用 2 个子数组并首先针对较小的子数组进行快速排序。

这个没有超过 LeetCode 的时间限制，并且比大多数提交都快得多。大 while 循环中的 2 个 while 循环（对我而言）似乎更慢，但实际上更快。

function quickSort(array) {
    sortHelper(array, 0, array.length - 1);
    return array;
}

function sortHelper(array, start, end) {
    if (start >= end) return;
    let i = start;
    let j = end;
    let base = array[i];

    while (i < j) {
        while (i < j && array[j] >= base) j -= 1; // This makes sense but why this while loop has to happen before the other while loop?
        array[i] = array[j]; // this line
        while (i < j && array[i] <= base) i += 1;
        array[j] = array[i]; // and this line. don't they make you lose access to the values in the array?
    }
    array[i] = base;
    sortHelper(array, start, i - 1);
    sortHelper(array, i + 1, end);
}

这是为什么呢？

Answer 1

时间复杂度没有区别，但第一个版本经常多次执行相同（或相反）的数据比较。这在第二个版本中没有发生。

例如，假设对于以下if，第一个表达式为真，第二个为假，并且在多次迭代中：

 if (array[left] > array[right] && array[right] < array[pivot])

...那么第一个表达式被检查多次确实是一种浪费，因为left 在第一个表达式为真时不会从一个迭代更改为下一个迭代。

以这个极端示例数组为例：[1, 6, 3, 2, 5, 4]

轴心为 1。

在所有迭代期间，right 索引将减小，直到到达左侧。每次迭代的比较次数为 4，因此 5 次迭代加起来为 20。

现在看看更快的算法。对于相同输入，第一个内部循环的比较次数为 5，第二个内部循环为 0（我只计算 data 比较）。

这是一个极端的例子（20 对 5），但在更多随机输入的情况下发生的程度也较小。