排序算法

数据结构排序算法总结I

考研复习到数据结构排序这章了，这章的内容比较经典，都是一些很好的算法，将来很可能会用得到，总结一下，加深一下印象。
             文章篇幅有点大，请点击查看更多，下面是跳转链接：
              一、插入排序     
1）直接插入排序      2）折半插入排序     
3）希尔排序
              二、交换排序     
1）冒泡排序           2）快速排序     
              三、选择排序     
1）简单选择排序      2）堆排序     
               四、归并排序     
              五、基数排序    
       一、插入排序
             1）直接插入排序    
算法演示
              时间复杂度：平均情况—O(n2)    
最坏情况—O(n2)    
辅助空间：O(1)     
稳定性：稳定
复制到剪贴板折叠C
代码
void InsertSort(SqList &L) {     

  //
对顺序表L作直接插入排序。   

  int i,j;   

  for (i=2; i<=L.length; ++i)   

    if (LT(L.r[i].key, L.r[i-1].key)) {   

      // "<"时，需将L.r[i]插入有序子表
  
       L.r[0] = L.r[i];                 //
复制为哨兵   

      for (j=i-1;   LT(L.r[0].key, L.r[j].key);   --j)   

         L.r[j+1] = L.r[j];             //
记录后移   

       L.r[j+1] = L.r[0];               //
插入到正确位置   

     }   

} // InsertSort   

             2）折半插入排序
              时间复杂度：平均情况—O(n2)     稳定性：稳定
复制到剪贴板折叠C
代码
void BInsertSort(SqList &L) {     

  //
对顺序表L作折半插入排序。   

  int i,j,high,low,m;   

  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 (LT(L.r[0].key, L.r[m].key)) high = m-1;  //
插入点在低半区   

      else   low = m+1;                             //
插入点在高半区   

     }   

    for (j=i-1; j>=high+1; --j) L.r[j+1] = L.r[j];  //
记录后移   

     L.r[high+1] = L.r[0];                           //
插入   

   }   

} // BInsertSort   

             3）希尔排序

算法演示
              时间复杂度：理想情况—O(nlog2n)     
最坏情况—O(n2)    
稳定性：不稳定
复制到剪贴板折叠C
代码
void ShellInsert(SqList &L, int dk) {     

  //
对顺序表L作一趟希尔插入排序。本算法对算法10.1作了以下修改：   

  //      1.
前后记录位置的增量是dk，而不是1；   

  //      2. r[0]只是暂存单元，不是哨兵。当j<=0时，插入位置已找到。
  
  int i,j;   

  for (i=dk+1; i<=L.length; ++i)   

    if (LT(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 && LT(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 (int k=0; k<t; ++k)   

       ShellInsert(L, dlta[k]);  //
一趟增量为dlta[k]的插入排序   

} // ShellSort   

       
二、交换排序
             1）冒泡排序

算法演示
              时间复杂度：平均情况—O(n2)    
最坏情况—O(n2)    
辅助空间：O(1)     
稳定性：稳定
复制到剪贴板折叠C
代码
void BubbleSort(SeqList R) {   

int i，j;   

Boolean exchange; //交换标志   

for(i=1;i<n;i++){ //最多做n-1趟排序
  
      exchange=FALSE; //本趟排序开始前，交换标志应为假   

     for(j=n-1;j>=i;j--) //对当前无序区R[i..n]自下向上扫描
  
          if(R[j+1].key<R[j].key){//交换记录   

               R[0]=R[j+1]; //R[0]不是哨兵，仅做暂存单元   

               R[j+1]=R[j];   

              
R[j]=R[0];   
               exchange=TRUE; //发生了交换，故将交换标志置为真   

           }   

          if(!exchange) //本趟排序未发生交换，提前终止算法   

          return;   

} //endfor(外循环)   

} //BubbleSort   

             2）快速排序

算法演示
              时间复杂度：平均情况—O(nlog2n)    
最坏情况—O(n2)    
辅助空间：O(log2n)     
稳定性：不稳定
复制到剪贴板折叠C
代码
int Partition(SqList &L, int low, int high) {     

//
交换顺序表L中子序列L.r[low..high]的记录，使枢轴记录到位，       

   //
并返回其所在位置，此时，在它之前（后）的记录均不大（小）于它       

    KeyType pivotkey;       

    RedType temp;       

    pivotkey = L.r[low].key;     //
用子表的第一个记录作枢轴记录       

   while (low<high) {           //
从表的两端交替地向中间扫描       

      while (low<high && L.r[high].key>=pivotkey) --high;       

       temp=L.r[low];       

       L.r[low]=L.r[high];       

       L.r[high]=temp;           //
将比枢轴记录小的记录交换到低端       

      while (low<high && L.r[low].key<=pivotkey) ++low;       

       temp=L.r[low];       

       L.r[low]=L.r[high];       

       L.r[high]=temp;           //
将比枢轴记录大的记录交换到高端       

    }       

   return low;                  //
返回枢轴所在位置       

} // Partition       

      

int Partition(SqList &L, int low, int high) {      

//
交换顺序表L中子序列L.r[low..high]的记录，使枢轴记录到位，       

   //
并返回其所在位置，此时，在它之前（后）的记录均不大（小）于它       

    KeyType pivotkey;       

    L.r[0] = L.r[low];            //
用子表的第一个记录作枢轴记录       

    pivotkey = L.r[low].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]进行快速排序       

  int pivotloc;       

  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   

  

void QuickSort(SqList &L) {  //
算法10.8   

   //
对顺序表L进行快速排序   

    QSort(L, 1, L.length);   

} // QuickSort   
 三、选择排序
             1）简单选择排序

算法演示
              时间复杂度：平均情况—O(n2)    
最坏情况—O(n2)    
辅助空间：O(1)     
稳定性：不稳定
复制到剪贴板折叠C
代码
void SelectSort(SqList &L) {     

  //
对顺序表L作简单选择排序。   

  int i,j;   

  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个记录交换   

       RedType temp;   

       temp=L.r[i];   

       L.r[i]=L.r[j];   

       L.r[j]=temp;       

     }   

   }   

} // SelectSort   

             2）堆排序

算法演示
              时间复杂度：平均情况—O(nlog2n)    
最坏情况—O(nlog2n)    
辅助空间：O(1)     
稳定性：不稳定
复制到剪贴板折叠C
代码
void HeapAdjust(HeapType &H, int s, int m) {     

  //
已知H.r[s..m]中记录的关键字除H.r[s].key之外均满足堆的定义，   

  //
本函数调整H.r[s]的关键字，使H.r[s..m]成为一个大顶堆   

  //
（对其中记录的关键字而言）   

  int j;   

   RedType rc;   

   rc = H.r[s];   

  for (j=2*s; j<=m; j*=2) {   //
沿key较大的孩子结点向下筛选   

    if (j<m && H.r[j].key<H.r[j+1].key) ++j; // j为key较大的记录的下标
  
    if (rc.key >= H.r[j].key) break;         // rc应插入在位置s上
  
     H.r[s] = H.r[j];   s = j;   

   }   

   H.r[s] = rc;  //
插入   

} // HeapAdjust   

  

void HeapSort(HeapType &H) {     

   //
对顺序表H进行堆排序。   

   int i;   

    RedType temp;   

   for (i=H.length/2; i>0; --i)  //
把H.r[1..H.length]建成大顶堆   

       HeapAdjust ( H, i, H.length );   

      for (i=H.length; i>1; --i) {   

          temp=H.r[i];   

          H.r[i]=H.r[1];   

          H.r[1]=temp;  //
将堆顶记录和当前未经排序子序列Hr[1..i]中   

                       //
最后一个记录相互交换   

          HeapAdjust(H, 1, i-1);  //
将H.r[1..i-1]
重新调整为大顶堆   

       }   

} // HeapSort   

       
四、归并排序
             1）归并排序

算法演示
              时间复杂度：平均情况—O(nlog2n)     
最坏情况—O(nlog2n)     
辅助空间：O(n)     
稳定性：稳定
复制到剪贴板折叠C
代码
void Merge (RedType SR[], RedType TR[], int i, int m, int n) {   

   //
将有序的SR[i..m]和SR[m+1..n]归并为有序的TR[i..n]   

   int j,k;   

   for (j=m+1, k=i;   i<=m && j<=n;   ++k) {      

      //
将SR中记录由小到大地并入TR   

      if LQ(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   

      while (k<=n && i<=m) TR[k++]=SR[i++];   

   if (j<=n)  //
将剩余的SR[j..n]复制到TR   

      while (k<=n &&j <=n) TR[k++]=SR[j++];   

} // Merge   

  

void MSort(RedType SR[], RedType TR1[], int s, int t) {   

   //
将SR[s..t]归并排序为TR1[s..t]。   

   int m;   

    RedType TR2[20];   

   if (s==t) TR1[t] = 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   

       
五、基数排序
             1）基数排序

算法演示
时间复杂度：平均情况—O(d(n+rd))     
最坏情况—O(d(n+rd))     
辅助空间：O(rd)     
稳定性：稳定
复制到剪贴板折叠C
代码
void Distribute(SLList &L, int i, ArrType &f, ArrType &e) {     

  //
静态链表L的r域中记录已按(keys[0],...,keys[i-1])有序，
  
  //
本算法按第i个关键字keys[i]建立RADIX个子表，
  
  //
使同一子表中记录的keys[i]相同。f[0..RADIX-1]和e[0..RADIX-1]
  
  //
分别指向各子表中第一个和最后一个记录。   

  int j, p;   

  for (j=0; j<RADIX; ++j) f[j] = 0;     //
各子表初始化为空表   

  for (p=L.r[0].next;   p;   p=L.r[p].next) {   

     j = L.r[p].keys[i]-'0';  //
将记录中第i个关键字映射到[0..RADIX-1]，   

    if (!f[j]) f[j] = p;   

    else L.r[e[j]].next = p;   

     e[j] = p;                //
将p所指的结点插入第j个子表中   

   }   

} // Distribute   

  

void Collect(SLList &L, int i, ArrType f, ArrType e) {     

  //
本算法按keys[i]自小至大地将f[0..RADIX-1]所指各子表依次链接成   

  //
一个链表，e[0..RADIX-1]为各子表的尾指针   

  int j,t;   

  for (j=0; !f[j]; j++);  //
找第一个非空子表，succ为求后继函数: ++   

   L.r[0].next = f[j];  // L.r[0].next指向第一个非空子表中第一个结点   

   t = e[j];   

  while (j<RADIX) {   

    for (j=j+1; j<RADIX && !f[j]; j++);       //
找下一个非空子表   

    if (j<RADIX) //
链接两个非空子表   

       { L.r[t].next = f[j];   t = e[j]; }   

   }   

   L.r[t].next = 0;   // t指向最后一个非空子表中的最后一个结点   

} // Collect   

  

void RadixSort(SLList &L) {     

   // L是采用静态链表表示的顺序表。   

   //
对L作基数排序，使得L成为按关键字自小到大的有序静态链表，   

   // L.r[0]为头结点。   

   int i;   

    ArrType f, e;   

   for (i=1; i<L.recnum; ++i) L.r[i-1].next = i;   

    L.r[L.recnum].next = 0;     //
将L改造为静态链表   

   for (i=0; i<L.keynum; ++i) {     

      //
按最低位优先依次对各关键字进行分配和收集   

       Distribute(L, i, f, e);    //
第i趟分配   

       Collect(L, i, f, e);       //
第i趟收集   

       print_SLList2(L, i);   

    }   

} // RadixSort