快速排序说明答案

【问题标题】：Quick sort explanation快速排序说明
【发布时间】：2015-12-02 22:05:21
【问题描述】：

我在学习快速排序，发现算法解释了here

据我所知，但我在其中一个步骤中有一个问题。

有人可以正确地解释我在枢轴 57 保持在其正确位置之前的步骤是什么，如果这一点中的数字 76 如图所示是 7 吗？

我认为如果读者首先看到幻灯片中解释的步骤会更有帮助，因为我发现还有许多其他不同的方法可以解释快速排序算法。

已编辑： 我猜最后的排序会像

24 49 16 38 55 21 36 9 *7 *57 81 85 63 79 74 85 97 61 77 70 *68。（如 nullpointer 所述）

当蓝色发现 68 作为右侧最大元素并且跳过检查较小元素作为蓝色交叉/遇到红色索引时，流是否停止了？

【问题讨论】：

你会用蓝色跳过 7，用红色在 7 处停止，比76 向右移动一个元素
分区步骤的目的是确定所有小元素都放在大元素的左侧。小/大分类是通过与“枢轴”值进行比较来决定的。为了让算法进步，必须确保至少有一个小元素和一个大元素。
@YvesDaoust 正如你所提到的，应该有一个小的 AND 一个大的（需要两个数字），在上述情况下的流程是什么，因为只有一个元素留待比较。
当只剩下一个元素时，分区是没有意义的。
@YvesDaoust 你能根据幻灯片中解释的流程告诉我最后一个问题的答案吗？我担心的是跳过检查较小元素部分？

标签： algorithm sorting quicksort

【解决方案1】：

续..[* 蓝色指针； ** 红色指针； *** 空的] 枢轴=57

=> 24  49  16  38  55  21  36  *68  7  **9  81  85  63  79  74  85  97  61  77  70  ***

=> 24  49  16  38  55  21  36  *9  7  **68  81  85  63  79  74  85  97  61  77  70  ***

我希望事情能按原样清楚。 9 和 68 互换。现在，从右端开始的下一个小于 57 的数字是 7（所以 **），而比左端更大的数字是 68（所以 *）。

 => 24  49  16  38  55  21  36  9  **7  *68  81  85  63  79  74  85  97  61  77  70  ***

但由于索引不再满足条件，因此带有红色指针的数字 68 将被移动到空白处，而 57 将移动到它的中间位置。因此顺序应该是：

=> 24  49  16  38  55  21  36  9  **7  *57  81  85  63  79  74  85  97  61  77  70  ***68

【讨论】：

您能否像幻灯片中解释的那样向我解释一下。我猜顺序会是这样的，但是如何？
@Tootsie_Roll 编辑了答案...虽然没有图表，但试图提供更好的视觉效果
在您的流程中，您首先尝试找到较小的元素。先找到较小元素还是先找到较大元素的优先级重要吗？
不，不是，它们都是在同一个步骤中搜索的
我的重要疑问是，在我的问题 xxxx 中提到的左侧 9 和 68 直到 xxxx 空白已按枢轴排序。而唯一剩下要比较的地方就是7的位置，所以按照你的说法，即使在已经排序的区域（即68处），也需要找到右侧最大的元素？

【解决方案2】：

快速排序的一种变体：

void swap(int *i, int *j)
{
    int t = *i;
    *i = *j;
    *j = t;
}

void QuickSort(int a[], int lo, int hi) {
    int i = lo, j = (lo + hi)/2, k = hi;
    int pivot;
    if (a[k] < a[i])            // median of 3
        swap(a+k, a+i);
    if (a[j] < a[i])
        swap(a+j, a+i);
    if (a[k] < a[j])
        swap(a+k, a+j);
    pivot = a[j];
    showa(lo, hi);
    while (i <= k) {            // partition
        while (a[i] < pivot)
            i++;
        while (a[k] > pivot)
            k--;
        if (i <= k) {
            swap(a+i, a+k);
            i++;
            k--;
            showa(lo, hi);
        }
    }
    if (lo < k)                 // recurse
        QuickSort(a, lo, k);
    if (i < hi)
        QuickSort(a, i, hi);
}

输出，在交换的数字后带有“*”：

57 70 97 38 63 21 85 68 76  9 81 36 55 79 74 85 16 61 77 49 24 
24*70 97 38 63 21 85 68 76  9 57*36 55 79 74 85 16 61 77 49 81*
24 49*97 38 63 21 85 68 76  9 57 36 55 79 74 85 16 61 77 70*81 
24 49 16*38 63 21 85 68 76  9 57 36 55 79 74 85 97*61 77 70 81 
24 49 16 38 55*21 85 68 76  9 57 36 63*79 74 85 97 61 77 70 81 
24 49 16 38 55 21 36*68 76  9 57 85*63 79 74 85 97 61 77 70 81 
24 49 16 38 55 21 36 57*76  9 68*85 63 79 74 85 97 61 77 70 81 
24 49 16 38 55 21 36 57  9*76*68 85 63 79 74 85 97 61 77 70 81 
 9*49 16 38 24*21 36 57 55*                                    
 9 21*16 38 24 49*36 57 55                                     
 9 21 16 24*38*49 36 57 55                                     
 9 21 16 24                                                    
 9 16*21*24                                                    
 9 16                                                          
 9 16                                                          
      21 24                                                    
      21 24                                                    
            36*49 38*57 55                                     
            36 38*49*57 55                                     
            36 38                                              
            36 38                                              
                  49 55*57*                                    
                  49 55 57                                     
                           74*68 85 63 79 76*85 97 61 77 70 81 
                           74 68 70*63 79 76 85 97 61 77 85*81 
                           74 68 70 63 61*76 85 97 79*77 85 81 
                           74 68 70 63 61 76 85 97 79 77 85 81 
                           61*68 70 63 74*                     
                           61 68 63*70*74                      
                           61 63*68*                           
                           61 63 68                            
                                    70 74                      
                                    70 74                      
                                             79*97 81*77 85 85*
                                             79 77*81 97*85 85 
                                             79 77 81 97 85 85 
                                             77*79*            
                                             77 79             
                                                      85*85 97*
                                                      85 85 97 
                                                         85 97 
                                                         85 97 
 9 16 21 24 36 38 49 55 57 61 63 68 70 74 76 77 79 81 85 85 97

【讨论】：