快速排序

一、简介

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

 

二、基本思想

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

如下图所示:

Sorting_quicksort_anim

 

三、具体实现

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;

综上所述:快速排序最优的情况下时间复杂度为:O(nlogn)。

 

2) 最差情况下时间复杂度

最差的情况就是每一次取到的元素就是数组中最小/最大的,这种情况其实就是冒泡排序了(每一次都排好一个元素的顺序)这种情况时间复杂度就好计算了,就是冒泡排序的时间复杂度:T[n] = n * (n-1) = n^2 + n;
      综上所述:快速排序最差的情况下时间复杂度为:O( n^2 )。

 

3) 平均时间复杂度

快速排序的平均时间复杂度也是:O(nlogn)。

通常,快排被认为是在所有同数量级(O(nlogn))的排序方法中,其平均性能最好的一个算法。当是如果初始记录序列按关键字有序或者基本有序时,就会退化为冒泡排序,时间复杂度为O(n^2),为了改进,在取枢轴的时候,通常会用“三者取中”的方法,其实就是取序列头、中间、尾三个元素,然后取其中的中值。

 

2. 稳定性

从算法思路我们知道,当序列中的元素的值和枢轴相等的时候,是会被交换的,因此,快排不是稳定的排序算法。

 

五、参考

1. 快速排序算法

2. 白话经典算法系列之六 快速排序 快速搞定

3. 快速排序算法

posted @ 2018-06-02 23:07  大师兄啊哈  阅读(529)  评论(0编辑  收藏  举报