第 8章 排序技术

排序算法的稳定性
假定在待排序的记录集中，存在多个具有相同键值的记录，若经过排序，这些记录的相对次序仍然保持不变，则称这种排序算法是稳定的；否则称为不稳定的。
排序算法的性能
时间复杂性：基本操作。
内排序在排序过程中的基本操作：
⑴比较：关键码之间的比较；
⑵移动：记录从一个位置移动到另一个位置。
空间复杂性： 辅助存储空间。
辅助存储空间是指在数据规模一定的条件下，除了存放待排序记录占用的存储空间之外，执行算法所需要的其他存储空间。
插入类排序
直接插入排序
基本思想：在插入第 i（i＞1）个记录时，前面的 i-1个记录已经排好序。
void insertSort (int r[ ], int n){
for (i=2; i<=n; i++) {
r[0]=r[i]; j=i-1;
while (r[0]<r[j]) {
r[j+1]=r[j];
j=j-1;
}
r[j+1]=r[0];
}
}
最好情况下（正序）：时间复杂度为O(n)。
最坏情况下（逆序或反序）：时间复杂度为O(n2)。
平均情况下（随机排列）：时间复杂度为O(n2)。
空间性能：需要一个记录的辅助空间。

希尔排序
改进的依据：
1）若待排序记录按关键码基本有序时，直接插入排序的效率可以大大提高；
2）由于直接插入排序算法简单，则在待排序记录数量n较小时效率也很高。
在插入记录r[i]时，自r[i-d]起往前跳跃式（跳跃幅度为d）搜索待插入位置，并且r[0]只是暂存单元，不是哨兵。当搜索位置＜0，表示插入位置已找到。
在搜索过程中，记录后移也是跳跃d个位置。

void Shellsort(int r[],int n){
for (d=n/2; d>=1; d=d/2){
for (i=d+1; i<=n; i++) {
r[0]=r[i];
j=i-d;
while (j>0 && r[0]<r[j])
{
r[j+d]=r[j];
j=j-d;
}
r[j+d]=r[0];
}
}
}
希尔排序的时间性能在O(n2)和O(nlog2n)之间。当n在某个特定范围内，希尔排序所需的比较次数和记录的移动次数约为O(n1.3 ) 。

交换排序
起泡排序
基本思想：两两比较相邻记录的关键码，如果反序则交换，直到没有反序的记录为止。
void BubbleSort(int r[ ], int n)
{
exchange=n;
while (exchange)
{
bound=exchange;
exchange=0；
for (j=1; j<bound; j++)
if (r[j]>r[j+1]) {
r[j]←→r[j+1]；
exchange=j；
}
}
}
最好情况（正序）：时间复杂度为O(n)。
最坏情况（反序）：平均情况：时间复杂度为O(n2)。
快速排序
首先选一个轴值（即比较的基准），通过一趟排序将待排序记录分割成独立的两部分，前一部分记录的关键码均小于或等于轴值，后一部分记录的关键码均大于或等于轴值，然后分别对这两部分重复上述方法，直到整个序列有序。
int Partition(int r[ ], int first, int end)
{
i=first; j=end; //初始化
r[0]=r[i];
while (i<j)
{
while (i<j && r[0]<= r[j]) j–； //右侧扫描
if (i<j) {
r[i]=r[j]; i++; //将较小记录交换到前面
}
while (i<j && r[i]<= r[0]) i++； //左侧扫描
if (i<j) {
r[j]=r[i]; j–; //将较大记录交换到后面
}
}
r[i]=r[0];
retutn i; //i为轴值记录的最终位置
}
最好情况：每一次划分对一个记录定位后，该记录的左侧子表与右侧子表的长度相同，为O(nlog2n)。
最坏情况：每次划分只得到一个比上一次划分少一个记录的子序（另一个子序列为空），这样，总共需要进行n-1趟排序，第i趟排序又要进行为 n-i次比较，O（n2）
平均情况：为O(nlog2n)。

选择排序
选择排序的主要操作是选择，其主要思想是：每趟排序在当前待排序序列中选出关键码最小的记录，添加到有序序列中。
简单选择排序
基本思想：第i 趟在n-i+1（i=1,2,…,n-1）个记录中选取关键码最小的记录作为有序序列中的第i个记录
void selectSort ( int r[ ], int n)
{
for ( i=1; i<n; i++)
{
index=i;
for (j=i+1; j<=n; j++)
if (r[j]<r[index]) index=j;
if (index!=i) r[i]<==>r[index];
}
}
简单选择排序的时间复杂度为O(n2)
空间性能：需一个辅助空间。
堆排序
堆是具有下列性质的完全二叉树：每个结点的值都小于或等于其左右孩子结点的值（称为小根堆），或每个结点的值都大于或等于其左右孩子结点的值（称为大根堆）。
基本思想：
首先将待排序的记录序列构造成一个堆(大顶堆)，此时，选出了堆中所有记录的最大者，然后将它从堆中移走，将剩余的记录再调整成堆，这样又找出了次大的记录，以此类推，直到堆中只有一个记录。
void HeapSort ( int r[], int n)
{
for (i=n/2; i>=1; i–) //初建堆
sift(r, i, n) ;
for (i=1; i<n; i++ )
{
r[1]←→r[n-i+1]; //移走堆顶
sift(r, 1, n-i); //重建堆
}
}
void HeapSort ( int r[], int n)
{
for (i=n/2; i>=1; i–)
sift(r, i, n) ;

for (i=1; i<n; i++ )
{
   r[1]←→r[n-i+1]; 

sift(r, 1, n-i);
}
}
归并排序
归并：将两个或两个以上的有序序列合并成一个有序序列的过程
归并排序的主要操作是归并，其主要思想是：将若干有序序列逐步归并，最终得到一个有序序列。
二路归并排序
基本思想：
将一个具有n个待排序记录的序列看成是n个长度为1的有序序列，然后进行两两归并，得到n/2个长度为2的有序序列，再进行两两归并，得到n/4个长度为4的有序序列，……，直至得到一个长度为n的有序序列为止。
void msort(int a[], int r[], int s, int t){
if(s==t)
return; //如果只有一个数字则返回，无须排序
int mid=(s+t)/2;
msort(s,mid); //分解左序列
msort(mid+1,t); //分解右序列
int i=s, j=mid+1, k=s; //接下来合并
while(i<=mid && j<=t) {
if(a[i]<=a[j]) {
r[k]=a[i]; k++; i++;
}
else {
r[k]=a[j]; k++; j++;
}
}
时间性能：O(nlog2n)。
空间性能：O(n)。
分配排序
基本思想:先将数据分配到不同的桶中,再将桶中的数据收集到一起