快速排序和霍尔分区

Question

我很难将带有 Hoare 分区的 QuickSort 转换为 C 代码，但不知道原因。我正在使用的代码如下所示：

void QuickSort(int a[],int start,int end) {
    int q=HoarePartition(a,start,end);
    if (end<=start) return;
    QuickSort(a,q+1,end);
    QuickSort(a,start,q);
}

int HoarePartition (int a[],int p, int r) {
    int x=a[p],i=p-1,j=r;
    while (1) {
        do  j--; while (a[j] > x);
        do  i++; while (a[i] < x);

        if  (i < j)
            swap(&a[i],&a[j]);
        else
            return j;
    }
}

另外，我真的不明白为什么HoarePartition 有效。有人可以解释它为什么有效，或者至少将我链接到一篇有效的文章吗？

我已经看到了分区算法的逐步完成，但我对它没有直观的感觉。在我的代码中，它甚至似乎都不起作用。例如，给定数组

13 19  9  5 12  8  7  4 11  2  6 21

它将使用枢轴 13，但以数组结尾

 6  2  9  5 12  8  7  4 11 19 13 21 

并将返回j，即a[j] = 11。我认为从该点开始并继续前进的数组应该具有都大于枢轴的值，但这里不是这样，因为 11

这里是 Hoare 分区的伪代码（来自 CLRS，第二版），如果有用的话：

Hoare-Partition (A, p, r)
    x ← A[p]
    i ← p − 1
    j ← r + 1
    while  TRUE
        repeat   j ←  j − 1
            until     A[j] ≤ x
        repeat   i ←  i + 1
            until     A[i] ≥ x
        if  i < j
            exchange  A[i] ↔ A[j]
        else  return   j 

谢谢！

编辑：

解决这个问题的正确 C 代码最终会是：

void QuickSort(int a[],int start,int end) {
    int q;
    if (end-start<2) return;
    q=HoarePartition(a,start,end);
    QuickSort(a,start,q);
    QuickSort(a,q,end);
}

int HoarePartition (int a[],int p, int r) {
    int x=a[p],i=p-1,j=r;
    while (1) {
        do  j--; while (a[j] > x);
        do  i++; while (a[i] < x);
        if  (i < j) 
            swap(&a[i],&a[j]);
        else 
            return j+1;
    }
}

Answer 1

我认为这段代码有两个问题。对于初学者，在您的快速排序功能中，我认为您想重新排序行

 int q=HoarePartition(a,start,end);
 if (end<=start) return;

这样你就有了它们：

 if (end<=start) return;
 int q=HoarePartition(a,start,end);

但是，您应该做的还不止这些；特别是这应该是

 if (end - start < 2) return;
 int q=HoarePartition(a,start,end);

原因是如果您尝试分区的范围大小为零或一，Hoare 分区将无法正常工作。在我的 CLRS 版本中，任何地方都没有提到这一点。我必须去 the book's errata page 才能找到这个。这几乎肯定是您遇到“访问超出范围”错误问题的原因，因为如果不变量被破坏，您可能会直接跑出数组！

至于对 Hoare 分区的分析，我建议从手动跟踪它开始。还有更详细的分析here。直观地说，它的工作原理是从范围的末端向彼此增加两个范围——一个在左侧包含小于枢轴的元素，一个在右侧包含大于枢轴的元素。这可以稍微修改以生成 Bentley-McIlroy 分区算法（在链接中引用），该算法可以很好地扩展以处理相等的键。

希望这会有所帮助！

Answer 2

你最后的 C 代码有效。但这并不直观。 幸运的是，现在我正在学习 CLRS。 在我看来，CLRS 的伪代码是错误的。（在 2e） 最后，我发现换个地方就好了。

 Hoare-Partition (A, p, r)
 x ← A[p]
     i ← p − 1
     j ← r + 1
 while  TRUE
        repeat   j ←  j − 1
            until     A[j] ≤ x
    repeat   i ←  i + 1
            until     A[i] ≥ x
    if  i < j
              exchange  A[i] ↔ A[j]
    else  
              exchnage  A[r] ↔ A[i]  
              return   i

是的，添加一个交换 A[r] ↔ A[i] 可以使它工作。 为什么？ 因为 A[i] 现在大于 A[r] OR i == r。 所以我们必须交换来保证分区的特性。

Answer 3

回答“为什么霍尔分区有效？”的问题：

让我们将数组中的值简化为三种：L 值（小于枢轴值），E 值（等于枢轴值） , 和 G 值（大于枢轴值的值）。

我们还将为数组中的一个位置指定一个特殊的名称；我们称这个位置为 s，它是过程结束时 j 指针所在的位置。我们是否提前知道 s 是哪个位置？不，但我们知道一些位置符合该描述。

使用这些术语，我们可以用稍微不同的术语来表达分区过程的目标：它将单个数组拆分为两个较小的子数组，这些子数组没有错误排序彼此。如果满足以下条件，则满足“未错误排序”的要求：

1. “低”子数组，从数组的左端到包括 s，不包含 G 值。
2. 在 s 之后立即开始并一直到右端的“high”子数组不包含 L 值。

这就是我们真正需要做的。我们甚至不需要担心 E 值在任何给定的传递中结束。只要每次传递都使子数组彼此正确，以后的传递就会处理任何子数组中存在的任何混乱。

所以现在让我们从另一边来解决这个问题：分区过程如何确保在 s 或它的左侧没有 G 值，以及s 右侧没有 L 值？

嗯，“s 右侧的值集”与“j 指针在到达 之前移动的单元格集相同” s”。而“s左侧并包括s的值的集合”与“i指针在j之前移动过的值的集合”相同em> 达到s”。

这意味着任何 错位的值在循环的某些迭代中都将位于我们的两个指针之一之下。 （为方便起见，假设它是指向 L 值的 j 指针，尽管它对于指向 a 的 i 指针完全相同G 值。）当 j 指针位于错位的值上时，i 指针会在哪里？我们知道它会是：

1. 在“低”子数组中的某个位置，L 值可以毫无问题地通过该位置；
2. 指向的值可以是 E 或 G 值，可以轻松替换 j 下的 L 值 指针。 （如果它不在 E 或 G 值上，它就不会停在那里。）

请注意，有时 i 和 j 指针实际上都会停在 E 值上。发生这种情况时，值将被切换，即使不需要它。不过，这不会造成任何伤害；我们之前说过 E 值的放置不会导致子数组之间的错误排序。

所以，总而言之，Hoare 分区之所以有效，是因为：

1. 它将一个数组分成更小的子数组，这些子数组彼此之间没有错误排序；
2. 如果您继续这样做并对子数组进行递归排序，最终数组中将没有任何未排序的内容。

Answer 4

您的最终代码是错误的，因为j 的初始值应该是r + 1 而不是r。否则你的分区函数总是忽略最后一个值。

实际上，HoarePartition 之所以有效，是因为对于任何包含至少 2 个元素（即 p < r）的数组 A[p...r]，当它终止时，A[p...j] 的每个元素都是 <= A[j+1...r] 的每个元素。 所以接下来主要算法重复的两个部分是[start...q]和[q+1...end]

所以正确的C代码如下：

void QuickSort(int a[],int start,int end) {
    if (end <= start) return;
    int q=HoarePartition(a,start,end);
    QuickSort(a,start,q);
    QuickSort(a,q + 1,end);
}

int HoarePartition (int a[],int p, int r) {
    int x=a[p],i=p-1,j=r+1;
    while (1) {
        do  j--; while (a[j] > x);
        do  i++; while (a[i] < x);
        if  (i < j) 
            swap(&a[i],&a[j]);
        else 
            return j;
    }
}

更多说明：

1. 分区部分只是伪代码的翻译。 （注意返回值为j）

2. 对于递归部分，请注意基本情况检查（end <= start 而不是end <= start + 1 否则您将跳过[2 1] 子数组）

Answer 5

1. 将枢轴移至第一个。 （例如，使用 3 的中位数。为小输入大小切换到插入排序。）
2. 分区，
   • 反复交换当前最左边的 1 和当前最右边的 0。
     0 -- cmp(val, pivot) == true, 1 -- cmp(val, pivot) == false。
     不左则停止
   • 之后，将枢轴与最右边的 0 交换。

Answer 6

首先你误解了Hoare的划分算法，从c中的翻译代码可以看出， 因为你认为枢轴是子数组的最左边的元素。

我会解释你将最左边的元素视为枢轴。

int HoarePartition (int a[],int p, int r) 

这里 p 和 r 代表数组的下界和上界，它可以是一个更大的数组的一部分，也可以是要分区的子数组。

所以我们从最初指向数组端点前后的指针（标记）开始（只需 bcoz 使用 do while 循环）。因此，

i=p-1,

j=r+1;    //here u made mistake

现在根据分区，我们希望枢轴左侧的每个元素都小于或等于枢轴并大于枢轴右侧的每个元素。

所以我们将移动“i”标记，直到我们得到大于或等于枢轴的元素。和类似的 'j' 标记，直到我们找到小于或等于枢轴的元素。

现在如果 i

do  j--; while (a[j] <= x);                 //look at inequality sign
do  i++; while (a[i] >= x);
if  (i < j) 
    swap(&a[i],&a[j]);

现在如果 'i' 不小于 'j'，这意味着现在中间没有元素可以交换，所以我们返回 'j' 位置。

所以现在分区下半部分后的数组是从'start到j'

上半部分是从'j+1到end'

所以代码看起来像

void QuickSort(int a[],int start,int end) {
    int q=HoarePartition(a,start,end);
    if (end<=start) return;
    QuickSort(a,start,q);
    QuickSort(a,q+1,end);
}

Answer 7

java 中的简单实现。

public class QuickSortWithHoarePartition {

    public static void sort(int[] array) {
        sortHelper(array, 0, array.length - 1);
    }

    private static void sortHelper(int[] array, int p, int r) {
        if (p < r) {
            int q = doHoarePartitioning(array, p, r);
            sortHelper(array, p, q);
            sortHelper(array, q + 1, r);
        }
    }

    private static int doHoarePartitioning(int[] array, int p, int r) {
        int pivot = array[p];
        int i = p - 1;
        int j = r + 1;

        while (true) {

            do {
                i++;
            }
            while (array[i] < pivot);

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

            if (i < j) {
                swap(array, i, j);
            } else {
                return j;
            }
        }

    }

    private static void swap(int[] array, int i, int j) {
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }
}