算法——快速排序

前言

为了学习面试中常常要考察到的快速排序，在网上搜索了很多篇资料，才大致搞懂了快速排序的原理。现在作出总结，以防日后忘记。

介绍

快速排序（Quicksort）是对冒泡排序的一种改进。
快速排序由C. A. R. Hoare在1960年提出。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
快速排序采用了一种分治的策略，通常称其为分治法(Divide-and-ConquerMethod)。

特点

• 时间复杂度
  • 最好情况：O($n{\log }_{2}n$)
  • 平均情况：O($n{\log }_{2}n$)
  • 最坏情况：O($n^2$)
• 空间复杂度：O($n{\log }_{2}n$)
• 稳定性：不稳定

基本思想

1. 先从数列中取出一个数作为基准数。
2. 分区过程，将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边。
3. 再对左右区间重复第二步，直到各区间只有一个数。

在该篇博客中，将使用挖坑填数法+分治法来对快速排序作出介绍

实现

假设存在这样一个数组a[10]，数组中存在有10个100以下的数：

a[10] = [72,6,57,88,60,42,83,73,48,85];

要使用快速排序给这个数组排序，第一步要做的，就是取基准数。
这里取数组的第一个数（即72）为基准数，为了更直观地体现快速排序的过程，这里用表格形式来显示该组数据：

表格①

0	1	2	3	4	5	6	7	8	9
72	6	57	88	60	42	83	73	48	85

X=72，i=0，j=9

第一列为数组的索引值，第二列为该数组的每个值，而标红的值（72），即为此次快速排序的基准数
除了取基准值（设为X）之外，我们还要获得该数组开头的索引值（设为i）和结尾的索引值（设为j）。
由该表格可以看出，X=a[0]=72（我们刚刚取出来的），i=0（起始索引），j=9（结尾索引）
由于已经将 a[0] 中的数保存到 X 中，可以理解成在数组 a[0] 上挖了个坑，所以可以将其它数据填充到这来。
接下来，从j开始向前找一个比X小或等于X的数。从表格中可以得知，当j=8时，a[j]=a[8]=48<72，符合条件，于是将a[8]挖出再填到上一个坑a[0]中，即执行a[0] = a[8]，并且让i++，这样一个坑a[0]就被填上了，变换后的数组如下所示：

表格②

0	1	2	3	4	5	6	7	8	9
48	6	57	88	60	42	83	73	48	85

X=72（基准值虽然暂时消失了，但是只要定义了，就不会改变），i=1，j=8

但是不要高兴得太早，因为新坑a[8]出现了。为了处理这个问题，我们使用上次的方法，只不过，这次要从i开始向后找一个大于X的数。从表格中可以得知，当i=3时，a[i]=a[3]=88>72，符合条件，于是将a[3]挖出再填到上一个坑a[8]中，即执行a[8] = a[3]，并且让j– ，这样第二个坑a[8]就被填上了，变换后的数组如下所示：

表格③

0	1	2	3	4	5	6	7	8	9
48	6	57	88	60	42	83	73	88	85

X=72，i=3，j=7

就跟前面的步骤相似的，这次轮到新坑a[3]出现了，还是参照上面的老方法，从j开始向前找一个比X小或等于X的数。从表格中可以得知，当j=5时，a[j]=a[5]=42<72，符合条件，于是将a[5]挖出再填到上一个坑a[3]中，即执行a[3] = a[5]，并且让i++，这样第三个坑a[3]就被填上了，变换后的数组如下所示：

表格④

0	1	2	3	4	5	6	7	8	9
48	6	57	42	60	42	83	73	88	85

X=72，i=4，j=5

这次出现的是新坑a[5]，按照老规矩，我们从i开始向后找一个大于X的数，但是知道i==j，即两个索引碰头时，也没有找到能大于X的数，那应该怎么填上这个坑呢？
还记得最开始挖的坑a[0] 吗？没错，要填上a[5]这个坑，只能用最开始选取的基准值来填进去，即X，变换后的数组如下：

表格⑤

0	1	2	3	4	5	6	7	8	9
48	6	57	42	60	72	83	73	88	85

X=72，i=5，j=5

由这个表可以看出：a[5]前面的数字都小于它，a[5]后面的数字都大于它。至此，快速排序的第一轮就结束了。

---

等等！这个数组好像还没有排序成功吧！

这个时候，就需要用到分治法的思想了。现在整体大致排序好了，我们只需要再对a[0…4]和a[6…9]这二个子区间重复上述步骤就可以了。具体的过程，就不在这里赘述了。

总结

1. i =0; j = a.length - 1; 将基准数挖出形成第一个坑（这里建议选择a[0]，即数组的第一个值）。
2. 由后向前找比它小的数，找到后挖出此数填前一个坑a[i]中，然后记得j–
3. 由前向后找比它大的数，找到后也挖出此数填到前一个坑a[j]中，然后记得i++。
4. 再重复执行2，3二步（切记：顺序不能调换！），直到i==j，最后再将基准数填入a[i]中。

代码实现

这里仅列出用Java代码实现的版本，其他版本可以参考网上的其他资料

//快速排序
void quick_sort(int s[], int l, int r)
{
    if (l < r)
    {
        //Swap(s[l], s[(l + r) / 2]); //将中间的这个数和第一个数交换
        int i = l, j = r, x = s[l];
        while (i < j)
        {
            while(i < j && s[j] >= x) // 从右向左找第一个小于x的数
                j--;  
            if(i < j) 
                s[i++] = s[j];
            
            while(i < j && s[i] < x) // 从左向右找第一个大于等于x的数
                i++;  
            if(i < j) 
                s[j--] = s[i];
        }
        s[i] = x;
        quick_sort(s, l, i - 1); // 递归调用 
        quick_sort(s, i + 1, r);
    }
}