快速排序

Posted 2020-11-18 harrymore

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了快速排序相关的知识，希望对你有一定的参考价值。

一、简介

快速排序（Quicksort）由C. A. R. Hoare在1962年提出，是对冒泡排序的一种改进。它采用了一种分治的策略，通常称其为分治法(Divide-and-ConquerMethod)，快速排序由于排序效率在同为O(N*logN)的几种排序方法中效率较高，因此经常被采用。

二、基本思想

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

如下图所示：

三、具体实现

1. 实现思路

关于快排的实现的描述，感觉有篇博客[参考2]讲的“挖坑填数+分治法”比较贴切，其描述如下：

以一个数组作为示例，取区间第一个数为枢轴（pivot）。

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

初始时，i = 0; j = 9; X = a[i] = 72。

从j开始向前找一个比X小或等于X的数。当j=8，符合条件，将a[8]挖出再填到上一个坑a[0]中。a[0]=a[8]; i++;

这样一个坑a[0]就被搞定了，但又形成了一个新坑a[8]，这怎么办了？简单，再找数字来填a[8]这个坑。这次从i开始向后找一个大于X的数，当i=3，符合条件，将a[3]挖出再填到上一个坑中a[8]=a[3]; j—;

数组变为：

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

i = 3; j = 7; X=72

再重复上面的步骤，先从后向前找，再从前向后找。

从j开始向前找，当j=5，符合条件，将a[5]挖出填到上一个坑中，a[3] = a[5]; i++;

从i开始向后找，当i=5时，由于i==j退出。

此时，i = j = 5，而a[5]刚好又是上次挖的坑，因此将X填入a[5]。

数组变为：

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

可以看出a[5]前面的数字都小于它，a[5]后面的数字都大于它。因此再对a[0…4]和a[6…9]这二个子区间重复上述步骤就可以了。

2. 代码实现

挖坑填数代码，c++实现：

int AdjustArray(int s[], int l, int r) //返回调整后基准数的位置  
{  
    int i = l, j = r;  
    int x = s[l]; //s[l]即s[i]就是第一个坑  
    while (i < j)  
    {  
        // 从右向左找小于x的数来填s[i]  
        while(i < j && s[j] >= x)   
            j--;    
        if(i < j)   
        {  
            s[i] = s[j]; //将s[j]填到s[i]中，s[j]就形成了一个新的坑  
            i++;  
        }  
  
        // 从左向右找大于或等于x的数来填s[j]  
        while(i < j && s[i] < x)  
            i++;    
        if(i < j)   
        {  
            s[j] = s[i]; //将s[i]填到s[j]中，s[i]就形成了一个新的坑  
            j--;  
        }  
    }  
    //退出时，i等于j。将x填到这个坑中。  
    s[i] = x;  
  
    return i;  
}

快排c++实现：

void quick_sort1(int s[], int l, int r)  
{  
    if (l < r)  
    {  
        int i = AdjustArray(s, l, r);//先成挖坑填数法调整s[]  
        quick_sort1(s, l, i - 1); // 递归调用   
        quick_sort1(s, i + 1, r);  
    }  
}

实际上其他语言的实现就要简洁得多了：

ruby：

def quick_sort(a)  
  (x=a.pop) ? quick_sort(a.select { |i| i <= x }) + [x] + quick_sort(a.select { |i| i > x }) : []
end

erlang：

q_sort([]) -> [];
q_sort([H|R]) -> q_sort([X||X<-R,X<H])++ [H]++ q_sort([X||X<-R,X>=H]).

haskell：

q_sort n=case n of
    []->[]
    (x:xs)->q_sort [a|a<-xs,a<=x]++[x]++q_sort [a|a<-xs,a>x]

四、时间复杂度及稳定性

1. 时间复杂度

首先，递归算法的时间复杂度公式：T[n] = aT[n/b] + f(n)。

1) 最优情况下时间复杂度

快速排序最优的情况就是每一次取到的元素都刚好平分整个数组，此时的时间复杂度公式则为：

T[n] = 2T[n/2] + f(n)

T[n/2]为平分后的子数组的时间复杂度，f(n)为平分这个数组时所花的时间

从c++实现代码（AdjustArray）可以知道，f(n)与数组长度成正比，可以用cn来表示（c为常数），

用迭代法：

T[n]             = 2T[n/2] + n                        ----第一次递归
令：n = n/2，    = 2{2T[n/4] + (n/2) } + n
                 = 2^2T[n/(2^2)] + 2n                 ----第二次递归
令：n = n/(2^2)，= 2^2{2T[n/(2^3)] + n/(2^2)} + 2n
                 = 2^3T[n/(2^3)] + 3n                 ----第三次递归 
......
令：n = n/(2^(m-1))，=2^mT[1] + mn                   ----第m次递归(m次后结束)
当最后平分的不能再平分时，也就是说把公式一直往下迭代，到最后得到T[1]时，说明这个公式已经迭代完了（T[1]是常量了）。
得到：T[n/(2^m)] = T[1] ===>> n = 2^m ====>> m = logn；
T[n] = 2^mT[1] + mn ；其中m = logn;
T[n] = 2^(logn) T[1] + nlogn  =  n T[1] + nlogn  =  n + nlogn  ；其中n为元素个数
又因为当n >= 2时：nlogn >= n  (也就是logn > 1)，nlogn增长最快，所以取后面的nlogn；