排序算法之快速排序和归并排序

申明:此博文转自他人，感觉不错特转载供大家分享

摘要：一般评判排序算法的标准有时间代价，空间代价和稳定性。本文主要讨论性质相对比较好且作者喜欢的快速排序算法和归并排序算法，并对此这做了一定比较。

正文：

常见的排序算法大致分为四类：
1.插入排序：直接插入排序，Shell排序
2.选择排序：直接选择排序，堆排序
3.交换排序：冒泡排序，快速排序
4.归并排序

而对排序算法的一般评判标准有：
              时间代价：比较次数、移动次数
              空间代价：额外空间、堆栈深度
              稳定性：存在多个具有相同排序码的记录排序后这些记录的相对次序保持不变

下面我们先用这些评判标准对这些算法做一下基本评价：

从这个表中可以看出，快速排序、归并排序和堆排序的时间代价是比较小的，而其他几个的时间代价相对比较大。我们知道时间复杂度是评判一个算法的最主要标准。程序运行速度直接关系着算法的可行性。而真正美妙的算法也必定是运行速度比较快的。然而，由于现在计算机硬件的发展，尤其是多级缓存的引入，导致堆排序在实际运行中并不快。而且堆排序算法相对比较难理解，程序实现也相对困难，这样的算法显然不是美妙的算法。至少在快速排序面前很难找到优势。

而对于快速排序和归并排序，我们先做一简单介绍，然后分别分析，最后对比分析。

快速排序：
算法思想：以第一个元素为准，小于该元素的放在左边，不小于该元素的放在右边，然后对两侧元素递归排序。
算法：
void quicksort(int l, int u)
{   int i, m;
    if (l >= u) return;
    m = l;
    for (i = l+1; i <= u; i++)
        if (x[i] < x[l])
            swap(++m, i);
    swap(l, m);
    quicksort(l, m-1);
    quicksort(m+1, u);
}
这里假设x为全局变量。

改进：快速排序有一个很大不足就是对于比较有序的数组排序效率很低，而且当数组较短时快速排序并不是最快的。应对这些情况有三种简单常用的改进：
随机化改进：不是选取第一个值为基准，而是随机选取。
平衡化改进：取第一个、最后一个和中间点三个值中中间值为基准进行排序。
设置阀值–混合排序：当数组长度小于某一值时使用其他较快的排序。

算法分析：
时间代价：最好情况是O(n log n),最坏情况是O(n2)。如果设f(n)为数组长为n时的比较次数，则f(n)=[(f(1)+f(n-1))+(f(2)+f(n-2))+…+(f(n-1)+f(1))]/n.
利用数学知识易知f(n)=(n+1)*[1/2+1/3+…+1/(n+1)]-2n~1.386nlog(n).
空间代价：程序所需的空间即为堆栈深度(用于存储l,u,m)，所以空间代价为O(log(n))
稳定性：快速排序时不稳定的，即不保序的。

评价：快速排序的时间代价比较低，空间代价也比较低，算是时空代价相当好的算法。而且在下面的数值试验中也会发现，快速排序效率还是很好的。但是最大的不足使快速排序不稳定。比如在excel中进行排序，我们自然希望排序结果是稳定的（即相同的数排序后与原来的顺序相同）。

归并排序：
算法思想：将长为的n序列分为长度相当的左右两列，分别排序，然后再合并。即先分后合。
算法：
void merge_sort(int l,int u)
{
if(l+1>=u){basic_merge_sort(l,u);return;}
int c=(l+u)/2;
merge_sort(l,c);
merge_sort(++c,u);
merge(l,u);
}
其中basic_nerge_sort算法为：
void basic_merge_sort(int l,int u)
{
if((u-l==1)&&(x[l]>x[u]))
   swap(l,u);
}
其中的merge算法作用是：将两个有序的序列排成一个有序序列，算法如下：
void merge(int l,int u)
{
int c=(l+u)/2,j=c+1,i;
for(i=l;i<=u;i++)
   y[i]=x[i];
i=l;
while(l<=c&&j<=u)
{
   if(y[l]>y[j]) x[i++]=y[j++];
   else x[i++]=y[l++];
}
while(l<=c) x[i++]=y[l++];
while(j<=u) x[i++]=y[j++];
}
改进：归并排序使用时基本上使用的和这类似。
算法分析：
时间代价：设f(n)为数组长为n时的比较次数，则f(n)=f(n/2)+f((n+1)/2)+n.则利用数学知识很容易看出f(n)为O(nlog(n))的。
空间代价：归并排序所需空间除了堆栈深度以外还需要开长度为n的空间。所以归并排序的空间代价为O(n)。
稳定性：由于归并排序中并没有使用出现对换，所以排序时稳定的。

评价：归并排序时间代价是比较理想的，而且算法是稳定的，这个是很好的。但是不足的是排序的空间代价比较大，需要开一个与原数组同样大小的数组。

二种算法对比：
时间代价：从时间复杂度上看，两个算法平分秋色。但理论分析并不等于实际运行结果。于是我对两种算法用C实现了一下，分别用visual stdio C++6.0和Dev C++编译，在我的COMPAQ B1800笔记本（1.73GHz主频）上运行。运行结果如下：（N为数组长度，由于排序算法很快，且快排运行时间随机性比较大，我对每个排序都运行了times次，每次数组元素都是随机选取）
visual stdio C++6.0上运行时间（ms）
N和times                   归并 快排
N=500 times=10000 1395 2593
N=1000 times=10000 3165 5645
N=2000 times=10000 6974 12115
N=10000 times=1000 4308 6986

Dev C++上最优化编译后运行时间（ms）
N和times                  归并 快排
N=500 times=10000 591 594
N=1000 times=10000 1515 907
N=2000 times=10000 2620 2381
N=10000 times=1000 3156 3172

两个编译器的运行时间很出乎意料，不光Dev C++上运行时间降低了，而且连两者的相对速度都不一样。从VC上来看，显然归并要优于快排，而且又是很明显。而从Dev上来看，结果就不一样了，两者一般情况下运行速度一样，部分情况下快排较好。这个运行结果与网上的一致评论比较相似。

对于这种情况我的解释：不同编译器编译原理不同，众所周知，Dev编译的结果一般是明显优于VC编译结果的，这里数据不同的原因部分也就是这个。而不同编译器编译的执行文

件里都会有些辅助信息，这些一定程度上降低了程序的运行速度，这也是在VC上两者运行速度相差很大的原因。再加上现在电脑各级内存的引入使得程序运行速度的快慢远远不能

只从理论分析值上来看。所以两个编译器的运行结果是大大不同的。

不过总体来说，两种排序的运行效率应该是相差无几的。不过如果选用VC编译器的话，归并有一定优势。但如果选用其他变异效果比较好的编译器，两者效率相差就不明显了。

空间代价：正如上面所分析的那样，快排的空间代价为堆栈深度，但快排最坏情况堆栈深度为n，最好情况为log(n)，平均情况为O(log(n))。
归并排序堆栈深度为O(log(n)),但还需要额外的大小为n的空间，所以空间代价为O(n)。
从空间代价上来看，归并排序不如快速排序。

稳定性：从上面的分析上知道，快速排序时不稳定的，而归并排序是稳定的。在这方面两个排序完全不同。如果对稳定性没有要求，则两者没有太大差距；但如果对稳定性有要求

，则快速排序则不适用。所以归并排序在这方面有一个比较大的优势。

从上面三个方面上看，快速排序的时空代价相对较小，略比归并要好。这应该是大家特别看好快速排序的原因。甚至快排还是20世纪十大经典算法之一。但归并排序的劣势并不是很明显，而且归并排序的算法思想是如此简单。更重要的是，归并排序是稳定的。这些应该是归并排序能与快速排序抗衡的主要原因。

这两个排序算法是我最喜欢的。当然如果非要从两者之间选一个最最喜欢的话，我会选择归并排序。一方面在我完全不知道归并排序的情况下，自己独立写出了它的算法并上机实

现了。另一方面，归并排序思想简单，是稳定的，适用性优于快速排序。由于其稳定性，我可以大胆的copy这些代码到我需要用它的地方。

参考文献：
1.Jon Bentley The Most Beautiful Code I Never Wrote
2.http://baike.baidu.com/view/297739.htm
3.http://baike.baidu.com/view/115472.htm