快速排序
一、简介
快速排序(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;
综上所述:快速排序最优的情况下时间复杂度为:O(nlogn)。
2) 最差情况下时间复杂度
最差的情况就是每一次取到的元素就是数组中最小/最大的,这种情况其实就是冒泡排序了(每一次都排好一个元素的顺序)这种情况时间复杂度就好计算了,就是冒泡排序的时间复杂度:T[n] = n * (n-1) = n^2 + n;
综上所述:快速排序最差的情况下时间复杂度为:O( n^2 )。
3) 平均时间复杂度
快速排序的平均时间复杂度也是:O(nlogn)。
通常,快排被认为是在所有同数量级(O(nlogn))的排序方法中,其平均性能最好的一个算法。当是如果初始记录序列按关键字有序或者基本有序时,就会退化为冒泡排序,时间复杂度为O(n^2),为了改进,在取枢轴的时候,通常会用“三者取中”的方法,其实就是取序列头、中间、尾三个元素,然后取其中的中值。
2. 稳定性
从算法思路我们知道,当序列中的元素的值和枢轴相等的时候,是会被交换的,因此,快排不是稳定的排序算法。
五、参考
1. 快速排序算法
3. 快速排序算法