八大排序算法（二）

6. 交换排序—快速排序（Quick Sort）

基本思想：

1）选择一个基准元素,通常选择第一个元素或者最后一个元素,

2）通过一趟排序讲待排序的记录分割成独立的两部分，其中一部分记录的元素值均比基准元素值小。另一部分记录的 元素值比基准值大。

3）此时基准元素在其排好序后的正确位置

4）然后分别对这两部分记录用同样的方法继续进行排序，直到整个序列有序。

快速排序的示例：

（a）一趟排序的过程：

（b）排序的全过程

算法的实现：

 递归实现：

void print(int a[], int n){      for(int j= 0; j<n; j++){          cout<<a[j] <<"  ";      }      cout<<endl;  }    void swap(int *a, int *b)  {      int tmp = *a;      *a = *b;      *b = tmp;  }    int partition(int a[], int low, int high)  {      int privotKey = a[low];                             //基准元素      while(low < high){                                   //从表的两端交替地向中间扫描          while(low < high  && a[high] >= privotKey) --high;  //从high 所指位置向前搜索，至多到low+1 位置。将比基准元素小的交换到低端          swap(&a[low], &a[high]);          while(low < high  && a[low] <= privotKey ) ++low;          swap(&a[low], &a[high]);      }      print(a,10);      return low;  }      void quickSort(int a[], int low, int high){      if(low < high){          int privotLoc = partition(a,  low,  high);  //将表一分为二          quickSort(a,  low,  privotLoc -1);          //递归对低子表递归排序          quickSort(a,   privotLoc + 1, high);        //递归对高子表递归排序      }  }    int main(){      int a[10] = {3,1,5,7,2,4,9,6,10,8};      cout<<"初始值：";      print(a,10);      quickSort(a,0,9);      cout<<"结果：";      print(a,10);    }  

分析：

快速排序是通常被认为在同数量级（O(nlog2n)）的排序方法中平均性能最好的。但若初始序列按关键码有序或基本有序时，快排序反而蜕化为冒泡排序。为改进之，通常以“三者取中法”来选取基准记录，即将排序区间的两个端点与中点三个记录关键码居中的调整为支点记录。快速排序是一个不稳定的排序方法。

 
快速排序的改进

在本改进算法中,只对长度大于k的子序列递归调用快速排序,让原序列基本有序，然后再对整个基本有序序列用插入排序算法排序。实践证明，改进后的算法时间复杂度有所降低，且当k取值为 8 左右时,改进算法的性能最佳。算法思想如下：

void print(int a[], int n){      for(int j= 0; j<n; j++){          cout<<a[j] <<"  ";      }      cout<<endl;  }    void swap(int *a, int *b)  {      int tmp = *a;      *a = *b;      *b = tmp;  }    int partition(int a[], int low, int high)  {      int privotKey = a[low];                 //基准元素      while(low < high){                   //从表的两端交替地向中间扫描          while(low < high  && a[high] >= privotKey) --high; //从high 所指位置向前搜索，至多到low+1 位置。将比基准元素小的交换到低端          swap(&a[low], &a[high]);          while(low < high  && a[low] <= privotKey ) ++low;          swap(&a[low], &a[high]);      }      print(a,10);      return low;  }      void qsort_improve(int r[ ],int low,int high, int k){      if( high -low > k ) { //长度大于k时递归, k为指定的数          int pivot = partition(r, low, high); // 调用的Partition算法保持不变          qsort_improve(r, low, pivot - 1,k);          qsort_improve(r, pivot + 1, high,k);      }   }   void quickSort(int r[], int n, int k){      qsort_improve(r,0,n,k);//先调用改进算法Qsort使之基本有序        //再用插入排序对基本有序序列排序      for(int i=1; i<=n;i ++){          int tmp = r[i];           int j=i-1;          while(tmp < r[j]){              r[j+1]=r[j]; j=j-1;           }          r[j+1] = tmp;      }     }         int main(){      int a[10] = {3,1,5,7,2,4,9,6,10,8};      cout<<"初始值：";      print(a,10);      quickSort(a,9,4);      cout<<"结果：";      print(a,10);    }  

7. 归并排序（Merge Sort）

基本思想：

归并（Merge）排序法是将两个（或两个以上）有序表合并成一个新的有序表，即把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列。

归并排序示例：

合并方法：

设r[i…n]由两个有序子表r[i…m]和r[m+1…n]组成，两个子表长度分别为n-i +1、n-m。

1. j=m+1；k=i；i=i; //置两个子表的起始下标及辅助数组的起始下标
2. 若i>m 或j>n，转⑷ //其中一个子表已合并完，比较选取结束
3. //选取r[i]和r[j]较小的存入辅助数组rf
   如果r[i]<r[j]，rf[k]=r[i]； i++； k++； 转⑵
   否则，rf[k]=r[j]； j++； k++； 转⑵
4. //将尚未处理完的子表中元素存入rf
   如果i<=m，将r[i…m]存入rf[k…n] //前一子表非空
   如果j<=n ,  将r[j…n] 存入rf[k…n] //后一子表非空
5. 合并结束。

//将r[i…m]和r[m +1 …n]归并到辅助数组rf[i…n]  void Merge(ElemType *r,ElemType *rf, int i, int m, int n)  {      int j,k;      for(j=m+1,k=i; i<=m && j <=n ; ++k){          if(r[j] < r[i]) rf[k] = r[j++];          else rf[k] = r[i++];      }      while(i <= m)  rf[k++] = r[i++];      while(j <= n)  rf[k++] = r[j++];  }  

归并的迭代算法

1 个元素的表总是有序的。所以对n 个元素的待排序列，每个元素可看成1 个有序子表。对子表两两合并生成n/2个子表，所得子表除最后一个子表长度可能为1 外，其余子表长度均为2。再进行两两合并，直到生成n 个元素按关键码有序的表。

void print(int a[], int n){      for(int j= 0; j<n; j++){          cout<<a[j] <<"  ";      }      cout<<endl;  }    //将r[i…m]和r[m +1 …n]归并到辅助数组rf[i…n]  void Merge(ElemType *r,ElemType *rf, int i, int m, int n)  {      int j,k;      for(j=m+1,k=i; i<=m && j <=n ; ++k){          if(r[j] < r[i]) rf[k] = r[j++];          else rf[k] = r[i++];      }      while(i <= m)  rf[k++] = r[i++];      while(j <= n)  rf[k++] = r[j++];      print(rf,n+1);  }    void MergeSort(ElemType *r, ElemType *rf, int lenght)  {       int len = 1;      ElemType *q = r ;      ElemType *tmp ;      while(len < lenght) {          int s = len;          len = 2 * s ;          int i = 0;          while(i+ len <lenght){              Merge(q, rf,  i, i+ s-1, i+ len-1 ); //对等长的两个子表合并              i = i+ len;          }          if(i + s < lenght){              Merge(q, rf,  i, i+ s -1, lenght -1); //对不等长的两个子表合并          }          tmp = q; q = rf; rf = tmp; //交换q,rf，以保证下一趟归并时，仍从q 归并到rf      }  }      int main(){      int a[10] = {3,1,5,7,2,4,9,6,10,8};      int b[10];      MergeSort(a, b, 10);      print(b,10);      cout<<"结果：";      print(a,10);    }  

两路归并的递归算法

void MSort(ElemType *r, ElemType *rf,int s, int t)  {       ElemType *rf2;      if(s==t) r[s] = rf[s];      else      {           int m=(s+t)/2;          /*平分*p 表*/          MSort(r, rf2, s, m);        /*递归地将p[s…m]归并为有序的p2[s…m]*/          MSort(r, rf2, m+1, t);      /*递归地将p[m+1…t]归并为有序的p2[m+1…t]*/          Merge(rf2, rf, s, m+1,t);   /*将p2[s…m]和p2[m+1…t]归并到p1[s…t]*/      }  }  void MergeSort_recursive(ElemType *r, ElemType *rf, int n)  {   /*对顺序表*p 作归并排序*/      MSort(r, rf,0, n-1);  }  

8. 桶排序/基数排序(Radix Sort)

说基数排序之前，我们先说桶排序：

基本思想：是将阵列分到有限数量的桶子里。每个桶子再个别排序（有可能再使用别的排序算法或是以递回方式继续使用桶排序进行排序）。桶排序是鸽巢排序的一种归纳结果。当要被排序的阵列内的数值是均匀分配的时候，桶排序使用线性时间（Θ（n））。但桶排序并不是 比较排序，他不受到 O(n log n) 下限的影响。
         简单来说，就是把数据分组，放在一个个的桶中，然后对每个桶里面的在进行排序。  

 例如要对大小为[1..1000]范围内的n个整数A[1..n]排序  

 首先，可以把桶设为大小为10的范围，具体而言，设集合B[1]存储[1..10]的整数，集合B[2]存储   (10..20]的整数，……集合B[i]存储(   (i-1)*10,   i*10]的整数，i   =   1,2,..100。总共有  100个桶。  

  然后，对A[1..n]从头到尾扫描一遍，把每个A[i]放入对应的桶B[j]中。  再对这100个桶中每个桶里的数字排序，这时可用冒泡，选择，乃至快排，一般来说任  何排序法都可以。

  最后，依次输出每个桶里面的数字，且每个桶中的数字从小到大输出，这  样就得到所有数字排好序的一个序列了。  

  假设有n个数字，有m个桶，如果数字是平均分布的，则每个桶里面平均有n/m个数字。如果  

  对每个桶中的数字采用快速排序，那么整个算法的复杂度是  

  O(n   +   m   *   n/m*log(n/m))   =   O(n   +   nlogn   -   nlogm)  

  从上式看出，当m接近n的时候，桶排序复杂度接近O(n)  

  当然，以上复杂度的计算是基于输入的n个数字是平均分布这个假设的。这个假设是很强的  ，实际应用中效果并没有这么好。如果所有的数字都落在同一个桶中，那就退化成一般的排序了。  

        前面说的几大排序算法 ，大部分时间复杂度都是O（n2），也有部分排序算法时间复杂度是O(nlogn)。而桶式排序却能实现O（n）的时间复杂度。但桶排序的缺点是：

        1）首先是空间复杂度比较高，需要的额外开销大。排序有两个数组的空间开销，一个存放待排序数组，一个就是所谓的桶，比如待排序值是从0到m-1，那就需要m个桶，这个桶数组就要至少m个空间。

        2）其次待排序的元素都要在一定的范围内等等。

       桶式排序是一种分配排序。分配排序的特定是不需要进行关键码的比较，但前提是要知道待排序列的一些具体情况。