排序总结

#define MAXSIZE    20  //一个用作示例的小顺序表的最大长度 
typedef int KeyType;//定义关键字类型为整数类型
typedef struct {
           KeyType    key;              //关键字项
           InfoType    otherinfo;   //其他数据项
} RedType;                              //记录类型
typedef struct {
          RedType      r[MAXSIZE+1];    //r[0]闲置或用作哨兵单元
          int                 length;        //顺序表长度
}SqList;                            //顺序表类型

插入排序

void   InsertSort(SqList &L) {
         // 对顺序表L做直接插入排序   
     for ( i=2 ;  i<=L.length ;  ++i) { 
       if (L.r[i].key < L.r[i-1].key)  {   //若小于，需将L.r[i]插入有序子表
            L.r[0]=L.r[i];                          //复制为哨兵
        L.r[i] = L.r[i-1];  
          for (j=i-2; L.r[0].key<L.r[j].key; --j)
                    L.r[j+1]=L.r[j];               //记录后移
             L.r[j+1]=L.r[0];                          //插入到正确位置
         }
    }
} //  InsertSort 

折半插入排序

void BInsertSort (SqList &L)     {//对顺序表L作折半插入排序
    for  (i=2; i<=L.length; i++)    {
          L.r[0] = L.r[i];             //将L.r[i]暂存到L.r[0]
          low = 1;  high = i-1;  
          while  (low <= high)      {     //在r[low, high]中折半查找有序插入的位置
                 m = (low + high)/2;
                 if (L.r[0].key < L.r[m].key) 
                           high = m-1;  //如果L.r[0].key<L.r[m].key，则插入点在低半区
                 else low = m + 1;         //否则插入点在高半区
          }//while
          for(j=i-1; j>=high+1; --j)  L.r[j+1] = L.r[j];   //记录后移
          L.r[high+1] = L.r[0];                            //插入
      }//for
}//BInsertSort

表插入排序

#define SIZE 100                  //静态链表容量
typedef struct {
      RcdType          rc;            //记录项
      int                    next;        //指针项
}SLNode；                     //表结点类型

typedef struct {
      SLNode           r[SIZE];           //0号单元为表头结点
      int                    length;         //链表当前长度
}SLinkListType；                  //静态链表类型 

希尔排序

void  ShellInsert(SqList &L,  int dk){
         //对顺序表L做一趟希尔插入排序
  for  (i=dk+1;  i<=L.length; i+=1) {//dk+1为第一个子序列的第二个元素下标        if (L.r[i].key < L.r[i-dk].key)  {//需将L.r[i]插入有序增量子表
                L.r[0]=L.r[i];             //暂存在L.r[0]中 
                for (j=i-dk; j>0 &&(L.r[0].key <L.r[j].key);  j-=dk)  
                    L.r[j+dk]=L.r[j];  //记录后移，查找插入位置
                L.r[j+dk]=L.r[0];    //插入记录
   }
}//ShellInsert
void  ShellSort(SqList &L, int dlta[], int t)  {
      //按增量序列dlta[0..t-1]对顺序表L作希尔排序
     for(k=0; k<t; ++k) 
         ShellInsert(L, dlta[k])； //一趟增量为dlta[k]的插入排序
} //ShellSort

快速排序

int Partition(SqList &L, int low, int high)  {
   //交换顺序表L中子表r[low..high]的记录，枢轴记录到位，并返回其所在位置，此      //时它之前（后）的记录不大（小）于它。
   L.r[0] = L.r[low];                             //用子表的第一个记录作枢轴记录
   pivotkey = L.r[0].key;                     //枢轴记录关键字
   while (low < high)   {                      //从表的两端交替地向中间扫描
        while （low < high  && L.r[high].key >= pivotkey)  --high;
                 L.r[low] = L.r[high];           //将比枢轴记录小的记录移到低端
         while (low < high  && L.r[low].key <= pivotkey)  ++low;
                 L.r[high] = L.r[low];          //将比枢轴记录大的记录移到高端
    }
    L.r[low] = L.r[0];                            //枢轴记录到位
    return low;                                       //返回枢轴位置
} // Partition
void QSort(SqList &L, int low, int high)  {
   //对顺序表L中子序列L.r[low..high]作快速排序（递归形式）
   if (low < high)    {                       //长度大于1
         pivotloc = Partition(L, low, high);  //将L.r[low..high]一分为二
          QSort(L, low, pivotloc - 1);       //对低子表递归排序，                                                            //  pivotloc是枢轴位置
          Qsort(L, pivotloc +1, high);    //对高子表递归排序
   }
} // QSort

简单选择排序的基本思想：第i趟简单选择排序是指通过n-i次关键字的比较，从n-i+1个记录中选出关键字最小的记录，并与第i个记录进行交换。一共需进行n-1趟比较，直到所有记录排序完成为止。

void  SelectSort(SqList &L)   {
     //对顺序表L做简单选择排序 
      for ( i=1 ; i<L.length; ++i)  { //选择第i小的记录,并交换到位 
            j = SelectMinKey(L, i);//在L.r[i..L.length]中选择key最小的记录
            if (i != j)  L.r[i]<->L.r[j];   //与第i个记录交换 
      }
}//SelectSort

2-路归并排序

void Merge(RcdType SR[], RcdType &TR[], int i, int m, int n)  {
    //将有序的SR[i..m]和SR[m+1..n]归并成有序的TR[i..n]
    for (j=m+1, k=i；i<=m && j <=n; ++k)  {
         //将SR中记录由小到大并入TR
         if (SR[i].key <= SR[j].key) TR[k] = SR[i++];
         else TR[k]=SR[j++];
   }  
    if  (i <=m) TR[k..n] = SR[i..m];    //剩余SR[i..m]复制到TR
    if (j <= n) TR[k..n] =  SR[j..n];      //剩余SR[j..n]复制到TR
}//Merge

递归形式的2-路归并排序的算法如下：

void MSort (RcdType SR[], RcdType &TR1[], int s, int t)   {
    // 将SR[s..t]归并排序为TR1[s..t]
    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]        
    }
}  //MSort 
void MergeSort(SqList &L)  {
       // 对顺序表L作归并排序
       MSort(L.r, L.r, 1, L.length);
}  //MergeSort