快速排序
- 基本思想
分而治之的思想。归并排序也是先分解后归并,归并的时候也做了一部分工作。而快速排序,是选取一个基准元素(povit),然后把数组分为两部分,通过交换,使得基准元素的左边都小于基准元素,右边都大于基准元素。
基准元素一次性就排在了真正正确的地方。然后再递归地处理基准元素左边和右边就可以了。不需要在合并的时候进行操作。
快排的一个关键点是选择基准元素。
如果基准元素每次都正好选在正中间,那么 T(N) = 2*T(N/2) + O(N) = O(N*logN)。
但是如果基准元素每次都选择在最边上,那么 T(N) = T(N-1)+O(N) = O(N^2)。这样快排就退化为很慢的算法了。
一种选择基准元素的方式是:选择数组左端、右端、中间的中位数作为基准元素。 - 代码
#include <stdio.h>
#define ElementType long
#define maxn 100001
#define threshold 10
ElementType A[maxn]
void Swap(ElementType A[], int i, int j)
ElementType Median3(ElementType A[], int left, int right)
void Quick_sort(ElementType A[], int N)
int main(int argc, const char * argv[]) {
int N,i
scanf("%d",&N)
for(i=0
scanf("%ld",&A[i])
}
Quick_sort(A, N)
printf("%ld",A[0])
for(i=1
printf(" %ld",A[i])
}
printf("\n")
return 0
}
void Swap(ElementType A[], int i, int j){
ElementType tmp = A[i]
A[i] = A[j]
A[j] = tmp
}
ElementType Median3(ElementType A[], int left, int right)
{
int mid = (left + right)/2
//下面使得 A[left]、 A[mid]、 A[right] 按序排列
if(A[left] > A[mid]) Swap(A, left, mid)
if(A[left] > A[right]) Swap(A, left, right)
if(A[mid] > A[right]) Swap(A, mid, right)
//之后只需要考虑A[left+1] - A[right-2]
Swap(A,mid,right-1)
return A[right-1]
}
void Qsort(ElementType A[], int left, int right)
{
int length = right-left+1
if(length <= 1) return
else if(length < threshold) Insert_sort(A+left, length)
else{
ElementType povit
int lo = left, hi = right-1
povit = Median3(A, left, right)
while(1){
while(A[++lo] < povit)
while(A[--hi] > povit)
if(lo > hi) break
else Swap(A,lo,hi)
}
Swap(A, right-1, lo)
Qsort(A,left, lo-1)
Qsort(A,lo+1,right)
}
}
void Quick_sort(ElementType A[], int N)
{
Qsort(A, 0, N-1)
}
- 运行结果
我们可以看到快速排序真的蛮快的。 - 小结
快速排序是不稳定的算法,最坏时间复杂度为O(N^2),但是当基准元素选取的比较好的时候,时间复杂度为O(N*logN)。空间复杂度为O(1)。
我在上面的一个优化是:当数组长度小于一个阈值(我这儿为10)时,采用插入排序。
系统库函数qsort
#include<stdlib.h>
int cmp(const void *a, const void *b)
{
return(*(ElementType*)a-*(ElementType*)b);
}
qsort(A,N,sizeof(ElementType),cmp);
- 运行结果
哇,我发现我自己写的快排竟然比库函数还快一点,狠开心。
非递归的归并排序
- 大概思想
可以用循环的方式来实现归并排序。具体就是刚开始两两归并,然后规模依次乘2,直到规模大于数组长度。
具体的归并时要注意,先归并长度足够的元素,最后处理剩余的元素。 - 代码
void Merge(ElementType A[],ElementType tmpA[], int L, int R, int rightEnd)
{
int tmp = L,leftEnd = R-1,size = rightEnd-L+1;
while(L<=leftEnd && R<=rightEnd)
{
if(A[L] <= A[R]) tmpA[tmp++] = A[L++];
else tmpA[tmp++] = A[R++];
}
while(L<=leftEnd) tmpA[tmp++] = A[L++];
while(R<=rightEnd) tmpA[tmp++] = A[R++];
int i;
for(i=0; i<size; i++) A[rightEnd-i] = tmpA[rightEnd-i];
}
//将A[]中的N个元素归并到tmpA[]中,其中length表示当前有序子列的长度
void Merge_pass(ElementType A[], ElementType tmpA[], int N, int length)
{
int i;
for(i=0; i<=N-2*length; i+=2*length)
{
Merge(A, tmpA, i, i+length, i+2*length-1);
}
//归并最后两个列
if(i+length < N) Merge(A, tmpA, i, i+length, N-1);
else{//如果最后只剩一个子列
for(; i<N; i++) tmpA[i] = A[i];
}
}
void Merge_sort(ElementType A[], int N)
{
int length = 1;
ElementType *tmpA;
tmpA = malloc(sizeof(ElementType) * N);
if(tmpA != NULL)
{
while(length < N)
{
Merge_pass(A, tmpA, N, length);
length *= 2;
Merge_pass(tmpA, A, N,length);
length *= 2;
}
free(tmpA);
} else{
printf("空间不足\n");
}
}
- 运行结果
- 小结
非递归排序用循环实现,比递归排序更快一些。时间复杂度还是O(N*logN)。