排序

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")。
  注意：
　  ① 实际上，一切为简化边界条件而引入的附加结点(元素)均可称为哨兵。
　　  【例】单链表中的头结点实际上是一个哨兵
　　② 引入哨兵后使得测试查找循环条件的时间大约减少了一半，所以对于记录数较大的文件节约的时间就相当可观。对于类似于排序这样使用频率非常高的算法，要尽可能地减少其运行时间。所以不能把上述算法中的哨兵视为雕虫小技，而应该深刻理解并掌握这种技巧。