排序

1 选择排序
已知一组无序数据a[1]、a[2]、……a[n]，需将其按升序排列。

首先比较a[1]与a[2]的值，若a[1]大于a[2]则交换两者的值，否则不变。

再比较a[1]与a[3]的值，若a[1]大于a[3]则交换两者的值，否则不变。

再比较a[1]与a[4]，以此类推，最后比较a[1]与a[n]的值。

这样处理一轮后，a[1]的值一定是这组数据中最小的。

再将a[2]与a[3]~a[n]以相同方法比较一轮，则a[2]的值一定是a[2]~a[n]中最小的。

再将a[3]与a[4]~a[n]以相同方法比较一轮，以此类推。

共处理n-1轮后a[1]、a[2]、……a[n]就以升序排列了。

优点：稳定，比较次数与冒泡排序一样；
缺点：相对之下还是慢。

2 插入排序
已知一组升序排列数据a[1]、a[2]、……a[n]，一组无序数据b[1]、b[2]、……b[m]，需将二者合并成一个升序数列。

首先比较b[1]与a[1]的值，若b[1]大于a[1]，则跳过，比较b[1]与a[2]的值，若b[1]仍然大于a[2]，则继续跳过，直到b[1]小于a数组中某一数据a[x]，则将a[x]~a[n]分别向后移动一位，将b[1]插入到原来a[x]的位置这就完成了b[1]的插入。

b[2]~b[m]用相同方法插入。

（若无数组a，可将b[1]当作n=1的数组a）
优点：稳定，快；
缺点：比较次数不一定，比较次数越少，插入点后的数据移动越多，特别是当数据总量庞大的时候，但用链表可以解决这个问题。

3 归并排序
由希尔在1959年提出，又称希尔排序(shell排序)。

已知一组无序数据a[1]、a[2]、……a[n]，需将其按升序排列。

发现当n不大时，插入排序的效果很好。

首先取一增量d(d<n)，将a[1]、a[1+d]、a[1+2d]……列为第一组，a[2]、a[2+d]、a[2+2d]……列为第二组……，a[d]、a[2d]、a[3d]……列为最后一组以次类推，在各组内用插入排序，然后取d'<d，重复上述操作，直到d=1。

优点：快，数据移动少；
缺点：不稳定，d的取值是多少，应取多少个不同的值，都无法确切知道，只能凭经验来取。

4 快速排序
快速排序是冒泡排序的改进版，是目前已知的最快的排序方法。

已知一组无序数据a[1]、a[2]、……a[n]，需将其按升序排列。

首先任取数据a[x]作为基准。

比较a[x]与其它数据并排序，使a[x]排在数据的第k位，并且使a[1]~a[k-1]中的每一个数据<a[x]，a[k+1]~a[n]中的每一个数据>a[x]，然后采用分治的策略分别对a[1]~a[k-1]和a[k+1]~a[n]两组数据进行快速排序。

优点：极快，数据移动少；
缺点：不稳定。

插入排序
概述
有一个已经有序的数据序列，要求在这个已经排好的数据序列中插入一个数，但要求插入后此数据序列仍然有序，这个时候就要用到一种新的排序方法——插入排序法,插入排序的基本操作就是将一个数据插入到已经排好序的有序数据中,从而得到一个新的、个数加一的有序数据，算法适用于少量数据的排序，时间复杂度为⊙(㎡)。

是稳定的排序方法。

插入算法（insertion sort）把要排序的数组分成两部分：第一部分包含了这个数组的所有元素，但将最后一个元素除外，而第二部分就只包含这一个元素。

在第一部分排序后，再把这个最后元素插入到此刻已是有序的第一部分里的正确位置中。

插入排序：
包括：直接插入排序，折半插入排序，链表插入排序，Shell排序
基本思想
将n个元素的数列分为已有序和无序两个部分，如下所示：
{，{a2，a3，a4，…,an}}
{{a1(1)，a2(1)}，{a3(1)，a4(1) …,an(1)}}
…
{{a1(n-1)，a2(n-1) ，…}, {an(n-1)}}
每次处理就是将无序数列的第一个元素与有序数列的元素从后往前逐个进行比较，找出插入位置，将该元素插入到有序数列的合适位置中。

插入排序算法步骤
1.从有序数列和无序数列{a2,a3,…,an}开始进行排序；
2.处理第i个元素时(i=2,3,…,n) , 数列{a1,a2,…,ai-1}是已有序的,而数列{ai,ai+1,…,an}是无序的。

用ai与ai-1，a i-2,…,a1进行比较,找出合适的位置将ai插入；
3.重复第二步，共进行n-1次插入处理，数列全部有序。

void insertSort(Type* arr,long len)/*InsertSort algorithm*/
{
long i=0,j=0;/*iterator value*/
Type tmpData;
assertF(arr!=NULL,"In InsertSort sort,arr is NULL\n");
for(i=1;i<len;i++)
{
j=i;
tmpData=*(arr + i);
while(j > 0 && tmpData < arr[j-1])
{
arr[j]=arr[j-1];
j--;
}
arr[j]=tmpData;
}
}
插入排序算法思路
假定这个数组的序是排好的,然后从头往后,如果有数比当前外层元素的值大,则将这个数的位置往后挪,直到当前外层元素的值大于或等于它前面的位置为止.这具算法在排完前k 个数之后,可以保证a[1…k]是局部有序的,保证了插入过程的正确性.
算法描述
一般来说，插入排序都采用in-place在数组上实现。

具体算法描述如下：
1. 从第一个元素开始，该元素可以认为已经被排序
2. 取出下一个元素，在已经排序的元素序列中从后向前扫描
3. 如果该元素（已排序）大于新元素，将该元素移到下一位置
4. 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置
5. 将新元素插入到该位置中
6. 重复步骤2
如果比较操作的代价比交换操作大的话，可以采用二分查找法来减少比较操作的数目。

该算法可以认为是插入排序的一个变种，称为二分查找排序。

Procedure InsertSort(Var R : FileType);
//对R[1..N]按递增序进行插入排序, R[0]是监视哨//
Begin
for I := 2 To N Do //依次插入R[2],...,R[n]//
begin
R[0] := R[I]; J := I - 1;
While R[0] < R[J] Do //查找R[I]的插入位置//
begin
R[J+1] := R[J]; //将大于R[I]的元素后移//
J := J - 1
end
R[J + 1] := R[0] ; //插入R[I] //
end
End; //InsertSort //
算法复杂度
如果目标是把n个元素的序列升序排列，那么采用插入排序存在最好情况和最坏情况。

最好情况就是，序列已经是升序排列了，在这种情况下，需要进行的比较操作需(n-1)次即可。

最坏情况就是，序列是降序排列，那么此时需要进行的比较共有n(n-1)/2次。

插入排序的赋值操作是比较操作的次数加上(n-1)次。

平均来说插入排序算法复杂度为O(n2)。

因而，插入排序不适合对于数据量比较大的排序应用。

但是，如果需要排序的数据量很小，例如，量级小于千，那么插入排序还是一个不错的选择。

冒泡排序
冒泡排序（BubbleSort）的基本概念是：依次比较相邻的两个数，将小数放在前面，大数放在后面。

即首先比较第1个和第2个数，将小数放前，大数放后。

然后比较第2个数和第3个数，将小数放前，大数放后，如此继续，直至比较最后两个数，将小数放前，大数放后。

重复以上过程，仍从第一对数开始比较（因为可能由于第2个数和第3个数的交换，使得第1个数不再小于第2个数），将小数放前，大数放后，一直比较到最大数前的一对相邻数，将小数放前，大数放后，第二趟结束，在倒数第二个数中得到一个新的最大数。

如此下去，直至最终完成排序。

由于在排序过程中总是小数往前放，大数往后放，相当于气泡往上升，所以称作冒泡排序。

用二重循环实现，外循环变量设为i，内循环变量设为j。

外循环重复9次，内循环依次重复9，8，...，1次。

每次进行比较的两个元素都是与内循环j有关的，它们可以分别用a[j]和a[j+1]标识，i的值依次为1,2,...,9，对于每一个i, j的值依次为1,2,...10-i。

产生在许多程序设计中，我们需要将一个数列进行排序，以方便统计，常见的排序方法有冒泡排序，二叉树排序，选择排序等等。

而冒泡排序一直由于其简洁的思想方法和比较高的效率而倍受青睐。

排序过程
设想被排序的数组R［1..N］垂直竖立，将每个数据元素看作有重量的气泡，根据轻气泡不能在重气泡之下的原则，从下往上扫描数组R，凡扫描到违反本原则的轻气泡，就使其向上"漂浮"，如此反复进行，直至最后任何两个气泡都是轻者在上，重者在下为止。

算法示例
49 13 13 13 13 13 13 13
38 49 27 27 27 27 27 27
65 38 49 38 38 38 38 38
97 65 38 49 49 49 49 49
76 97 65 49 49 49 49 49
13 76 97 65 65 65 65 65
27 27 76 97 76 76 76 76
49 49 49 76 97 97 97 97
Procedure BubbleSort(Var R : FileType) //从下往上扫描的起泡排序//
Begin
For I := 1 To N-1 Do //做N-1趟排序//
begin
NoSwap := True; //置未排序的标志//
For J := N - 1 DownTo 1 Do //从底部往上扫描//
begin
If R[J+1]< R[J] Then //交换元素//
begin
Temp := R[J+1]; R[J+1 := R[J]; R[J] := Temp;
NoSwap := False
end;
end;
If NoSwap Then Return//本趟排序中未发生交换，则终止算法//
end
End; //BubbleSort//
该算法的时间复杂性为O(n^2),算法为稳定的排序方
冒泡排序法的改进
比如用冒泡排序将4、5、7、1、2、3这6个数排序。

在该列中，第二趟排序结束后，数组已排好序，但计算机此时并不知道已经反排好序，计算机还需要进行一趟比较，如果这一趟比较，未发生任何数据交换，则知道已排序好，可以不再进行比较了。

因而第三趟比较还需要进行，但第四、五趟比较则是不必要的。

为此，我们可以考虑程序的优化。

为了标志在比较中是否进行了，设一个布尔量flag。

在进行每趟比较前将flag置成true。

如果在比较中发生了数据交换，则将flag置为false，在一趟比较结束后，再判断flag，如果它仍为true（表明在该趟比较中未发生一次数据交换）则结束排序，否则进行下一趟比较。

[编辑本段]
性能分析
若记录序列的初始状态为"正序"，则冒泡排序过程只需进行一趟排序，在排序过程中只需进行n-1次比较，且不移动记录；反之，若记录序列的初始状态为"逆序"，则需进行n(n-1)/2
次比较和记录移动。

因此冒泡排序总的时间复杂度为O(n*n)。

选择排序
基本思想
每一趟从待排序的数据元素中选出最小（或最大）的一个元素，顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。

选择排序是不稳定的排序方法。

n个记录的文件的直接选择排序可经过n-1趟直接选择排序得到有序结果：
①初始状态：无序区为R[1..n]，有序区为空。

②第1趟排序
在无序区R[1..n]中选出关键字最小的记录R[k]，将它与无序区的第1个记录R[1]交换，使R[1..1]和R[2..n]分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区。

……
③第i趟排序
第i趟排序开始时，当前有序区和无序区分别为R[1..i-1]和R(1≤i≤n-1)。

该趟排序从当前无序区中选出关键字最小的记录R[k]，将它与无序区的第1个记录R交换，使R[1..i]和R分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区。

这样，n个记录的文件的直接选择排序可经过n-1趟直接选择排序得到有序结果。

排序过程
【示例】：
初始关键字[49 38 65 97 76 13 27 49]
第一趟排序后13 ［38 65 97 76 49 27 49]
第二趟排序后13 27 ［65 97 76 49 38 49]
第三趟排序后13 27 38 [97 76 49 65 49]
第四趟排序后13 27 38 49 [76 97 65 49 ]
第五趟排序后13 27 38 49 49 [97 65 76]
第六趟排序后13 27 38 49 49 65 [97 76]
第七趟排序后13 27 38 49 49 65 76 [97]
最后排序结果13 27 38 49 49 65 76 97
Pascal语言过程
procedure ssort(a:array of integer);{a为元素数组}
var
i,j,k,temp:integer;
begin
for i:=n downto 2 do{共n-1轮选择}
begin
k:=1;
for j:=1 to i do
if a[j]>a[k] then k:=j;{第i轮，记录前i个数中最大的}
temp:=a[k];{把最大的与倒数第i个交换}
a[k]:=a[j];
a[j]:=temp;
end;
end;
快速排序
概述
快速排序（Quicksort）是对冒泡排序的一种改进。

由C. A. R. Hoare在1962年提出。

它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

算法过程
设要排序的数组是A[0]……A[N-1]，首先任意选取一个数据（通常选用第一个数据）作为关键数据，然后将所有比它小的数都放到它前面，所有比它大的数都放到它后面，这个过程称为一趟快速排序。

一趟快速排序的算法是：
1）设置两个变量I、J，排序开始的时候：I=0，J=N-1；
2）以第一个数组元素作为关键数据，赋值给X，即X=A[0]；
3）从J开始向前搜索，即由后开始向前搜索（J=J-1），找到第一个小于X的值，让
该值与X交换（找到就行.找到后i大小不变）；
4）从I开始向后搜索，即由前开始向后搜索（I=I+1），找到第一个大于X的值，让该值与X交换（找到就行.找到后j大小不变）；
5）重复第3、4步，直到I=J；(3,4步是在程序中没找到时候j=j-1，i=i+1。

找到并交换的时候i，j指针位置不变。

另外当i=j这过程一定正好是i+或j+完成的最后另循环结束) 例如：待排序的数组A的值分别是：（初始关键数据：X=49）注意关键X永远不变.永远是和X进行比较无论在什么位子最后的目的就是把X放在中间小的放前面大的放后面
A[0] 、A[1]、A[2]、A[3]、A[4]、A[5]、A[6]：
49 38 65 97 76 13 27
进行第一次交换后：27 38 65 97 76 13 49
( 按照算法的第三步从后面开始找)
进行第二次交换后：27 38 49 97 76 13 65
( 按照算法的第四步从前面开始找>X的值，65>49,两者交换，此时：I=3 )
进行第三次交换后：27 38 13 97 76 49 65
( 按照算法的第五步将又一次执行算法的第三步从后开始找
进行第四次交换后：27 38 13 49 76 97 65
( 按照算法的第四步从前面开始找大于X的值，97>49,两者交换，此时：J=4 )
此时再执行第三步的时候就发现I=J，从而结束一趟快速排序，那么经过一趟快速排序之后的结果是：27 38 13 49 76 97 65，即所以大于49的数全部在49的后面，所以小于49的数全部在49的前面。

快速排序就是递归调用此过程——在以49为中点分割这个数据序列，分别对前面一部分和后面一部分进行类似的快速排序，从而完成全部数据序列的快速排序，最后把此数据序列变成一个有序的序列，根据这种思想对于上述数组A的快速排序的全过程如图6所示：初始状态{49 38 65 97 76 13 27}
进行一次快速排序之后划分为{27 38 13} 49 {76 97 65}
分别对前后两部分进行快速排序{27 38 13} 经第三步和第四步交换后变成{13 27 38} 完成排序。

{76 97 65} 经第三步和第四步交换后变成{65 76 97} 完成排序。

利用快排排序一组数
变种算法
快速排序(Quicksort)有几个值得一提的变种算法，这里进行一些简要介绍：
随机化快排：快速排序的最坏情况基于每次划分对主元的选择。

基本的快速排序选取第一个元素作为主元。

这样在数组已经有序的情况下，每次划分将得到最坏的结果。

一种比较常见的优化方法是随机化算法，即随机选取一个元素作为主元。

这种情况下虽然最坏情况仍然是O(n^2)，但最坏情况不再依赖于输入数据，而是由于随机函数取值不佳。

实际上，随机化快速排序得到理论最坏情况的可能性仅为1/(2^n)。

所以随机化快速排序可以对于绝大多数输入数据达到O(nlogn)的期望时间复杂度。

一位前辈做出了一个精辟的总结：“随机化快速排序可以满足一个人一辈子的人品需求。

”
随机化快速排序的唯一缺点在于，一旦输入数据中有很多的相同数据，随机化的效果将直接减弱。

对于极限情况，即对于n个相同的数排序，随机化快速排序的时间复杂度将毫无疑问的降低到O(n^2)。

平衡快排（Balanced Quicksort）：每次尽可能地选择一个能够代表中值的元素作为关键数据，然后遵循普通快排的原则进行比较、替换和递归。

通常来说，选择这个数据的方法是取开头、结尾、中间3个数据，通过比较选出其中的中值。

取这3个值的好处是在实际问题（例如信息学竞赛……）中，出现近似顺序数据或逆序数据的概率较大，此时中间数据必然成为中值，而也是事实上的近似中值。

万一遇到正好中间大两边小（或反之）的数据，取的值都接近最值，那么由于至少能将两部分分开，实际效率也会有2倍左右的增加，而且利于将数据略微打乱，破坏退化的结构。

外部快排（External Quicksort）：与普通快排不同的是，关键数据是一段buffer，首先将之前和之后的M/2个元素读入buffer并对该buffer中的这些元素进行排序，然后从被排序数组的开头（或者结尾）读入下一个元素，假如这个元素小于buffer中最小的元素，把它写到最开头的空位上；假如这个元素大于buffer中最大的元素，则写到最后的空位上；否则把buffer中最大或者最小的元素写入数组，并把这个元素放在buffer里。

保持最大值低于这些关键数据，最小值高于这些关键数据，从而避免对已经有序的中间的数据进行重排。

完成后，数组的中间空位必然空出，把这个buffer写入数组中间空位。

然后递归地对外部更小的部分，循环地对其他部分进行排序。

三路基数快排（Three-way Radix Quicksort，也称作Multikey Quicksort、Multi-key
Quicksort）：结合了基数排序（radix sort，如一般的字符串比较排序就是基数排序）和快排的特点，是字符串排序中比较高效的算法。

该算法被排序数组的元素具有一个特点，即multikey，如一个字符串，每个字母可以看作是一个key。

算法每次在被排序数组中任意选择一个元素作为关键数据，首先仅考虑这个元素的第一个key（字母），然后把其他元素通过key的比较分成小于、等于、大于关键数据的三个部分。

然后递归地基于这一个key位置对“小于”和“大于”部分进行排序，基于下一个key对“等于”部分进行排序。

[编辑本段]
Pascal中的快速排序源代码
procedure sort(l,r: longint);
var i,j,x,y: longint;
begin
i:=l; j:=r; x:=a[(l+r) div 2];
repeat
while a[i]<x do inc(i);
while x<a[j] do dec(j);
if i<=j then
begin
y:=a[i]; a[i]:=a[j]; a[j]:=y;
inc(i); dec(j);
end;
until i>j;
if l<j then sort(l,j);
if i<r then sort(i,r);
end;
begin
sort(1,max);
end;
堆排序
堆排序原理及分析
起源
1991年计算机先驱奖获得者、斯坦福大学计算机科学系教授罗伯特•弗洛伊德(Robert W．Floyd)和威廉姆斯(J．Williams)在1964年共同发明了著名的堆排序算法( Heap Sort ) “堆”定义
n个关键字序列Kl，K2，…，Kn称为(Heap)，当且仅当该序列满足如下性质(简称为堆性质)：
(1) ki≤K2i且ki≤K2i+1 或(2)Ki≥K2i且ki≥K2i+1(1≤i≤n)
若将此序列所存储的向量R[1..n]看做是一棵完全二叉树的存储结构，则堆实质上是满足如下性质的完全二叉树：树中任一非叶结点的关键字均不大于(或不小于)其左右孩子(若存在)结点的关键字。

（即如果按照线性存储该树，可得到一个不下降序列或不上升序列）【例】关键字序列(10，15，56，25，30，70)和(70，56，30，25，15，10)分别满足堆性质(1)和(2)，故它们均是堆，其对应的完全二叉树分别如小根堆示例和大根堆示例所示。

大根堆和小根堆：根结点(亦称为堆顶)的关键字是堆里所有结点关键字中最小者的堆称为小根堆，又称最小堆。

根结点(亦称为堆顶)的关键字是堆里所有结点关键字中最大者，称为大根堆，又称最大堆。

注意：①堆中任一子树亦是堆。

②以上讨论的堆实际上是二叉堆(Binary Heap)，类似地可定义k叉堆。

堆排序
堆排序利用了大根堆(或小根堆)堆顶记录的关键字最大(或最小)这一特征，使得在当前无序区中选取最大(或最小)关键字的记录变得简单。

（1）用大根堆排序的基本思想
①先将初始文件R[1..n]建成一个大根堆,此堆为初始的无序区
②再将关键字最大的记录R[1](即堆顶)和无序区的最后一个记录R[n]交换，由此得到新的无序区R[1..n-1]和有序区R[n]，且满足R[1..n-1].keys≤R[n].key
③由于交换后新的根R[1]可能违反堆性质，故应将当前无序区R[1..n-1]调整为堆。

然后再次将R[1..n-1]中关键字最大的记录R[1]和该区间的最后一个记录R[n-1]交换，由此得到新的无序区R[1..n-2]和有序区R[n-1..n]，且仍满足关系R[1..n-2].keys≤R[n-1..n].keys，同样要将R[1..n-2]调整为堆。

……
直到无序区只有一个元素为止。

（2）大根堆排序算法的基本操作：
①初始化操作：将R[1..n]构造为初始堆；
②每一趟排序的基本操作：将当前无序区的堆顶记录R[1]和该区间的最后一个记录交换，然后将新的无序区调整为堆(亦称重建堆)。

注意：
①只需做n-1趟排序，选出较大的n-1个关键字即可以使得文件递增有序。

②用小根堆排序与利用大根堆类似，只不过其排序结果是递减有序的。

堆排序和直接选择排序相反：在任何时刻堆排序中无序区总是在有序区之前，且有序区是在原向量的尾部由后往前逐步扩大至整个向量为止
特点
堆排序(HeapSort)是一树形选择排序。

堆排序的特点是：在排序过程中，将R[l..n]看成是一棵完全二叉树的顺序存储结构，利用完全二叉树中双亲结点和孩子结点之间的内在关系(参见二叉树的顺序存储结构)，在当前无序区中选择关键字最大(或最小)的记录
堆排序与直接选择排序的区别
直接选择排序中，为了从R[1..n]中选出关键字最小的记录，必须进行n-1次比较，然后在R[2..n]中选出关键字最小的记录，又需要做n-2次比较。

事实上，后面的n-2次比较中，有许多比较可能在前面的n-1次比较中已经做过，但由于前一趟排序时未保留这些比较结果，所以后一趟排序时又重复执行了这些比较操作。

堆排序可通过树形结构保存部分比较结果，可减少比较次数。

算法分析
堆[排序的时间，主要由建立初始]堆和反复重建堆这两部分的时间开销构成，它们均是通过调用Heapify实现的。

堆排序的最坏时间复杂度为O(nlog2n)。

堆序的平均性能较接近于最坏性能。

由于建初始堆所需的比较次数较多，所以堆排序不适宜于记录数较少的文件。

堆排序是就地排序，辅助空间为O(1)，
它是不稳定的排序方法。

堆排序(Pascal/Delphi描述)
Const
FI = 'Heap.In' ;
FO = 'Heap.Out' ;
MaxSize = 10000 ;
Type
TIndex = Longint ;
TDat = Array [ 0 .. MaxSize ] Of TIndex ;
Var
N , M : TIndex ;
D : TDat ;
Procedure Swap ( A, B : TIndex ) ;
Var
Tmp : TIndex ;
Begin
Tmp := D [ A ] ;
D [ A ] := D [ B ] ;
D [ B ] := Tmp ;
End ;
Procedure DownSift ( Node : TIndex ) ;
Var
LSon , RSon : TIndex ;
Father : TIndex ;
Change : Boolean ;
Begin
Repeat
Change := False ;
If Node Shl 1 &gt; N Then
Exit ;
LSon := Node Shl 1 ;
RSon := LSon + 1 ;
Father := Node ;
If ( LSon &lt;= N ) And ( D [ Father ] &lt; D [ LSon ] ) Then Father := LSon ;
If ( RSon &lt;= N ) And ( D [ Father ] &lt; D [ RSon ] ) Then Father := RSon ;
If ( Father &lt;&gt; Node ) Then
Begin
Swap ( Father , Node ) ;
Node := Father ;
Change := True ;
End ;
Until Not Change ;
End ;
Procedure HeapReset ;
Var
I : TIndex ;
Begin
For I := ( N Shr 1 ) DownTo 1 Do
DownSift ( I ) ;
End ;
Procedure Init ;
Var
I : TIndex ;
Begin
FillChar ( D , SizeOf ( D ) , 0 ) ;
Readln ( N ) ;
For I := 1 To N Do
Read ( D [ I ] ) ;
End ;
Procedure Main ;
Var
I : TIndex ;
Begin
M := N ;
HeapReset ;
For I := M DownTo 2 Do
Begin
Swap ( 1 , N ) ;
Dec ( N ) ;
DownSift ( 1 ) ;
End ;
End ;
Procedure Final ;
Var
I : TIndex ;
Begin
For I := 1 To M Do
Write ( D [ I ] , ' ' ) ;
End ;
Begin
Assign ( Input , FI ) ;
Assign ( Output , FO ) ;
Reset ( Input ) ;
Rewrite ( Output ) ;
Init ;
Main ;
Final ;
Close ( Input ) ;
Close ( Output ) ;
End .
实现
Pascal中的较简单实现
var
i,j,k,n:integer;
a:array[0..100] of integer;
procedure swap(var a,b:integer);
var t:integer;
begin t:=a;a:=b;b:=t;
end;
procedure heapsort(i,m:integer);
begin
while i*2<=m do
begin
i:=i*2;
if (i<m) and (a[i]<a[i+1]) then inc(i);
if a[i]>a[i div 2] then swap(a[i],a[i div 2])
else break;
end;
end;
begin
readln(n);
for i:=1 to n do read(a[i]);
for i:=n div 2 downto 1 do heapsort(i,n);
for i:=n downto 2 do
begin
swap(a[i],a[1]);
heapsort(1,i-1);
end;
for i:=1 to n do write(a[i],' ');
end
归并排序
归并排序是多次将两个或两个以上的有序表合并成一个新的有序表。

最简单的归并是直接将两个有序的子表合并成一个有序的表。

在内部排序中，通常采用的是2-路归并排序。

即：将两个位置相邻的记录有序子序列归并为一个记录的有序序列。

每一趟归并的时间复杂度为O(n)
在插入排序，选择排序，快速排序，归并排序这几种排序中，要求内存量最大的是归并排序。

F. 归并排序
{a为序列表，tmp为辅助数组}
procedure merge(var a:listtype; p,q,r:integer);
{将已排序好的子序列a[p..q]与a[q+1..r]合并为有序的tmp[p..r]}
var I,j,t:integer;
tmp:listtype;
begin
t:=p;i:=p;j:=q+1;{t为tmp指针，I,j分别为左右子序列的指针}
while (t<=r) do begin
if (i<=q){左序列有剩余} and ((j>r) or (a<=a[j])) {满足取左边序列当前元素的要求}
then begin
tmp[t]:=a; inc(i);
end
else begin
tmp[t]:=a[j];inc(j);
end;
inc(t);
end;
for i:=p to r do a[i]:=tmp[i];
end;{merge}
procedure merge_sort(var a:listtype; p,r: integer); {合并排序a[p..r]}
var q:integer;
begin
if p<>r then begin
q:=(p+r-1) div 2;
merge_sort (a,p,q);
merge_sort (a,q+1,r);
merge (a,p,q,r);
end;
end;
{main}
begin
merge_sort(a,1,n);
end.
基数排序
“基数排序法”（radix sort）则是属于“分配式排序”（distribution sort），基数排序法又称“桶子法”（bucket sort）或bin sort，顾名思义，它是透过键值的部份资讯，将要排序的元素分配至某些“桶”中，藉以达到排序的作用，基数排序法是属于稳定性的排序，其时间复杂度为O (nlog(r)m)，其中r为所采取的基数，而m为堆数，在某些时候，基数排序法的效率高于其它的比较性排序法。

解法
基数排序的方式可以采用LSD（Least significant digital）或MSD（Most significant digital），LSD的排序方式由键值的最右边开始，而MSD则相反，由键值的最左边开始。

以LSD为例，假设原来有一串数值如下所示：
73, 22, 93, 43, 55, 14, 28, 65, 39, 81
首先根据个位数的数值，在走访数值时将它们分配至编号0到9的桶子中：
1 81
2 22
3 73 93 43
4 14
5 55 65
6
7
8 28
9 39
接下来将这些桶子中的数值重新串接起来，成为以下的数列：
81, 22, 73, 93, 43, 14, 55, 65, 28, 39
接着再进行一次分配，这次是根据十位数来分配：
1 14
2 22 28
3 39
4 43
5 55
6 65
7 73
8 81
9 93
接下来将这些桶子中的数值重新串接起来，成为以下的数列：
14, 22, 28, 39, 43, 55, 65, 73, 81, 93
这时候整个数列已经排序完毕；如果排序的对象有三位数以上，则持续进行以上的动作直至最高位数为止。

LSD的基数排序适用于位数小的数列，如果位数多的话，使用MSD的效率会比较好，
MSD的方式恰与LSD相反，是由高位数为基底开始进行分配，其他的演算方式则都相同。

希尔排序
希尔排序(Shell Sort)是插入排序的一种。

因D．L．Shell于1959年提出而得名。

希尔排序基本思想
基本思想：
先取一个小于n的整数d1作为第一个增量，把文件的全部记录分成d1个组。

所有距离为dl的倍数的记录放在同一个组中。

先在各组内进行直接插入排序；然后，取第二个增量d2<d1重复上述的分组和排序，直至所取的增量dt=1(dt<dt-l<…<d2<d1)，即所有记录放在同一组中进行直接插入排序为止。

该方法实质上是一种分组插入方法。

给定实例的shell排序的排序过程
假设待排序文件有10个记录，其关键字分别是：
49，38，65，97，76，13，27，49，55，04。

增量序列的取值依次为：
5，3，1
Shell排序的算法实现
1．不设监视哨的算法描述
void ShellPass(SeqList R，int d)
{//希尔排序中的一趟排序，d为当前增量
for(i=d+1;i<=n；i++) //将R[d+1．．n]分别插入各组当前的有序区
if(R[ i ].key<R[i-d].key){
R[0]=R;j=i-d；//R[0]只是暂存单元，不是哨兵
do {//查找R的插入位置
R[j+d]=R[j]；//后移记录
j=j-d；//查找前一记录
}while(j>0&&R[0].key<R[j].key)；
R[j+d]=R[0]；//插入R到正确的位置上
} //endif
} //ShellPass
void ShellSort(SeqList R)
{
int increment=n；//增量初值，不妨设n>0
do {
increment=increment/3+1；//求下一增量
ShellPass(R，increment)；//一趟增量为increment的Shell插入排序
}while(increment>1)
} //ShellSort
注意：
当增量d=1时，ShellPass和InsertSort基本一致，只是由于没有哨兵而在内循环中增加了一个循环判定条件"j>0"，以防下标越界。

2．设监视哨的shell排序算法
具体算法【参考书目[12] 】
算法分析
1．增量序列的选择
Shell排序的执行时间依赖于增量序列。

好的增量序列的共同特征：
①最后一个增量必须为1；
②应该尽量避免序列中的值(尤其是相邻的值)互为倍数的情况。

有人通过大量的实验，给出了目前较好的结果：当n较大时，比较和移动的次数约在nl.25到1.6n1.25之间。

2．Shell排序的时间性能优于直接插入排序
希尔排序的时间性能优于直接插入排序的原因：
①当文件初态基本有序时直接插入排序所需的比较和移动次数均较少。

②当n值较小时，n和n2的差别也较小，即直接插入排序的最好时间复杂度O(n)和最坏时间复杂度0(n2)差别不大。

③在希尔排序开始时增量较大，分组较多，每组的记录数目少，故各组内直接插入较快，后来增量di逐渐缩小，分组数逐渐减少，而各组的记录数目逐渐增多，但由于已经按di-1。