转【算法之经常使用排序算法（一）】八大经常使用内部排序算法（快排、冒泡、希尔、堆排序等）

时间  2019-12-08
标签 算法之经常使用排序算法（一） 经常 使用 内部 排序算法 冒泡 希尔 排序 栏目 应用数学 繁體版
原文   原文链接

概述

排序有内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳所有的排序记录，在排序过程当中须要访问外存。java

咱们这里说说八大排序就是内部排序。git

    

    当n较大，则应采用时间复杂度为O(nlog2n)的排序方法：快速排序、堆排序或归并排序序。算法

   快速排序：是目前基于比较的内部排序中被认为是最好的方法，当待排序的关键字是随机分布时，快速排序的平均时间最短；shell

 

总结：

 


 C语言实现：数组

1.插入排序—直接插入排序(Straight Insertion Sort)

基本思想:数据结构

将一个记录插入到已排序好的有序表中，从而获得一个新，记录数增1的有序表。即：先将序列的第1个记录当作是一个有序的子序列，而后从第2个记录逐个进行插入，直至整个序列有序为止。ide

要点：设立哨兵，做为临时存储和判断数组边界之用。函数

直接插入排序示例：性能

 

若是遇见一个和插入元素相等的，那么插入元素把想插入的元素放在相等元素的后面。因此，相等元素的先后顺序没有改变，从原无序序列出去的顺序就是排好序后的顺序，因此插入排序是稳定的。优化

算法的实现：

  1. void print(int a[], int n ,int i){  
  2.     cout<<i <<":";  
  3.     for(int j= 0; j<8; j++){  
  4.         cout<<a[j] <<" ";  
  5.     }  
  6.     cout<<endl;  
  7. }  
  8.   
  9.   
  10. void InsertSort(int a[], int n)  
  11. {  
  12.     for(int i= 1; i<n; i++){  
  13.         if(a[i] < a[i-1]){               //若第i个元素大于i-1元素，直接插入。小于的话，移动有序表后插入  
  14.             int j= i-1;   
  15.             int x = a[i];        //复制为哨兵，即存储待排序元素  
  16.             a[i] = a[i-1];           //前后移一个元素  
  17.             while(x < a[j]){  //查找在有序表的插入位置  
  18.                 a[j+1] = a[j];  
  19.                 j--;         //元素后移  
  20.             }  
  21.             a[j+1] = x;      //插入到正确位置  
  22.         }  
  23.         print(a,n,i);           //打印每趟排序的结果  
  24.     }  
  25.       
  26. }  
  27.   
  28. int main(){  
  29.     int a[8] = {3,1,5,7,2,4,9,6};  
  30.     InsertSort(a,8);  
  31.     print(a,8,8);  
  32. }  


效率：

时间复杂度：O（n^2）.

其余的插入排序有二分插入排序，2-路插入排序。

 

 2. 插入排序—希尔排序（Shell`s Sort）

希尔排序是1959 年由D.L.Shell 提出来的，相对直接排序有较大的改进。希尔排序又叫缩小增量排序

基本思想：

先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录“基本有序”时，再对全体记录进行依次直接插入排序。

操做方法：

  1. 选择一个增量序列t1，t2，…，tk，其中ti>tj，tk=1；
  2. 按增量序列个数k，对序列进行k 趟排序；
  3. 每趟排序，根据对应的增量ti，将待排序列分割成若干长度为m 的子序列，分别对各子表进行直接插入排序。仅增量因子为1 时，整个序列做为一个表来处理，表长度即为整个序列的长度。

希尔排序的示例：

 

算法实现：

 

咱们简单处理增量序列：增量序列d = {n/2 ,n/4, n/8 .....1} n为要排序数的个数

即：先将要排序的一组记录按某个增量d（n/2,n为要排序数的个数）分红若干组子序列，每组中记录的下标相差d.对每组中所有元素进行直接插入排序，而后再用一个较小的增量（d/2）对它进行分组，在每组中再进行直接插入排序。继续不断缩小增量直至为1，最后使用直接插入排序完成排序。

  1. void print(int a[], int n ,int i){  
  2.     cout<<i <<":";  
  3.     for(int j= 0; j<8; j++){  
  4.         cout<<a[j] <<" ";  
  5.     }  
  6.     cout<<endl;  
  7. }  
  8. /** 
  9.  * 直接插入排序的通常形式 
  10.  * 
  11.  * @param int dk 缩小增量，若是是直接插入排序，dk=1 
  12.  * 
  13.  */  
  14.   
  15. void ShellInsertSort(int a[], int n, int dk)  
  16. {  
  17.     for(int i= dk; i<n; ++i){  
  18.         if(a[i] < a[i-dk]){          //若第i个元素大于i-1元素，直接插入。小于的话，移动有序表后插入  
  19.             int j = i-dk;     
  20.             int x = a[i];           //复制为哨兵，即存储待排序元素  
  21.             a[i] = a[i-dk];         //首前后移一个元素  
  22.             while(x < a[j]){     //查找在有序表的插入位置  
  23.                 a[j+dk] = a[j];  
  24.                 j -= dk;             //元素后移  
  25.             }  
  26.             a[j+dk] = x;            //插入到正确位置  
  27.         }  
  28.         print(a, n,i );  
  29.     }  
  30.       
  31. }  
  32.   
  33. /** 
  34.  * 先按增量d（n/2,n为要排序数的个数进行希尔排序 
  35.  * 
  36.  */  
  37. void shellSort(int a[], int n){  
  38.   
  39.     int dk = n/2;  
  40.     while( dk >= 1  ){  
  41.         ShellInsertSort(a, n, dk);  
  42.         dk = dk/2;  
  43.     }  
  44. }  
  45. int main(){  
  46.     int a[8] = {3,1,5,7,2,4,9,6};  
  47.     //ShellInsertSort(a,8,1); //直接插入排序  
  48.     shellSort(a,8);           //希尔插入排序  
  49.     print(a,8,8);  
  50. }  

 

 

希尔排序时效分析很难，关键码的比较次数与记录移动次数依赖于增量因子序列d的选取，特定状况下能够准确估算出关键码的比较次数和记录的移动次数。目前尚未人给出选取最好的 增量因子序列的方法。增量因子序列能够有各类取法，有取奇数的，也有取质数的，但须要注意：增量因子中除1 外没有公因子，且最后一个增量因子必须为1。希尔排序方法是一个不稳定的排序方法。

 

3. 选择排序—简单选择排序（Simple Selection Sort）

基本思想：

在要排序的一组数中，选出最小（或者最大）的一个数与第1个位置的数交换；而后在剩下的数当中再找最小（或者最大）的与第2个位置的数交换，依次类推，直到第n-1个元素（倒数第二个数）和第n个元素（最后一个数）比较为止。

简单选择排序的示例：

 

操做方法：

第一趟，从n 个记录中找出关键码最小的记录与第一个记录交换；

第二趟，从第二个记录开始的n-1 个记录中再选出关键码最小的记录与第二个记录交换；

以此类推.....

第i 趟，则从第i 个记录开始的n-i+1 个记录中选出关键码最小的记录与第i 个记录交换，

直到整个序列按关键码有序。


算法实现：

  1. void print(int a[], int n ,int i){  
  2.     cout<<"第"<<i+1 <<"趟 : ";  
  3.     for(int j= 0; j<8; j++){  
  4.         cout<<a[j] <<"  ";  
  5.     }  
  6.     cout<<endl;  
  7. }  
  8. /** 
  9.  * 数组的最小值 
  10.  * 
  11.  * @return int 数组的键值 
  12.  */  
  13. int SelectMinKey(int a[], int n, int i)  
  14. {  
  15.     int k = i;  
  16.     for(int j=i+1 ;j< n; ++j) {  
  17.         if(a[k] > a[j]) k = j;  
  18.     }  
  19.     return k;  
  20. }  
  21.   
  22. /** 
  23.  * 选择排序 
  24.  * 
  25.  */  
  26. void selectSort(int a[], int n){  
  27.     int key, tmp;  
  28.     for(int i = 0; i< n; ++i) {  
  29.         key = SelectMinKey(a, n,i);           //选择最小的元素  
  30.         if(key != i){  
  31.             tmp = a[i];  a[i] = a[key]; a[key] = tmp; //最小元素与第i位置元素互换  
  32.         }  
  33.         print(a,  n , i);  
  34.     }  
  35. }  
  36. int main(){  
  37.     int a[8] = {3,1,5,7,2,4,9,6};  
  38.     cout<<"初始值：";  
  39.     for(int j= 0; j<8; j++){  
  40.         cout<<a[j] <<"  ";  
  41.     }  
  42.     cout<<endl<<endl;  
  43.     selectSort(a, 8);  
  44.     print(a,8,8);  
  45. }  

 

 简单选择排序的改进——二元选择排序

简单选择排序，每趟循环只能肯定一个元素排序后的定位。咱们能够考虑改进为每趟循环肯定两个元素（当前趟最大和最小记录）的位置,从而减小排序所需的循环次数。改进后对n个数据进行排序，最多只需进行[n/2]趟循环便可。具体实现以下：

  1. void SelectSort(int r[],int n) {  
  2.     int i ,j , min ,max, tmp;  
  3.     for (i=1 ;i <= n/2;i++) {    
  4.         // 作不超过n/2趟选择排序   
  5.         min = i; max = i ; //分别记录最大和最小关键字记录位置  
  6.         for (j= i+1; j<= n-i; j++) {  
  7.             if (r[j] > r[max]) {   
  8.                 max = j ; continue ;   
  9.             }    
  10.             if (r[j]< r[min]) {   
  11.                 min = j ;   
  12.             }     
  13.       }    
  14.       //该交换操做还可分状况讨论以提升效率  
  15.       tmp = r[i-1]; r[i-1] = r[min]; r[min] = tmp;  
  16.       tmp = r[n-i]; r[n-i] = r[max]; r[max] = tmp;   
  17.   
  18.     }   
  19. }  

 

4. 选择排序—堆排序（Heap Sort）

堆排序是一种树形选择排序，是对直接选择排序的有效改进。

基本思想：

堆的定义以下：具备n个元素的序列（k1,k2,...,kn),当且仅当知足

时称之为堆。由堆的定义能够看出，堆顶元素（即第一个元素）必为最小项（小顶堆）。
若以一维数组存储一个堆，则堆对应一棵彻底二叉树，且全部非叶结点的值均不大于(或不小于)其子女的值，根结点（堆顶元素）的值是最小(或最大)的。如：

（a）大顶堆序列：（96, 83,27,38,11,09)

  (b)  小顶堆序列：（12，36，24，85，47，30，53，91）

 

初始时把要排序的n个数的序列看做是一棵顺序存储的二叉树（一维数组存储二叉树），调整它们的存储序，使之成为一个堆，将堆顶元素输出，获得n 个元素中最小(或最大)的元素，这时堆的根节点的数最小（或者最大）。而后对前面(n-1)个元素从新调整使之成为堆，输出堆顶元素，获得n 个元素中次小(或次大)的元素。依此类推，直到只有两个节点的堆，并对它们做交换，最后获得有n个节点的有序序列。称这个过程为堆排序。

所以，实现堆排序需解决两个问题：
1. 如何将n 个待排序的数建成堆；
2. 输出堆顶元素后，怎样调整剩余n-1 个元素，使其成为一个新堆。


首先讨论第二个问题：输出堆顶元素后，对剩余n-1元素从新建成堆的调整过程。
调整小顶堆的方法：

1）设有m 个元素的堆，输出堆顶元素后，剩下m-1 个元素。将堆底元素送入堆顶（（最后一个元素与堆顶进行交换），堆被破坏，其缘由仅是根结点不知足堆的性质。

2）将根结点与左、右子树中较小元素的进行交换。

3）若与左子树交换：若是左子树堆被破坏，即左子树的根结点不知足堆的性质，则重复方法 （2）.

4）若与右子树交换，若是右子树堆被破坏，即右子树的根结点不知足堆的性质。则重复方法 （2）.

5）继续对不知足堆性质的子树进行上述交换操做，直到叶子结点，堆被建成。

称这个自根结点到叶子结点的调整过程为筛选。如图：


再讨论对n 个元素初始建堆的过程。
建堆方法：对初始序列建堆的过程，就是一个反复进行筛选的过程。

1）n 个结点的彻底二叉树，则最后一个结点是第个结点的子树。

2）筛选从第个结点为根的子树开始，该子树成为堆。

3）以后向前依次对各结点为根的子树进行筛选，使之成为堆，直到根结点。

如图建堆初始过程：无序序列：（49，38，65，97，76，13，27，49）
                              


                              

 

 算法的实现：

从算法描述来看，堆排序须要两个过程，一是创建堆，二是堆顶与堆的最后一个元素交换位置。因此堆排序有两个函数组成。一是建堆的渗透函数，二是反复调用渗透函数实现排序的函数。

  1. void print(int a[], int n){  
  2.     for(int j= 0; j<n; j++){  
  3.         cout<<a[j] <<"  ";  
  4.     }  
  5.     cout<<endl;  
  6. }  
  7.   
  8.   
  9.   
  10. /** 
  11.  * 已知H[s…m]除了H[s] 外均知足堆的定义 
  12.  * 调整H[s],使其成为大顶堆.即将对第s个结点为根的子树筛选,  
  13.  * 
  14.  * @param H是待调整的堆数组 
  15.  * @param s是待调整的数组元素的位置 
  16.  * @param length是数组的长度 
  17.  * 
  18.  */  
  19. void HeapAdjust(int H[],int s, int length)  
  20. {  
  21.     int tmp  = H[s];  
  22.     int child = 2*s+1; //左孩子结点的位置。(i+1 为当前调整结点的右孩子结点的位置)  
  23.     while (child < length) {  
  24.         if(child+1 <length && H[child]<H[child+1]) { // 若是右孩子大于左孩子(找到比当前待调整结点大的孩子结点)  
  25.             ++child ;  
  26.         }  
  27.         if(H[s]<H[child]) {  // 若是较大的子结点大于父结点  
  28.             H[s] = H[child]; // 那么把较大的子结点往上移动，替换它的父结点  
  29.             s = child;       // 从新设置s ,即待调整的下一个结点的位置  
  30.             child = 2*s+1;  
  31.         }  else {            // 若是当前待调整结点大于它的左右孩子，则不须要调整，直接退出  
  32.              break;  
  33.         }  
  34.         H[s] = tmp;         // 当前待调整的结点放到比其大的孩子结点位置上  
  35.     }  
  36.     print(H,length);  
  37. }  
  38.   
  39.   
  40. /** 
  41.  * 初始堆进行调整 
  42.  * 将H[0..length-1]建成堆 
  43.  * 调整完以后第一个元素是序列的最小的元素 
  44.  */  
  45. void BuildingHeap(int H[], int length)  
  46. {   
  47.     //最后一个有孩子的节点的位置 i=  (length -1) / 2  
  48.     for (int i = (length -1) / 2 ; i >= 0; --i)  
  49.         HeapAdjust(H,i,length);  
  50. }  
  51. /** 
  52.  * 堆排序算法 
  53.  */  
  54. void HeapSort(int H[],int length)  
  55. {  
  56.     //初始堆  
  57.     BuildingHeap(H, length);  
  58.     //从最后一个元素开始对序列进行调整  
  59.     for (int i = length - 1; i > 0; --i)  
  60.     {  
  61.         //交换堆顶元素H[0]和堆中最后一个元素  
  62.         int temp = H[i]; H[i] = H[0]; H[0] = temp;  
  63.         //每次交换堆顶元素和堆中最后一个元素以后，都要对堆进行调整  
  64.         HeapAdjust(H,0,i);  
  65.   }  
  66. }   
  67.   
  68. int main(){  
  69.     int H[10] = {3,1,5,7,2,4,9,6,10,8};  
  70.     cout<<"初始值：";  
  71.     print(H,10);  
  72.     HeapSort(H,10);  
  73.     //selectSort(a, 8);  
  74.     cout<<"结果：";  
  75.     print(H,10);  
  76.   
  77. }  



分析:

设树深度为k，。从根到叶的筛选，元素比较次数至多2(k-1)次，交换记录至多k 次。因此，在建好堆后，排序过程当中的筛选次数不超过下式： 

                                

而建堆时的比较次数不超过4n 次，所以堆排序最坏状况下，时间复杂度也为：O(nlogn )。

 

5. 交换排序—冒泡排序（Bubble Sort）

基本思想：

在要排序的一组数中，对当前还未排好序的范围内的所有数，自上而下对相邻的两个数依次进行比较和调整，让较大的数往下沉，较小的往上冒。即：每当两相邻的数比较后发现它们的排序与排序要求相反时，就将它们互换。

冒泡排序的示例：

 

算法的实现：

 

  1. void bubbleSort(int a[], int n){  
  2.     for(int i =0 ; i< n-1; ++i) {  
  3.         for(int j = 0; j < n-i-1; ++j) {  
  4.             if(a[j] > a[j+1])  
  5.             {  
  6.                 int tmp = a[j] ; a[j] = a[j+1] ;  a[j+1] = tmp;  
  7.             }  
  8.         }  
  9.     }  
  10. }  



冒泡排序算法的改进

对冒泡排序常见的改进方法是加入一标志性变量exchange，用于标志某一趟排序过程当中是否有数据交换，若是进行某一趟排序时并无进行数据交换，则说明数据已经按要求排列好，可当即结束排序，避免没必要要的比较过程。本文再提供如下两种改进算法：

1．设置一标志性变量pos,用于记录每趟排序中最后一次进行交换的位置。因为pos位置以后的记录均已交换到位,故在进行下一趟排序时只要扫描到pos位置便可。

改进后算法以下:

  1. void Bubble_1 ( int r[], int n) {  
  2.     int i= n -1;  //初始时,最后位置保持不变  
  3.     while ( i> 0) {   
  4.         int pos= 0; //每趟开始时,无记录交换  
  5.         for (int j= 0; j< i; j++)  
  6.             if (r[j]> r[j+1]) {  
  7.                 pos= j; //记录交换的位置   
  8.                 int tmp = r[j]; r[j]=r[j+1];r[j+1]=tmp;  
  9.             }   
  10.         i= pos; //为下一趟排序做准备  
  11.      }   
  12. }    

 

2．传统冒泡排序中每一趟排序操做只能找到一个最大值或最小值,咱们考虑利用在每趟排序中进行正向和反向两遍冒泡的方法一次能够获得两个最终值(最大者和最小者) , 从而使排序趟数几乎减小了一半。

改进后的算法实现为:

  1. void Bubble_2 ( int r[], int n){  
  2.     int low = 0;   
  3.     int high= n -1; //设置变量的初始值  
  4.     int tmp,j;  
  5.     while (low < high) {  
  6.         for (j= low; j< high; ++j) //正向冒泡,找到最大者  
  7.             if (r[j]> r[j+1]) {  
  8.                 tmp = r[j]; r[j]=r[j+1];r[j+1]=tmp;  
  9.             }   
  10.         --high;                 //修改high值, 前移一位  
  11.         for ( j=high; j>low; --j) //反向冒泡,找到最小者  
  12.             if (r[j]<r[j-1]) {  
  13.                 tmp = r[j]; r[j]=r[j-1];r[j-1]=tmp;  
  14.             }  
  15.         ++low;                  //修改low值,后移一位  
  16.     }   
  17. }   

 

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

基本思想：

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

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

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

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

快速排序的示例：

（a）一趟排序的过程：

（b）排序的全过程

算法的实现：

 递归实现：

  1. void print(int a[], int n){  
  2.     for(int j= 0; j<n; j++){  
  3.         cout<<a[j] <<"  ";  
  4.     }  
  5.     cout<<endl;  
  6. }  
  7.   
  8. void swap(int *a, int *b)  
  9. {  
  10.     int tmp = *a;  
  11.     *a = *b;  
  12.     *b = tmp;  
  13. }  
  14.   
  15. int partition(int a[], int low, int high)  
  16. {  
  17.     int privotKey = a[low];                             //基准元素  
  18.     while(low < high){                                   //从表的两端交替地向中间扫描  
  19.         while(low < high  && a[high] >= privotKey) --high;  //从high 所指位置向前搜索，至多到low+1 位置。将比基准元素小的交换到低端  
  20.         swap(&a[low], &a[high]);  
  21.         while(low < high  && a[low] <= privotKey ) ++low;  
  22.         swap(&a[low], &a[high]);  
  23.     }  
  24.     print(a,10);  
  25.     return low;  
  26. }  
  27.   
  28.   
  29. void quickSort(int a[], int low, int high){  
  30.     if(low < high){  
  31.         int privotLoc = partition(a,  low,  high);  //将表一分为二  
  32.         quickSort(a,  low,  privotLoc -1);          //递归对低子表递归排序  
  33.         quickSort(a,   privotLoc + 1, high);        //递归对高子表递归排序  
  34.     }  
  35. }  
  36.   
  37. int main(){  
  38.     int a[10] = {3,1,5,7,2,4,9,6,10,8};  
  39.     cout<<"初始值：";  
  40.     print(a,10);  
  41.     quickSort(a,0,9);  
  42.     cout<<"结果：";  
  43.     print(a,10);  
  44.   
  45. }  



分析：

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

 
快速排序的改进

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

  1. void print(int a[], int n){  
  2.     for(int j= 0; j<n; j++){  
  3.         cout<<a[j] <<"  ";  
  4.     }  
  5.     cout<<endl;  
  6. }  
  7.   
  8. void swap(int *a, int *b)  
  9. {  
  10.     int tmp = *a;  
  11.     *a = *b;  
  12.     *b = tmp;  
  13. }  
  14.   
  15. int partition(int a[], int low, int high)  
  16. {  
  17.     int privotKey = a[low];                 //基准元素  
  18.     while(low < high){                   //从表的两端交替地向中间扫描  
  19.         while(low < high  && a[high] >= privotKey) --high; //从high 所指位置向前搜索，至多到low+1 位置。将比基准元素小的交换到低端  
  20.         swap(&a[low], &a[high]);  
  21.         while(low < high  && a[low] <= privotKey ) ++low;  
  22.         swap(&a[low], &a[high]);  
  23.     }  
  24.     print(a,10);  
  25.     return low;  
  26. }  
  27.   
  28.   
  29. void qsort_improve(int r[ ],int low,int high, int k){  
  30.     if( high -low > k ) { //长度大于k时递归, k为指定的数  
  31.         int pivot = partition(r, low, high); // 调用的Partition算法保持不变  
  32.         qsort_improve(r, low, pivot - 1,k);  
  33.         qsort_improve(r, pivot + 1, high,k);  
  34.     }   
  35. }   
  36. void quickSort(int r[], int n, int k){  
  37.     qsort_improve(r,0,n,k);//先调用改进算法Qsort使之基本有序  
  38.   
  39.     //再用插入排序对基本有序序列排序  
  40.     for(int i=1; i<=n;i ++){  
  41.         int tmp = r[i];   
  42.         int j=i-1;  
  43.         while(tmp < r[j]){  
  44.             r[j+1]=r[j]; j=j-1;   
  45.         }  
  46.         r[j+1] = tmp;  
  47.     }   
  48.   
  49. }   
  50.   
  51.   
  52.   
  53. int main(){  
  54.     int a[10] = {3,1,5,7,2,4,9,6,10,8};  
  55.     cout<<"初始值：";  
  56.     print(a,10);  
  57.     quickSort(a,9,4);  
  58.     cout<<"结果：";  
  59.     print(a,10);  
  60.   
  61. }  

 

7. 归并排序（Merge Sort）

 

基本思想：

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

归并排序示例：

 

 

合并方法：

设r[i…n]由两个有序子表r[i…m]和r[m+1…n]组成，两个子表长度分别为n-i +一、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. 合并结束。
  1. //将r[i…m]和r[m +1 …n]归并到辅助数组rf[i…n]  
  2. void Merge(ElemType *r,ElemType *rf, int i, int m, int n)  
  3. {  
  4.     int j,k;  
  5.     for(j=m+1,k=i; i<=m && j <=n ; ++k){  
  6.         if(r[j] < r[i]) rf[k] = r[j++];  
  7.         else rf[k] = r[i++];  
  8.     }  
  9.     while(i <= m)  rf[k++] = r[i++];  
  10.     while(j <= n)  rf[k++] = r[j++];  
  11. }  
 

归并的迭代算法

 

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

  1. void print(int a[], int n){  
  2.     for(int j= 0; j<n; j++){  
  3.         cout<<a[j] <<"  ";  
  4.     }  
  5.     cout<<endl;  
  6. }  
  7.   
  8. //将r[i…m]和r[m +1 …n]归并到辅助数组rf[i…n]  
  9. void Merge(ElemType *r,ElemType *rf, int i, int m, int n)  
  10. {  
  11.     int j,k;  
  12.     for(j=m+1,k=i; i<=m && j <=n ; ++k){  
  13.         if(r[j] < r[i]) rf[k] = r[j++];  
  14.         else rf[k] = r[i++];  
  15.     }  
  16.     while(i <= m)  rf[k++] = r[i++];  
  17.     while(j <= n)  rf[k++] = r[j++];  
  18.     print(rf,n+1);  
  19. }  
  20.   
  21. void MergeSort(ElemType *r, ElemType *rf, int lenght)  
  22. {   
  23.     int len = 1;  
  24.     ElemType *q = r ;  
  25.     ElemType *tmp ;  
  26.     while(len < lenght) {  
  27.         int s = len;  
  28.         len = 2 * s ;  
  29.         int i = 0;  
  30.         while(i+ len <lenght){  
  31.             Merge(q, rf,  i, i+ s-1, i+ len-1 ); //对等长的两个子表合并  
  32.             i = i+ len;  
  33.         }  
  34.         if(i + s < lenght){  
  35.             Merge(q, rf,  i, i+ s -1, lenght -1); //对不等长的两个子表合并  
  36.         }  
  37.         tmp = q; q = rf; rf = tmp; //交换q,rf，以保证下一趟归并时，仍从q 归并到rf  
  38.     }  
  39. }  
  40.   
  41.   
  42. int main(){  
  43.     int a[10] = {3,1,5,7,2,4,9,6,10,8};  
  44.     int b[10];  
  45.     MergeSort(a, b, 10);  
  46.     print(b,10);  
  47.     cout<<"结果：";  
  48.     print(a,10);  
  49.   
  50. }  

 

两路归并的递归算法

  1. void MSort(ElemType *r, ElemType *rf,int s, int t)  
  2. {   
  3.     ElemType *rf2;  
  4.     if(s==t) r[s] = rf[s];  
  5.     else  
  6.     {   
  7.         int m=(s+t)/2;          /*平分*p 表*/  
  8.         MSort(r, rf2, s, m);        /*递归地将p[s…m]归并为有序的p2[s…m]*/  
  9.         MSort(r, rf2, m+1, t);      /*递归地将p[m+1…t]归并为有序的p2[m+1…t]*/  
  10.         Merge(rf2, rf, s, m+1,t);   /*将p2[s…m]和p2[m+1…t]归并到p1[s…t]*/  
  11.     }  
  12. }  
  13. void MergeSort_recursive(ElemType *r, ElemType *rf, int n)  
  14. {   /*对顺序表*p 做归并排序*/  
  15.     MSort(r, rf,0, n-1);  
  16. }  

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）其次待排序的元素都要在必定的范围内等等。

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

 

分配排序的基本思想：说白了就是进行屡次的桶式排序。

基数排序过程无须比较关键字，而是经过“分配”和“收集”过程来实现排序。它们的时间复杂度可达到线性阶：O(n)。

实例:

扑克牌中52 张牌，可按花色和面值分红两个字段，其大小关系为：
花色： 梅花< 方块< 红心< 黑心  
面值： 2 < 3 < 4 < 5 < 6 < 7 < 8 < 9 < 10 < J < Q < K < A

若对扑克牌按花色、面值进行升序排序，获得以下序列：


即两张牌，若花色不一样，不论面值怎样，花色低的那张牌小于花色高的，只有在同花色状况下，大小关系才由面值的大小肯定。这就是多关键码排序。

为获得排序结果，咱们讨论两种排序方法。
方法1：先对花色排序，将其分为4 个组，即梅花组、方块组、红心组、黑心组。再对每一个组分别按面值进行排序，最后，将4 个组链接起来便可。
方法2：先按13 个面值给出13 个编号组(2 号，3 号，...，A 号)，将牌按面值依次放入对应的编号组，分红13 堆。再按花色给出4 个编号组(梅花、方块、红心、黑心)，将2号组中牌取出分别放入对应花色组，再将3 号组中牌取出分别放入对应花色组，……，这样，4 个花色组中均按面值有序，而后，将4 个花色组依次链接起来便可。

设n 个元素的待排序列包含d 个关键码{k1，k2，…，kd}，则称序列对关键码{k1，k2，…，kd}有序是指：对于序列中任两个记录r[i]和r[j](1≤i≤j≤n)都知足下列有序关系：

                                                               

其中k1 称为最主位关键码，kd 称为最次位关键码     。

 

两种多关键码排序方法：

多关键码排序按照从最主位关键码到最次位关键码或从最次位到最主位关键码的顺序逐次排序，分两种方法：

最高位优先(Most Significant Digit first)法，简称MSD 法：

1）先按k1 排序分组，将序列分红若干子序列，同一组序列的记录中，关键码k1 相等。

2）再对各组按k2 排序分红子组，以后，对后面的关键码继续这样的排序分组，直到按最次位关键码kd 对各子组排序后。

3）再将各组链接起来，便获得一个有序序列。扑克牌按花色、面值排序中介绍的方法一便是MSD 法。

最低位优先(Least Significant Digit first)法，简称LSD 法：

1) 先从kd 开始排序，再对kd-1进行排序，依次重复，直到按k1排序分组分红最小的子序列后。

2) 最后将各个子序列链接起来，即可获得一个有序的序列, 扑克牌按花色、面值排序中介绍的方法二便是LSD 法。

 

基于LSD方法的链式基数排序的基本思想

　　“多关键字排序”的思想实现“单关键字排序”。对数字型或字符型的单关键字，能够看做由多个数位或多个字符构成的多关键字，此时能够采用“分配-收集”的方法进行排序，这一过程称做基数排序法，其中每一个数字或字符可能的取值个数称为基数。好比，扑克牌的花色基数为4，面值基数为13。在整理扑克牌时，既能够先按花色整理，也能够先按面值整理。按花色整理时，先按红、黑、方、花的顺序分红4摞（分配），再按此顺序再叠放在一块儿（收集），而后按面值的顺序分红13摞（分配），再按此顺序叠放在一块儿（收集），如此进行二次分配和收集便可将扑克牌排列有序。   

基数排序:

是按照低位先排序，而后收集；再按照高位排序，而后再收集；依次类推，直到最高位。有时候有些属性是有优先级顺序的，先按低优先级排序，再按高优先级排序。最后的次序就是高优先级高的在前，高优先级相同的低优先级高的在前。基数排序基于分别排序，分别收集，因此是稳定的。

算法实现：

  1. Void RadixSort(Node L[],length,maxradix)  
  2. {  
  3.    int m,n,k,lsp;  
  4.    k=1;m=1;  
  5.    int temp[10][length-1];  
  6.    Empty(temp); //清空临时空间  
  7.    while(k<maxradix) //遍历全部关键字  
  8.    {  
  9.      for(int i=0;i<length;i++) //分配过程  
  10.     {  
  11.        if(L[i]<m)  
  12.           Temp[0][n]=L[i];  
  13.        else  
  14.           Lsp=(L[i]/m)%10; //肯定关键字  
  15.        Temp[lsp][n]=L[i];  
  16.        n++;  
  17.    }  
  18.    CollectElement(L,Temp); //收集  
  19.    n=0;  
  20.    m=m*10;  
  21.   k++;  
  22.  }  
  23. }  



 

 

 

 

总结

各类排序的稳定性，时间复杂度和空间复杂度总结：

 咱们比较时间复杂度函数的状况：

 

                             时间复杂度函数O(n)的增加状况

因此对n较大的排序记录。通常的选择都是时间复杂度为O(nlog2n)的排序方法。

 

时间复杂度来讲：

(1)平方阶(O(n2))排序
　　各种简单排序:直接插入、直接选择和冒泡排序；
 (2)线性对数阶(O(nlog2n))排序
　　快速排序、堆排序和归并排序；
 (3)O(n1+§))排序,§是介于0和1之间的常数。

       希尔排序
(4)线性阶(O(n))排序
　　基数排序，此外还有桶、箱排序。

说明：

当原表有序或基本有序时，直接插入排序和冒泡排序将大大减小比较次数和移动记录的次数，时间复杂度可降至O（n）；

而快速排序则相反，当原表基本有序时，将蜕化为冒泡排序，时间复杂度提升为O（n2）；

原表是否有序，对简单选择排序、堆排序、归并排序和基数排序的时间复杂度影响不大。

 

稳定性：

排序算法的稳定性:若待排序的序列中，存在多个具备相同关键字的记录，通过排序， 这些记录的相对次序保持不变，则称该算法是稳定的；若经排序后，记录的相对 次序发生了改变，则称该算法是不稳定的。 
     稳定性的好处：排序算法若是是稳定的，那么从一个键上排序，而后再从另外一个键上排序，第一个键排序的结果能够为第二个键排序所用。基数排序就是这样，先按低位排序，逐次按高位排序，低位相同的元素其顺序再高位也相同时是不会改变的。另外，若是排序算法稳定，能够避免多余的比较；

稳定的排序算法：冒泡排序、插入排序、归并排序和基数排序

不是稳定的排序算法：选择排序、快速排序、希尔排序、堆排序

 

选择排序算法准则：

每种排序算法都各有优缺点。所以，在实用时需根据不一样状况适当选用，甚至能够将多种方法结合起来使用。

选择排序算法的依据

影响排序的因素有不少，平均时间复杂度低的算法并不必定就是最优的。相反，有时平均时间复杂度高的算法可能更适合某些特殊状况。同时，选择算法时还得考虑它的可读性，以利于软件的维护。通常而言，须要考虑的因素有如下四点：

1．待排序的记录数目n的大小；

2．记录自己数据量的大小，也就是记录中除关键字外的其余信息量的大小；

3．关键字的结构及其分布状况；

4．对排序稳定性的要求。

设待排序元素的个数为n.

1）当n较大，则应采用时间复杂度为O(nlog2n)的排序方法：快速排序、堆排序或归并排序序。

   快速排序：是目前基于比较的内部排序中被认为是最好的方法，当待排序的关键字是随机分布时，快速排序的平均时间最短；
       堆排序 ：  若是内存空间容许且要求稳定性的，

       归并排序：它有必定数量的数据移动，因此咱们可能过与插入排序组合，先得到必定长度的序列，而后再合并，在效率上将有所提升。

2）  当n较大，内存空间容许，且要求稳定性 =》归并排序

3）当n较小，可采用直接插入或直接选择排序。

    直接插入排序：当元素分布有序，直接插入排序将大大减小比较次数和移动记录的次数。

    直接选择排序 ：元素分布有序，若是不要求稳定性，选择直接选择排序

5）通常不使用或不直接使用传统的冒泡排序。

6）基数排序
它是一种稳定的排序算法，但有必定的局限性：
　　一、关键字可分解。
　　二、记录的关键字位数较少，若是密集更好
　　三、若是是数字时，最好是无符号的，不然将增长相应的映射复杂度，可先将其正负分开排序。

 Java实现：

 

第一：直接插入排序

 

1. 基本思想：在要排序的一组数中，假设前面(n-1) [n>=2] 个数已是排好顺序的，如今要把第n个数插到前面的有序数中，使得这n个数也是排好顺序的。如此反复循环，直到所有排好顺序。

2. 实例

3. 用java实现

 

[java]  view plain copy
 
 
 
  1. package com.weijiang.demo;    
  2.   
  3. public class InsertSort {    
  4.   
  5.     public InsertSort(){    
  6.         int a[]={49,38,65,97,76,13,27,49,78,34,12,64,5,4,62,99,98,54,56,17,18,23,34,15,35,25,53,51};    
  7.         int temp=0;    
  8.         for(int i=1;i<a.length;i++){    
  9.             int j=i-1;    
  10.             temp=a[i];    
  11.             for(;j>=0 && temp<a[j];j--){    
  12.                 a[j+1]=a[j];//将大于temp的值总体后移一个单位    
  13.             }    
  14.             a[j+1]=temp;    
  15.         }    
  16.   
  17.         for(int i=0;i<a.length;i++)    
  18.             System.out.println(a[i]);    
  19.     }    
  20.   
  21. }    

4. 特色：每次循环一边以后，最前面的一部分必定是有序序列，可是位置不是最终的

 

 

第二：希尔排序（最小增量排序）

1. 基本思想：算法先将要排序的一组数按某个增量d（n/2,n为要排序数的个数）分红若干组，每组中记录的下标相差d.对每组中所有元素进行直接插入排序，而后再用一个较小的增量（d/2）对它进行分组，在每组中再进行直接插入排序。当增量减到1时，进行直接插入排序后，排序完成。

2. 实例：

 

3. 用java实现

 

[java]  view plain copy
 
 
 
  1. package com.weijiang.demo;  
  2.   
  3. public class ShellSort {    
  4.     public ShellSort(){    
  5.         int a[]={1,54,6,3,78,34,12,45,56,100};    
  6.         double d1=a.length;    
  7.         int temp=0;    
  8.         while(true){    
  9.             d1= Math.ceil(d1/2);    
  10.             int d=(int) d1;    
  11.             for(int x=0;x<d;x++){    
  12.                 for(int i=x+d;i<a.length;i+=d){    
  13.                     int j=i-d;    
  14.                     temp=a[i];    
  15.                     for(;j>=0 && temp<a[j];j-=d){    
  16.                         a[j+d]=a[j];    
  17.                     }    
  18.                     a[j+d]=temp;    
  19.                 }    
  20.             }    
  21.             if(d==1)    
  22.                 break;    
  23.         }    
  24.         for(int i=0;i<a.length;i++)    
  25.             System.out.println(a[i]);    
  26.   
  27.     }    
  28.   
  29. }    

 

 

第三：简单选择排序

1. 基本思想：在要排序的一组数中，选出最小的一个数与第一个位置的数交换；而后在剩下的数当中再找最小的与第二个位置的数交换，如此循环到倒数第二数和最后一个数比较为止。

2. 实例：

 

3. 用java实现

 

[java]  view plain copy
 
 
 
  1. package com.weijiang.demo;  
  2.   
  3. public class SelectSort {    
  4.   
  5.     public SelectSort(){    
  6.         int a[]={1,54,6,3,78,34,12,45};    
  7.         int position=0;    
  8.         for(int i=0;i<a.length;i++){    
  9.             int j=i+1;    
  10.             position=i;    
  11.             int temp=a[i];    
  12.             for(;j<a.length;j++){    
  13.                 if(a[j]<temp){    
  14.                     temp=a[j];    
  15.                     position=j;    
  16.                 }    
  17.             }    
  18.             a[position]=a[i];    
  19.             a[i]=temp;    
  20.         }    
  21.         for(int i=0;i<a.length;i++)    
  22.             System.out.println(a[i]);    
  23.   
  24.     }    
  25.   
  26. }    

 

4. 特色：每次循环一边以后，最前面的一部分必定是有序的，并且这个顺序不会再改变。这个和前面的插入排序有点不同。

 

第四：堆排序

1. 基本思想：堆排序是一种树形选择排序，是对直接选择排序的有效改进。

堆的定义以下：具备n个元素的序列（h1,h2,...,hn),当且仅当知足（hi>=h2i,hi>=2i+1;大顶堆）或（hi<=h2i,hi<=2i+1;小顶堆）(i=1,2,...,n/2)时称之为堆。在这里只讨论知足前者条件的堆。由堆的定义能够看出，堆顶元素（即第一个元素）必为最大项（大顶堆）。彻底二叉树能够很直观地表示堆的结构。堆顶为根，其它为左子树、右子树。初始时把要排序的数的序列看做是一棵顺序存储的二叉树，调整它们的存储序，使之成为一个堆，这时堆的根节点的数最大。而后将根节点与堆的最后一个节点交换。而后对前面(n-1)个数从新调整使之成为堆。依此类推，直到只有两个节点的堆，并对它们做交换，最后获得有n个节点的有序序列。从算法描述来看，堆排序须要两个过程，一是创建堆，二是堆顶与堆的最后一个元素交换位置。因此堆排序有两个函数组成。一是建堆的渗透函数，二是反复调用渗透函数实现排序的函数。

2. 实例：

初始序列：46,79,56,38,40,84

建堆：

首先咱们将须要排序的序列按照自上往下，从左到右的顺序构形成一颗彻底二叉树，而后开始修改为堆

说明：对初始状态修改为堆的形式，从叶子节点开始操做，咱们将其改变成大顶堆，遵循的原则是父节点大于其左右子节点，若是不符合规则，就将其子节点和父节点进行交换操做，操做的顺序是从右向左，自下而上。固然每次操做完以后都必须遵循父节点大于其左右子节点，好比到第三个状态了，当咱们把84移到顶部以后，发现46比56小，因此还须要进行操做。同时左子树和右子树也要遵循规则。下面的图片就是最终的堆结构

那么下面就来看一下如何选择数：

交换，从堆中踢出最大数，就是根节点。

 

每次踢出根节点以后对于剩余结点再建堆，这时候咱们就将最后一个叶子节点放到根节点的位置，而后再建堆，好比，当咱们踢出最大值84的时候，咱们就将最后的一个叶子节点46放到根节点中，而后按照以前的建堆的原则重新建堆。再交换踢出最大数，以下图：

 

依次类推：最后堆中剩余的最后两个结点交换，踢出一个，排序完成。

3. 用java实现

 

[java]  view plain copy
 
 
 
  1. package com.weijiang.demo;  
  2.   
  3. import java.util.Arrays;    
  4.   
  5. public class HeapSort {    
  6.   
  7.     int a[]={49,38,65,97,76,13,27,49,78,34,12,64,5,4,62,99,98,54,56,17,18,23,34,15,35,25,53,51};    
  8.   
  9.     public HeapSort(){    
  10.         heapSort(a);    
  11.   
  12.     }    
  13.   
  14.     public  void heapSort(int[] a){    
  15.         System.out.println("开始排序");    
  16.         int arrayLength=a.length;    
  17.         //循环建堆    
  18.         for(int i=0;i<arrayLength-1;i++){    
  19.             //建堆    
  20.             buildMaxHeap(a,arrayLength-1-i);    
  21.             //交换堆顶和最后一个元素    
  22.             swap(a,0,arrayLength-1-i);    
  23.             System.out.println(Arrays.toString(a));    
  24.         }    
  25.     }    
  26.   
  27.     private  void swap(int[] data, int i, int j) {    
  28.         int tmp=data[i];    
  29.         data[i]=data[j];    
  30.         data[j]=tmp;    
  31.     }    
  32.   
  33.     //对data数组从0到lastIndex建大顶堆    
  34.     private void buildMaxHeap(int[] data, int lastIndex) {    
  35.         //从lastIndex处节点（最后一个节点）的父节点开始    
  36.         for(int i=(lastIndex-1)/2;i>=0;i--){    
  37.             //k保存正在判断的节点    
  38.             int k=i;    
  39.             //若是当前k节点的子节点存在    
  40.             while(k*2+1<=lastIndex){    
  41.                 //k节点的左子节点的索引    
  42.                 int biggerIndex=2*k+1;    
  43.                 //若是biggerIndex小于lastIndex，即biggerIndex+1表明的k节点的右子节点存在    
  44.                 if(biggerIndex<lastIndex){    
  45.                     //若果右子节点的值较大    
  46.                     if(data[biggerIndex]<data[biggerIndex+1]){    
  47.                         //biggerIndex老是记录较大子节点的索引    
  48.                         biggerIndex++;    
  49.                     }    
  50.                 }    
  51.   
  52.                 //若是k节点的值小于其较大的子节点的值    
  53.                 if(data[k]<data[biggerIndex]){    
  54.                     //交换他们    
  55.                     swap(data,k,biggerIndex);    
  56.                     //将biggerIndex赋予k，开始while循环的下一次循环，从新保证k节点的值大于其左右子节点的值    
  57.                     k=biggerIndex;    
  58.                 }else{    
  59.                     break;    
  60.                 }    
  61.   
  62.             }    
  63.   
  64.         }    
  65.   
  66.     }   
  67. }  

第五： 冒泡排序

1. 基本思想：在要排序的一组数中，对当前还未排好序的范围内的所有数，自上而下对相邻的两个数依次进行比较和调整，让较大的数往下沉，较小的往上冒。即：每当两相邻的数比较后发现它们的排序与排序要求相反时，就将它们互换。

2. 实例：

3. 用java实现

 

[java]  view plain copy
 
 
 
  1. package com.weijiang.demo;  
  2.   
  3. public class BubbleSort {    
  4.     public BubbleSort(){    
  5.         int a[]={1,54,6,3,78,34,12,45};    
  6.         int temp=0;    
  7.         for(int i=0;i<a.length;i++){    
  8.             for(int j=i+1;j<a.length;j++){    
  9.                 if(a[i]>a[j]){    
  10.                     temp=a[i];    
  11.                     a[i]=a[j];    
  12.                     a[j]=temp;    
  13.                 }    
  14.             }    
  15.         }    
  16.         for(int i=0;i<a.length;i++)    
  17.             System.out.println(a[i]);       
  18.     }    
  19.   
  20. }    

 

通过道友的提醒，发现上面的不是正宗的冒泡排序，其实上面的至关去选择排序的变种。因此更正过来：

正宗的冒泡排序：

 

[java]  view plain copy
 
 
 
  1. package com.weijiang.demo;  
  2.   
  3. public class BubbleSort {    
  4.     public BubbleSort(){    
  5.         int a[]={49,38,65,97,76,13,27,49,78,34,12,64,5,4,62,99,98,54,56,17,18,23,34,15,35,25,53,51};    
  6.         int temp=0;    
  7.         for(int i=0;i<a.length-1;i++){    
  8.             for(int j=0;j<a.length-1-i;j++){    
  9.                 if(a[j]>a[j+1]){    
  10.                     temp=a[j];    
  11.                     a[j]=a[j+1];    
  12.                     a[j+1]=temp;    
  13.                 }    
  14.             }    
  15.         }    
  16.         for(int i=0;i<a.length;i++)    
  17.             System.out.println(a[i]);       
  18.     }    
  19. }  

4. 特色：和选择排序的特色同样，每循环一边以后最前面的一部分是有序的，并且位置不会再改变了

注：上面的冒泡排序的过程咱们是能够进行一些优化操做的，能够添加一个变量来记录每次有没有交换操做，若是没有的话，说明序列已经有序了，不须要在进行比较了，代码以下：

 

[java]  view plain copy
 
 
 
  1. package com.weijiang.demo;  
  2.   
  3. public class EnhanceBubbleSort {    
  4.     public EnhanceBubbleSort(){    
  5.         int a[]={49,38,65,97,76,13,27,49,78,34,12,64,5,4,62,99,98,54,56,17,18,23,34,15,35,25,53,51};   
  6.         int temp=0;   
  7.         boolean isChange = false;//记录每次有没有交换值的状态  
  8.         for(int i=0;i<a.length-1;i++){    
  9.             isChange = false;  
  10.             for(int j=0;j<a.length-1-i;j++){    
  11.                 if(a[j]>a[j+1]){  
  12.                     isChange = true;  
  13.                     temp=a[j];    
  14.                     a[j]=a[j+1];    
  15.                     a[j+1]=temp;    
  16.                 }    
  17.             }   
  18.             //若是一趟下来以后没有交换操做，说明数组已经有序了，直接跳出循环  
  19.             if(!isChange)  
  20.                 break;  
  21.         }    
  22.         for(int i=0;i<a.length;i++)    
  23.             System.out.println(a[i]);       
  24.     }   
  25. }  

若是原始序列大部分有序了，这个效率比以前的冒泡排序效果高出不少

 

 

 

第六：快速排序

1. 基本思想：选择一个基准元素,一般选择第一个元素或者最后一个元素,经过一趟扫描，将待排序列分红两部分,一部分比基准元素小,一部分大于等于基准元素,此时基准元素在其排好序后的正确位置,而后再用一样的方法递归地排序划分的两部分。

2. 实例：

3. 用java实现

[java]  view plain copy
 
 
 
  1. package com.weijia.demo;  
  2.   
  3. public class QuickSort {    
  4.   
  5.     int a[]={49,38,65,97,76,13,27,49,78,34,12,64,5,4,62,99,98,54,56,17,18,23,34,15,35,25,53,51};    
  6.     public QuickSort(){    
  7.         quick(a);    
  8.         for(int i=0;i<a.length;i++)    
  9.             System.out.println(a[i]);    
  10.   
  11.     }    
  12.   
  13.     public int getMiddle(int[] list, int low, int high) {       
  14.         int tmp = list[low];    //数组的第一个做为中轴       
  15.         while (low < high) {       
  16.             while (low < high && list[high] >= tmp) {       
  17.                 high--;       
  18.             }       
  19.             list[low] = list[high];   //比中轴小的记录移到低端       
  20.             while (low < high && list[low] <= tmp) {       
  21.                 low++;       
  22.             }       
  23.             list[high] = list[low];   //比中轴大的记录移到高端       
  24.         }       
  25.         list[low] = tmp;              //中轴记录到尾       
  26.         return low;                   //返回中轴的位置       
  27.   
  28.     }      
  29.   
  30.     public void _quickSort(int[] list, int low, int high) {       
  31.         if (low < high) {       
  32.             int middle = getMiddle(list, low, high);  //将list数组进行一分为二       
  33.             _quickSort(list, low, middle - 1);        //对低字表进行递归排序       
  34.             _quickSort(list, middle + 1, high);       //对高字表进行递归排序       
  35.         }       
  36.     }     
  37.   
  38.     public void quick(int[] a2) {       
  39.         if (a2.length > 0) {    //查看数组是否为空       
  40.             _quickSort(a2, 0, a2.length - 1);       
  41.         }       
  42.     }     
  43.   
  44. }    

4. 特色：每一趟结束以后，中间的数的位置不会在改变了，并且每次都是以这个中间数为中心轴的话，一部分是比这个数都小的，另一部分都是比这个数都大的

 

 

 

第七：归并排序

1. 基本思想：归并（Merge）排序法是将两个（或两个以上）有序表合并成一个新的有序表，即把待排序序列分为若干个子序列，每一个子序列是有序的。而后再把有序子序列合并为总体有序序列。

2. 实例：

3. 用java实现

 

[java]  view plain copy
 
 
 
  1. package com.weijia.demo;  
  2.   
  3. import java.util.Arrays;    
  4.   
  5. public class MergingSort {    
  6.       
  7.     int a[]={49,38,65,97,76,13,27,49,78,34,12,64,5,4,62,99,98,54,56,17,18,23,34,15,35,25,53,51};    
  8.       
  9.     public  MergingSort(){    
  10.         sort(a,0,a.length-1);    
  11.         for(int i=0;i<a.length;i++)    
  12.             System.out.println(a[i]);    
  13.     }    
  14.       
  15.     public void sort(int[] data, int left, int right) {    
  16.         if(left<right){    
  17.             //找出中间索引    
  18.             int center=(left+right)/2;    
  19.             //对左边数组进行递归    
  20.             sort(data,left,center);    
  21.             //对右边数组进行递归    
  22.             sort(data,center+1,right);    
  23.             //合并    
  24.             merge(data,left,center,right);    
  25.   
  26.         }    
  27.     }    
  28.       
  29.     public void merge(int[] data, int left, int center, int right) {    
  30.         int [] tmpArr=new int[data.length];    
  31.         int mid=center+1;    
  32.         //third记录中间数组的索引    
  33.         int third=left;    
  34.         int tmp=left;    
  35.         while(left<=center&&mid<=right){    
  36.             //从两个数组中取出最小的放入中间数组    
  37.             if(data[left]<=data[mid]){    
  38.                 tmpArr[third++]=data[left++];    
  39.             }else{    
  40.                 tmpArr[third++]=data[mid++];    
  41.             }    
  42.         }    
  43.         //剩余部分依次放入中间数组    
  44.         while(mid<=right){    
  45.             tmpArr[third++]=data[mid++];    
  46.         }    
  47.         while(left<=center){    
  48.             tmpArr[third++]=data[left++];    
  49.         }    
  50.         //将中间数组中的内容复制回原数组    
  51.         while(tmp<=right){    
  52.             data[tmp]=tmpArr[tmp++];    
  53.         }    
  54.         System.out.println(Arrays.toString(data));    
  55.     }    
  56.   
  57. }    


 

第八：基数排序

1. 基本思想：将全部待比较数值（正整数）统一为一样的数位长度，数位较短的数前面补零。而后，从最低位开始，依次进行一次排序。这样从最低位排序一直到最高位排序完成之后,数列就变成一个有序序列。
2. 实例：

3. 用java实现
[java] view plain copy
 
 
 
  1. package com.weijia.demo;  
  2.   
  3. import java.util.ArrayList;    
  4. import java.util.List;    
  5.   
  6. public class RadixSort {    
  7.   
  8.     int a[]={49,38,65,97,76,13,27,49,78,34,12,64,5,4,62,99,98,54,101,56,17,18,23,34,15,35,25,53,51};   
  9.       
  10.     public RadixSort(){    
  11.         sort(a);    
  12.         for(int i=0;i<a.length;i++)    
  13.             System.out.println(a[i]);    
  14.     }    
  15.   
  16.     public  void sort(int[] array){       
  17.         //首先肯定排序的趟数;       
  18.         int max=array[0];       
  19.         for(int i=1;i<array.length;i++){       
  20.             if(array[i]>max){       
  21.                 max=array[i];       
  22.             }       
  23.         }       
  24.   
  25.         int time=0;       
  26.         //判断位数;       
  27.         while(max>0){       
  28.             max/=10;       
  29.             time++;       
  30.         }       
  31.   
  32.         //创建10个队列;       
  33.         List<ArrayList> queue=new ArrayList<ArrayList>();       
  34.         for(int i=0;i<10;i++){       
  35.             ArrayList<Integer> queue1=new ArrayList<Integer>();     
  36.             queue.add(queue1);       
  37.         }       
  38.   
  39.         //进行time次分配和收集;       
  40.         for(int i=0;i<time;i++){       
  41.             //分配数组元素;       
  42.             for(int j=0;j<array.length;j++){       
  43.                 //获得数字的第time+1位数;     
  44.                 int x=array[j]%(int)Math.pow(10, i+1)/(int)Math.pow(10, i);    
  45.                 ArrayList<Integer> queue2=queue.get(x);    
  46.                 queue2.add(array[j]);    
  47.                 queue.set(x, queue2);    
  48.             }       
  49.             int count=0;//元素计数器;       
  50.             //收集队列元素;       
  51.             for(int k=0;k<10;k++){     
  52.                 while(queue.get(k).size()>0){    
  53.                     ArrayList<Integer> queue3=queue.get(k);    
  54.                     array[count]=queue3.get(0);       
  55.                     queue3.remove(0);    
  56.                     count++;    
  57.                 }       
  58.             }       
  59.         }       
  60.     }      
  61.   
  62. }   

 


注明：转载请提示出处：http://blog.csdn.net/hguisu/article/details/7776068

总结：

 

 

来源：http://blog.csdn.net/cangchen/article/details/44816905

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程