快速排序

关注

原创最新推荐文章于 2026-08-08 10:47:13 发布 7.6k 阅读 AI 写同款· GEO 优化 ›

微信小程序返回按钮的隐藏玩法：用onShow实现数据自动刷新（附完整代码）本文深入探讨了微信小程序中用户点击返回按钮后，如何利用onShow生命周期函数实现页面数据的自动刷新。文章对比了onLoad与onShow的差异，提供了从基础的本地存储标记到进阶的EventChannel事件通信，再到状态管理库的多种解决方案，并附有完整的代码示例，帮助开发者构建流畅的用户体验。阅读详情

排序算法是各种笔试，面试最常考到的一类题目，提到排序，一定会要求提供一种高效的方法，所以就不得不说一下快速排序了。快嘛！

写出快速排序一定要先理解什么是枢纽元（pivot），枢纽元就是每次执行快排需要参照的那个元素。

最常见的选择pivot的方法是选择第一个元素。此外还有最后一个元素，随机选择，中值法等等。

比如 20,34,4,53,43,42,6,67,193 选择20为pivot经过一趟快速排序后会达到：

6,4,20,53,43,42,34,67,193 过程可参见动画http://www.jcc.jx.cn/xinwen3/news/kj/flash/2004/0426/1306.htm

由此我们也可以看到快速排序每次的目的就是找到枢纽元的准确位置，

即小于枢纽元的数 | 枢纽元 | 大于等于枢纽元的数

所以只要你能每趟排序达到这样的效果，就可以条条大陆通罗马了。

实现快速的排序的难点在于，

(1) 如何停止递归，即什么时候return？

比较容易记忆的方式是：在 start>=end 时 return，很明显这时表示待排序的序列只有一个或0个元素。不需要做任何处理，所以返回。

(2) i,j越界问题。

编写程序时，只要单独考虑到以下三条特例情况，如果不出问题通常可以满足越界要求了：

1. 2个元素的排序，

2. i++到end时，

3. j--到为-1时。

(3) 如何停止i++,j--操作，即什么时候算是完成一趟快速排序操作？

通常i++，j--外面要包一层循环，问题也就变成了，如何停止这个循环。

比较常见的做法是：

do{

}

while(i<j)

当然也可用：

for(; ;)

{

if (i < j)

{...}

else

break;

}

(4) 如果序列有相等元素怎么办？

一种常见方法是，对于j--操作要求判断条件为 <= 而不是<

具体对于这4个难点的解决参见下面的代码片段：

//注意，该函数是以最后一个元素p[end]为pivot。
QuickSort(int p[], int start, int end)
{
    if (start >= end) //(1)此时无需排序，所以返回。(2).1 这还保证了，如果只有2个元素时，j=end-1 =1>0
        return;
    int i = start, j = end - 1;
    int tmp;
    do
    {
        while(p[i]<p[end]){i++;}
        while(p[j]>=p[end]){j--;} //(4) 解决相等元素问题。
         if (i<j)
           swap(p[i], p[j]);
        else
           swap(p[i], p[end]);//确定pivot的准确位置。
    }
    while(i < j);
    //(3)至此完成了一趟快速排序得到：小于pivot的数 | pivot | 大于等于pivot的数

    QuickSort(p, start, i-1); //对小于pivot的数进行快速排序。
    QuickSort(p, i+1, end); //对大于等于pivot的数进行快速排序。
    //(2).2 如果i到end时，即end前的所有元素都小于pivot，会发现，i+1>end了，即递归调用时会立刻返回，所以不会发生p[i]操作越界的现象，因为根本就没机会往下走。(2).3同理。
}

下面给一段可执行代码：

#include <iostream>
using namespace std;

void QuickSort(int p[], int start, int end)
{
    if (start >= end)
    {
        return;
    }
    int i=0, j=0, tmp=0;
    i = start;
    j = end-1;

    do
    {

        // i++是不会越界的，因为随着i++，p[i]最后会指向最后一个元素即等于p[end], 这时p[i]<p[end]不再成立，i将停止增加。
        while(p[i] < p[end])
        {
            i++;
        }

//吸纳网友回复，j--的确存在越界的情况，即j--会最后为-1，但p[-1] 是个未知内存地址，初值应该是-2147483648（见后面论据），所以会有p[j] < p[end]，终止循环，除了下面1种例外。

希望大家也能随我更深入的看一下这个问题，严格讲会有一种情况出现bug：p[end] = -2147483648 如：{20,34,4,53,43,42,6,67,-2147483648}, 这时p[j]>=p[end]将一直成立，我在自己电脑win7+vs2010测试： -2147483637仍然能过，所以我猜测系统给未初始化的地址初值是-2147483648（2^31 = 2147483648 = -2147483648）。很隐蔽的bug！！当然越界总归不好，另外，两层循环也显的有些臃肿，做了一个更新版QuickSort，见下面。

        while(p[j] >= p[end])
        {
            j--;
        }
        if (i<j)
        {
            tmp = p[i];
            p[i] = p[j];
            p[j] = tmp;
        }
        else
        {
            tmp = p[i];
            p[i] = p[end];
            p[end] = tmp;
        }
    }
    while(i<j);

    QuickSort(p, start, i-1);
    QuickSort(p, i+1, end);
}

void PrintArrary(int data[], int size)
{
    for (int i=0; i<size; ++i)
    {
        cout <<data[i]<<" ";
    }
    cout<<endl;
}

int main(int argc, const char** argv)
{
    int array[]= {20,34,4,53,43,42,6,67,193};
    int size = sizeof(array)/sizeof(int);
    QuickSort(array, 0, size - 1);
    PrintArrary(array, size);
    return 0;
}

更新版QuickSort:

void QuickSort(int a[], int low, int high)
{
    if (low >= high)
    {
        return;
    }
    int i = low;
    int j = high;
    int pivot = a[low];
    while(i <= j)
    {
        if (a[i] <= pivot)
        {
            i++;
        }
        else if (a[j] > pivot)
        {
            j--;
        }
        else
        {// swap a[i], a[j]
            int tmp = a[i];
            a[i] = a[j];
            a[j] = tmp;
            i++;
            j--;
        }
    }
    // swap a[low] , a[j]
    a[low] = a[j];
    a[j] = pivot;
    j--;

    QuickSort(a, low, j);
    QuickSort(a, i, high);
}