排序

1. 排序方法的分类

稳定的排序用'Y'表示，不稳定的排序用'N'表示

插入排序：直接插入排序(Y)、希尔排序
交换排序：冒泡排序(Y)、快速排序(N)
选择排序：直接选择排序(N)、堆排序(N)
归并排序：二路归并排序(Y)


2. 排序方法的特点

快速排序：适合对无序记录排序，平均性能最好，时间复杂度为O(nlogn)
直接插入排序：从待排序列中依次取出元素与已排子序列比较，找出在已排子序列中的位置。元素有序时比较次数最少。
冒泡排序：每一趟把最大元素置后
选择排序：从待排序列中选出最小的元素，放在已排子序列的末端。能在排序完成前能输出前几个最小的元素
堆排序：类似于选择排序，是完全二叉树的一种应用。一趟排序后最后一个元素或最大或最小
直接插入排序和冒泡排序：元素逐个比较，时间复杂度为O(n^2)


3. 排序方法

#include <stdio.h>

/* 宏定义 */
#define LQ(a, b) ((a) <= (b))

/* 
 * 插入排序: 直接插入排序
 * 
 * 参数: x -- 待排序列
 *       n -- 序列中元素个数 
 */
void InsertSort(int x[], int n)
{
    int sentinel=0; /* sentinel: 哨兵 */
    int i, j, k;
    for(i=1; i<n; i++) /* 序列中的第一个元素可以看成一个有序表 */
    {
        if(LQ(x[i], x[i-1]))
        {
            sentinel=x[i]; /* 复制为哨兵 */
            for(j=i-1; j>=0 && LQ(sentinel, x[j]); --j)
                x[j+1]=x[j]; /* 记录后移 */
            x[j+1]=sentinel; /* 插入到正确位置 */
        }
        /*输出每一趟排序的结果*/
        printf("第 %d 趟排序后的结果: ", i);
        for(k=0; k<n; k++)
            printf("%d ", x[k]);
        printf("/n");
    }
}

 

 

void lnsertSort(SeqList R) { //对顺序表R中的记录R[1..n]按递增序进行插入排序 int i，j； for(i=2;i<=n；i++) //依次插入R[2]，…，R[n] if(R[i].key<R[i-1].key){//若R[i].key大于等于有序区中所有的keys，则R[i] //应在原有位置上 R[0]=R[i];j=i-1; //R[0]是哨兵，且是R[i]的副本 do{ //从右向左在有序区R[1．．i-1]中查找R[i]的插入位置 R[j+1]=R[j]； //将关键字大于R[i].key的记录后移 j-- ； }while(R[0].key<R[j].key)； //当R[i].key≥R[j].key时终止 R[j+1]=R[0]； //R[i]插入到正确的位置上 }//endif }//InsertSort

 

 

上面两个代码片段都是直接插入排序，但是第一片段代码并没有真正的使用上哨兵。

 

 

/* 
 * 交换排序: 起泡排序
 * 
 * 参数：x -- 待排序列
 *       n -- 序列中元素个数 
 */
void BubbleSort(int x[], int n)
{
    int temp, exchange;
    int i, j, k;
    for(i=n-1; i>0; i--)  //最多做n-1趟排序
    {
        exchange=0; //本趟排序开始前, 交换标志应为假
        for(j=0; j<i; j++)
        {
            if(LQ(x[j+1], x[j]))
            {
                temp=x[j+1];
                x[j+1]=x[j];
                x[j]=temp;
                exchange=1;
            }
        }
        if(!exchange) //本趟排序未发生交换，提前终止算法
            break;
        /*输出每一趟排序的结果*/
        printf("第 %d 趟排序后的结果: ", n-i);
        for(k=0; k<n; k++)
            printf("%d ", x[k]);
        printf("/n");
    }
}

/* 
 * 交换排序: 快速排序
 * 
 * 参数：x -- 待排序列
 *       n -- 序列中元素个数 
 */
int Partition(int x[], int low, int high)
{
    int sentinel = x[low];
    int pivotkey = x[low];
    while(low < high)
    {
        while(low<high && LQ(pivotkey, x[high])) --high;
        x[low] = x[high];
        while(low<high && LQ(x[low], pivotkey)) ++low;
        x[high] = x[low];
    }
    x[low]=sentinel;
    return low;
}

void QuickSort(int x[], int low, int high)
{
    int pivotloc, k;
    if(low < high)
    {
        pivotloc=Partition(x, low, high);
        /*输出每一趟排序的结果*/
        printf("排序过程: ");
        for(k=0; k<8; k++)
            printf("%d ", x[k]);
        printf("/n");
        QuickSort(x, low, pivotloc-1);
        QuickSort(x, pivotloc+1, high);
    }
}

/* 
 * 选择排序: 简单选择排序
 * 
 * 参数：x -- 待排序列
 *       n -- 序列中元素个数 
 */
int SelectMinKey(int x[], int low, int high)
{
    int temp = x[low], pos=low;
    while(low <= high)
    {
        if(LQ(x[low], temp))
        {
            temp = x[low];
            pos = low;
        }
        low++;
    }
    return pos;
}

void SelectSort(int x[], int n)
{
    int i, j, k, temp;
    for(i=0; i<n; i++)
    {
        j = SelectMinKey(x, i, n-1);
        if(i!=j)
        {
            temp=x[i];
            x[i]=x[j];
            x[j]=temp;
        }
        /*输出每一趟排序的结果*/
        printf("第 %2d 趟排序后的结果: ", i+1);
        for(k=0; k<n; k++)
            printf("%d ", x[k]);
        printf("/n");
    }
}

int main()
{
    int x[10] = {10, 35, 19, 23, 17, 18, -1, 3, 12, 5}, i;
    printf("/n直接插入排序序列: ");
    for(i=0; i<10; i++)
            printf("%d ", x[i]);
    printf("/n/n");
    InsertSort(x, 10);
    printf("/n/n");
    
    int y[10] = {88, 29, 48, 37, 16, 5, 14, 32, -2, 11};
    printf("冒泡排序序列: ");
    for(i=0; i<10; i++)
            printf("%d ", y[i]);
    printf("/n/n");
    BubbleSort(y, 10);
    printf("/n/n");

    int z[8] = {49, 38, 65, 97, 76, 13, 27, 49};
    printf("快速排序序列: ");
    for(i=0; i<8; i++)
            printf("%d ", z[i]);
    printf("/n/n");
    QuickSort(z, 0, 7);
    printf("/n/n");

    int m[10] = {19, 45, 0, 17, 16, 8, 24, 14, 3, 11};
    printf("简单选择排序序列: ");
    for(i=0; i<10; i++)
            printf("%d ", m[i]);
    printf("/n/n");
    SelectSort(m, 10);
    printf("/n");

    return 0

;
}

2．哨兵的作用
    　算法中引进的附加记录R[0]称监视哨或哨兵(Sentinel)。
   　 哨兵有两个作用：
　　① 进人查找(插入位置)循环之前，它保存了R[i]的副本，使不致于因记录后移而丢失R[i]的内容；
　　② 它的主要作用是：在查找循环中"监视"下标变量j是否越界。一旦越界(即j=0)，因为R[0].key和自己比较，循环判定条件不成立使得查找循环结束，从而避免了在该循环内的每一次均要检测j是否越界(即省略了循环判定条件"j>=1")。
  注意：
　  ① 实际上，一切为简化边界条件而引入的附加结点(元素)均可称为哨兵。
　　  【例】单链表中的头结点实际上是一个哨兵
　　② 引入哨兵后使得测试查找循环条件的时间大约减少了一半，所以对于记录数较大的文件节约的时间就相当可观。对于类似于排序这样使用频率非常高的算法，要尽可能地减少其运行时间。所以不能把上述算法中的哨兵视为雕虫小技，而应该深刻理解并掌握这种技巧。