Question

从互联网上快速排序的示例实现是：

public void quickSort(int[] arr, int low, int high) {
        if (arr == null || arr.length == 0)
            return;

        if (low >= high)
            return;

        int middle = low + (high - low) / 2;
        int pivot = arr[middle];


        int i = low, j = high;
        while (i <= j) {
            while (arr[i] < pivot) {
                i++;
            }

            while (arr[j] > pivot) {
                j--;
            }

            if (i <= j) {
                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
                i++;
                j--;
            }
        }


        if (low < j)
            quickSort(arr, low, j);

        if (high > i)
            quickSort(arr, i, high);
    }
}

为什么最外面的循环i<= j而不是i <j？
在递归调用之前，为什么检查low < j和high > i因为低是最左边的元素而高是最右边的元素？
为什么交换发生if (i <= j)？不应该是i<j吗？当然，如果他们是平等的，那就自己换了吗？

Answer 1

因为您要从0到n
因为您必须分开表来检查和排序其他项目

阅读有关此排序类型的更多信息，所有排序类型 - 然后这将是明确和简单的：）

Answer 2

因此，它避免在排序左右部分时包含i == j元素。
因此它避免了排序空数组（low == j）
交换自己是的，但仍然需要移动++ i和--j，因为它与（1）中已经回答的相同。

Answer 3

这是因为我们不希望在后续排序调用中包含i == j的点。这样，我们不会对该点进行两次排序。
我不知道。剔除也在下一步完成。
是的，这是因为编写代码需要更多行代码。

Answer 4

i＆lt; = j的使用与递归调用quickSort（arr，low，j）相关;和quickSort（arr，i，high）;.
递归调用之前的if是多余的，但是避免进行刚刚返回的递归调用。第一个if语句用于处理初始调用。
交换比使用另一个if语句花费更少的CPU时间。

Hoare分区方案类似，但是它使用预递减和预递增，并且当i> = j时断开（如同i＆lt; j）。 C ++示例：

void QuickSort(int a[], int lo, int hi)
{
    if (lo >= hi)
        return;
    int p = a[(lo + hi) / 2];
    int i = lo, j = hi;
    i--;                        // partition
    j++;
    while (1)
    {
        while (a[++i] < p) ;
        while (a[--j] > p) ;
        if (i >= j)
            break;
        std::swap(a[i], a[j]);
    }
    QuickSort(a, lo, j);
    QuickSort(a, j + 1, hi);
}

用Java实现QuickSort

4 个答案: