第9章 排序（Sort）
排序：假設含有n個記錄的序列爲{r1,r2,……,rn}，其相應的關鍵字分別爲{k1,k2,……,kn}，需確定1,2,……,n的一種排序
p1,p2,……,pn，使其相應的關鍵字滿足kp1<=kp2<=……<=kpn（非遞減或非遞增）關係，即使得序列稱爲一個按關鍵字有序
的序列{rp1,rp2,……,rpn}，這樣的操作就稱爲排序
主要介紹7中排序的算法，按照算法的複雜度分爲兩大類：
簡單算法：冒泡排序、簡單選擇排序和直接插入排序
改進算法：希爾排序、堆排序、歸併排序和快速排序
結構定義
#define MAXSIZE 10 /* 用於要排序數組個數最大值，可根據需要修改 */
typedef struct
{
int r[MAXSIZE+1]; /* 用於存儲要排序數組，r[0]用作哨兵或臨時變量 */
int length; /* 用於記錄順序表的長度 */
}SqList;void swap(SqList *L, int i, int j)
{
int temp = L->r[i];
L->r[i] = L->r[j];
L->r[j] = temp;
}
冒泡排序（Bubble Sort）
冒泡排序，一種交換排序，它的基本思想是：兩兩比較相鄰記錄的關鍵字，如果反序則交換，直到沒有反序的記錄爲止。
時間複雜度O（n^2)
/* 對順序表L作交換排序（冒泡排序初級版） */
void BubbleSort0(SqList *L)
{
int i, j;
for(i=1;i<L->length;i++)
{
for(j=i+1;j<L->length;j++)
{
if (L->r[i]>L-r[j])
{
swap(L,i,j);
}
}
}
}
/* 對順序表L作冒泡排序 */
void BubbleSort(SqList *L)
{
int i, j;
for(i=1;i<L->length;i++)
{
for(j=L->length-1;j>=i;j--) /* 注意j是從後往前循環 */
{
if (L-r[j] > L->r[j+1]) /* 若前者大於後者（注意這裏與上一算法差異） */
{
swap(L, j, j+1); /* 交換L->r[j]與L->r[j+1]的值 */
}
}
}
}
/* 對順序表L作改進冒泡算法 */
void BubbleSort(SqList *L)
{
int i, j;
Status flag = true; /* flag用來作爲標記 */
for(i=1;i<L->length && flag;i++) /* 若flag爲true則退出循環 */
{
flag = false; /* 初始爲false */
for(j=L->length-1;j>=i;j--) /* 注意j是從後往前循環 */
{
if (L-r[j] > L->r[j+1]) /* 若前者大於後者（注意這裏與上一算法差異） */
{
swap(L, j, j+1); /* 交換L->r[j]與L->r[j+1]的值 */
flag = true; /* 如果有數據交換，則flag爲true */
}
}
}
}
簡單選擇排序（Simp Selection Sort）
簡單選擇排序法就是通過n-i次關鍵字間的比較，從n-i+1個記錄中選出關鍵字最小的記錄，並和第i（1<=i<=n）個記錄交換之。
/* 對順序表L作簡單選擇排序 */
void SelectSort(SqList *L)
{
int i,j,min;
for(i=1;i<L->length;i++)
{
min = i; /* 將當前下標定義爲最小值小標 */
for(j=i+1;j<=L->length;j++) /* 循環之後的數據 */
{
if (L->r[min]>L->r[j]) /* 如果有小於當前最小值的關鍵字 */
min = j; /* 將此關鍵字的下標賦值給min */
}
if (i != min) /* 若min不等於i，說明直到最小值，交換 */
swap(L,i,min); /* 交換L->r[i]與L->r[min]的值 */
}
}
直接插入排序（Straight Insertion Sort）
直接插入排序的基本操作是將一個記錄插入到已經排好序的有序表中，從而得到一個新的、記錄數增1的有序表。
/* 對順序表L作直接插入排序 */
void InsertSort(SqList *L)
{
int i,j;
for(i=2;i<L->length;i++)
{
if (L->r[i]<L-r[i-1]) /* 需將L->r[i]插入有序子表 */
{
L->r[0] = L->r[i]; /* 設置哨兵 */
for(j=i-1;L->r[j]>r[0];j--)
L->r[j+1] = L->r[j]; /* 記錄後移 */
L->r[j+1] = L->r[0]; /* 插入到正確位置 */
}
}
}
希爾排序（Shell Sort）
時間複雜度O（n^3/2)
/* 對順序表L作希爾排序 */
void ShellSort(SqList *L)
{
int i, j;
int increment = L->length;
do
{
increment = increment/3 + 1; /* 增量序列 */
for(i=increment+1;i<L->length;i++)
{
if (L->r[i]<L[i-increment])
{
/* 需將L->r[i]插入有序增量子表 */
L->r[0] = L->r[i]; /* 暫存在L->r[0] */
for(j=i-increment;j>0 && L->r[0]<L->r[j];j-=increment)
L->r[j+increment] = L->r[j]; /* 記錄後移，查找插入位置 */
L->r[j+increment] = L->r[0]; /* 插入 */
}
}
}while (increment > 1);
}
堆排序（Heap Sort）
堆是具有下列性質的完全二叉樹：每個結點的值都大於或等於其左右孩子結點的值，稱爲大頂堆；
或者每個結點的值都小於或等於其左右孩子結點的值，稱爲小頂堆。
堆排序就是利用堆（假設利用大頂堆）進行排序的方法。它的基本思想就是，將待排序的序列構造成一個大頂堆。
此時整個序列的最大值就是堆頂的根節點。將它移走（其實就是將其與堆數組的末尾元素交換，此時末尾元素就是
最大值），然後將剩餘的n-1個序列重新構造成一個堆，這樣就會得到n個元素中的次小值。如此反覆執行，便能
得到一個有序序列了。
時間複雜度爲O（nlogn）
/* 對順序表L進行堆排序 */
void HeapSort(SqList *L)
{
int i;
for(i=L->length/2;i>0;i--) /* 把L中的r構建成一個大頂堆 */
HeapAdjust(L,i,L->length);
for(i=L->length;i>1;i--)
{
swap(L,1,i); /* 將堆頂記錄和當前未經排序子序列的最後一個記錄交換 */
HeapAdjust(L,1,i-1); /* 將L->r[1..i-1]重新調整爲大頂堆 */
}
}
/* 已知L->r[s..m]中記錄的關鍵字除L->r[s]之外均滿足堆的定義 */
/* 本函數調整L->r[s]的關鍵字，使L->r[s..m]成爲一個大頂堆 */
void HeapAdjust(SqList *L, int s, int n)
{
int temp,j;
temp = L->r[s];
for(j=2*s;j<=m;j*=2) /* 沿關鍵字較大的孩子結點向下篩選 */
{
if (j<m && L->r[j]<L->r[j+1])
++j; /* j爲關鍵字中較大的記錄的下標 */
if (temp>=L->r[j])
break; /* rc應插入在位置s上 */
L->r[s] = L->r[j];
s= j;
}
L->r[s] = temp; /* 插入 */
}
歸併排序（Merging Sort）
歸併排序就是利用歸併的思想實現的排序方法，原理是假設初始序列含有n個記錄，則可以看成是n個有序的子序列，每個子序列的長度
爲1，然後兩兩歸併，得到[n/2]（[x]表示不小於x的最小整數）個長度爲2或1的有序子序列；再兩兩歸併，……，如此重複，直至得到
一個長度爲n的有序序列爲止，這種排序方法稱爲2路歸併排序。
時間複雜度爲O（nlogn）
/* 對順序表L作歸併排序 */
void MergeSrot(SqList *L)
{
MSort(L->r,L->r,l,L->length);
}
/* 將SR[s..t]歸併排序爲TR1[s..t] */
void MSort(int SR[], int TR1[], int s, int t)
{
int m;
int TR2[MAXSIZE+1];
if (s == t)
TR1[s] = SR[s];
else
{
m = (s+t)/2; /* 將SR[s..t]平分爲SR[s..m]和SR[m+1..t] */
MSort(SR,TR2,s,m); /* 遞歸將SR[s..m]歸併爲有序的TR2[s..m] */
MSort(SR,TR2,m+1,t); /* 遞歸將SR[m+1..t]歸併爲有序TR2[m+1..t] */
Merge(TR2,TR1,s,m,t); /* 將TR2[s..m]和TR2[m+1..t]歸併到TR1[s..t] */
}
}
/* 將有序的SR[i..m]和SR[m+1..n]歸併爲有序的TR[i..n] */
void Merge(int SR[],int TR[],int i,int m, int n)
{
int j,k,l;
for(j=m+1,k=i;i<=m && j<=n;k++) /* 將SR中記錄由小到大歸併入TR */
{
if (SR[i]<SR[j])
TR[k] = SR[i++];
else
TR[k] = SR[j++];
}
if (i<=m)
{
for(l=0;l<=m-i;l++)
TR[k+1] = SR[i+1]; /* 將剩餘的SR[i..m]複製到TR */
}
if (j<=n)
{
for(l=0;l<=n-j;l++)
TR[k+1] = SR[j+1]; /* 將剩餘的SR[j..m]複製到TR */
}
}
非遞歸實現歸併排序
/* 對順序表L作歸併非遞歸排序 */
void MergeSort2(SqList *L)
{
int* TR = (int*) malloc(L->length*sizeof(int)); /* 申請額外空間 */
int k = 1;
while(k<L->length)
{
MergePass(L->r,TR,L->length);
k = 2*k; /* 子序列長度加倍 */
MergePass(TR,L->r,k,L->length);
k = 2*k; /* 子序列長度加倍 */
}
}
/* 將SR[]中相鄰長度爲s的子序列兩兩歸併到TR[] */
void MergePass(int SR[],int TR[],int s,int n)
{
int i=1;
int j;
while(i <= n-2*s +1)
{
Merge(SR, TR, i+s-1,i+2*s-1); /* 兩兩歸併 */
i = i+2*s;
}
if (i<n-s+1) /* 歸併最後兩個序列 */
Merge(SR,TR,i,i+s-1,n);
else /* 若最後只剩下單個子序列 */
for(j=1;j<=n;j++)
TR[j] = SR[j]
}
非遞歸的迭代方法，避免了遞歸時深度爲log2n的棧空間，空間只是用到申請歸併臨時用得TR數組，
因此空間使用歸併也在時間性能上有一定的提升，應該說，使用歸併排序時，儘量考慮用非遞歸方法。
快速排序（Quick Sort）
快速排序的基本思想是：通過一趟排序將待排記錄分隔成獨立的兩部分，其中一部分記錄的關鍵字均
比另一部分記錄的關鍵字小，則可分別對這兩部分記錄繼續進行排序，以達到整個序列有序的目的。
最優的情況下，快速排序算法的時間複雜度O（nlogn）
最壞的情況下，快速排序算法的時間複雜度O（n^2）
/* 對順序表L作快速排序 */
void QuickSort(SqList *L)
{
QSort(L,1,L->length);
}
/* 對順序表L中的子序列L->r[low..high]作快速排序 */
void QSort(SqList *L,int low, int high)
{
int pivot;
if (low < high)
{
pivot = Partition(L,low,high); /* 將L->r[low..high]一分爲二，算出樞軸值pivot */
QSort(L,low,pivot-1); /* 對低子表遞歸排序 */
QSort(L,pivot+1,high); /* 對高子表遞歸排序 */
}
}
/* 交換順序表L中子表的記錄，是樞軸記錄到位，並返回其所在位置 */
/* 此時在它之前（後）的記錄均不大（小）於它。 */
int Partition(SqList *L, int low, int high)
{
int pivotkey;
/* 採用了三數取中法，來確定頂樞軸 */
int m = low + (high - low);
if (L->r[low]>L->r[high])
swap[L,low,high];
if (L->r[m] > L->r[high])
swap(L,high,m);
if (L->r[m] > L->r[low])
swap(L,m,low);
/* 三數取中法(結束) */
pivotkey = L->r[low]; /* 用子表的第一個記錄作樞軸記錄 */
while(low<high) /* 從表的兩端交替向中間掃描 */
{
while(low<high && L->r[high]>=pivotkey)
high--;
swap(L,low,high); /* 將比樞軸記錄小的記錄交換到低端 */
while(low<high&& L->r[low]<=pivotkey)
low++;
swap(L,low,high); /* 將比樞軸記錄大得記錄交換到高端 */
}
return low; /* 返回樞軸所在位置 */
}
/* 快速排序優化算法 */
int Partition1(SqList *L, int low, int high)
{
int pivotkey;
/* 採用了三數取中法，來確定頂樞軸 */
int m = low + (high - low);
if (L->r[low]>L->r[high])
swap[L,low,high];
if (L->r[m] > L->r[high])
swap(L,high,m);
if (L->r[m] > L->r[low])
swap(L,m,low);
/* 三數取中法(結束) */
pivotkey = L->r[low]; /* 用子表的第一個記錄作樞軸記錄 */
L->r[0] = pivotkey; /* 將樞軸關鍵字備份到L->r[0] */
while(low<high) /* 從表的兩端交替向中間掃描 */
{
while(low<high && L->r[high]>=pivotkey)
high--;
L->r[low] = L->r[high];
while(low<high&& L->r[low]<=pivotkey)
low++;
L->r[high] = L->r[low];
}
L->r[low] = L->r[0]; /* 將樞軸數值替換回L->r[low] */
return low; /* 返回樞軸所在位置 */
}
優化小數組時的排序
#define MAX_LENGTH_INSERT_SORT 7
void QSort(SqList &L, int low, int high)
{
int pivot;
if ((high-low)>MAX_LENGTH_INSERT_SORT)
{
pivot = Partition(L,low,high);
QSort(L,low,pivot-1);
QSort(L,pivot+1,high);
}
else
{
InsertSort(L); /* 採用直接插入排序 */
}
}
優化遞歸操作
void QSort(SqList &L, int low, int high)
{
int pivot;
if ((high-low)>MAX_LENGTH_INSERT_SORT)
{
while(low<high)
{
pivot = Partition1(L,low,high);
QSort1(L,low,pivot-1);
low = pivot+1;
}
}
else
{
InsertSort(L); /* 採用直接插入排序 */
}
}