各种经典排序算法汇总（ 亲测调试运算通过）

这几天好好学习了一下排序算法 查看了各种书籍和网络资源 挑着简单易懂的教程好好学习了一下  基本上算是过了一遍 之后几天 对排序算法好好地总结一下 整理一下，先把要整理的算法列举一下：

1，选择排序

对于一个a[0,n]的数组，依次遍历数组，每次选出最大或最小的一个数

[cpp] view plaincopyprint?

1. void selectSort(int *a,int size) 
2. { 
3.     int min; 
4.     for(int i=0;i<size;i++) 
5.     { 
6.         min=i;      //将当前下标定义为最小值下标 
7.         for(int j=i+1;j<size;j++) 
8.             if(a[min]>a[j]) 
9.                 min=j;    // 记录当前最小下标 
10.         if(i!=min) 
11.             swap(a[i],a[min]);   // 如果i不是最小下标 则交换 
12.     } 
13.     print(a,size); 
14. } 

void selectSort(int *a,int size){int min;for(int i=0;i<size;i++){min=i;      //将当前下标定义为最小值下标for(int j=i+1;j<size;j++)if(a[min]>a[j])min=j;    // 记录当前最小下标if(i!=min)swap(a[i],a[min]);   // 如果i不是最小下标 则交换}print(a,size);}

2，冒泡排序

依次比较相邻的两个数，将小数放在前面，大数放在后面。即在第一趟：首先比较第1个和第2个数，将小数放前，大数放后。然后比较第2个数和第3个数，将小数放前，大数放后，如此继续，直至比较最后两个数，将小数放前，大数放后。至此第一趟结束，将最大的数放到了最后。在第二趟：仍从第一对数开始比较（因为可能由于第2个数和第3个数的交换，使得第1个数不再小于第2个数），将小数放前，大数放后，一直比较到倒数第二个数（倒数第一的位置上已经是最大的），第二趟结束，在倒数第二的位置上得到一个新的最大数（其实在整个数列中是第二大的数）。如此下去，重复以上过程，直至最终完成排序。

[cpp] view plaincopyprint?

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

void BubbleSort(int *a,int size){for(int i=0;i<size-1;i++)for(int j=0;j<size-1-i;j++){if(a[j]>a[j+1])swap(a[j],a[j+1]);}print(a,size);}

优化：使用标志的冒泡排序， 因为当一次遍历时 没有发生任何的交换 事实上证明数组排序已经完成 函数可以退出

[cpp] view plaincopyprint?

1. void BubbleSortWithFlag(int *a,int size) 
2. { 
3.     bool flag; 
4. for(int i=0;i<size-1;i++) 
5.     { 
6.         flag=true; 
7.     for(int j=0;j<size-1-i;j++) 
8.         { 
9.             if(a[j]>a[j+1]) 
10.             { 
11.                 swap(a[j],a[j+1]); 
12.                 flag=false; 
13.             } 
14.         } 
15.         if(flag==true) 
16.         { 
17.             print(a,size); 
18.             return; 
19.         } 
20.     } 
21. } 

void BubbleSortWithFlag(int *a,int size){bool flag;for(int i=0;i<size-1;i++){flag=true;for(int j=0;j<size-1-i;j++){if(a[j]>a[j+1]){    swap(a[j],a[j+1]);    flag=false;}}if(flag==true){print(a,size);return;}}}

鸡尾酒排序 ：冒泡排序的变形 （转）

鸡尾酒排序等于冒泡排序的轻微变形，不同的地方在于从低到高然后从高到低，而冒泡排序则仅从低到高去比较序列里的每个元素。他可以得到比冒泡排序稍微好一点的效能，原因是冒泡排序只从一个方向进行比对(由低到高)，每次循环只移动一个项目。以序列(2,3,4,5,1)为例，鸡尾酒排序只需要访问两次（升序降序各一次 ）次序列就可以完成排序，但如果使用冒泡排序则需要四次。

（1）先对数组从左到右进行冒泡排序（升序），则最大的元素去到最右端；

（2）再对数组从右到左进行冒泡排序（降序），则最小的元素去到最左端。以此类推，依次改变冒泡的方向，并不断缩小未排序元素的范围。

[cpp] view plaincopyprint?

1. void CockSort(int *a,int size) 
2. { 
3.     int low=0; 
4.     int up=size-1; 
5.     int index=0; 
6.     while(low<up) 
7.     { 
8.         for(int i=low;i<up;i++) 
9.             if(a[i]>a[i+1]) 
10.             { 
11.                 swap(a[i],a[i+1]); 
12.                 index=i; 
13.             } 
14.         up=index; 
15.         for(int i=up;i>low;i--) 
16.             if(a[i]<a[i-1]) 
17.             { 
18.                 swap(a[i],a[i-1]); 
19.                 index=i; 
20.             } 
21.          low=index; 
22.     } 
23.     print(a,size); 
24. } 

void CockSort(int *a,int size){int low=0;int up=size-1;int index=0;while(low<up){for(int i=low;i<up;i++)if(a[i]>a[i+1]){    swap(a[i],a[i+1]);index=i;}up=index;    for(int i=up;i>low;i--)if(a[i]<a[i-1]){swap(a[i],a[i-1]);index=i;}         low=index;}print(a,size);}

3，插入排序 （直接，折半，路插入，表插入）

依次取出便利每一项 将每一项temp=a[j]和其之前的数进行比较，如果发现了比自己大的数 就将其放在当前j的位置 同时j--，继续用temp和之前的数进行比较，直到没有比自己大的数时结束。

[cpp] view plaincopyprint?

1. //直接插入排序 
2. void insertSort(int *a,int size) 
3. { 
4.     if(size<2) 
5.         return; 
6.     int temp; 
7.     int j; 
8.     for(int i=1;i<size;i++) 
9.     { 
10.         temp=a[i]; 
11.         for( j=i;j>0&&temp<a[j-1];j--) 
12.         { 
13.               a[j]=a[j-1]; 
14.         } 
15.         a[j]=temp; 
16.     } 
17.     print(a,size); 
18. } 

//直接插入排序void insertSort(int *a,int size){if(size<2)return;int temp;int j;for(int i=1;i<size;i++){temp=a[i];for( j=i;j>0&&temp<a[j-1];j--){  a[j]=a[j-1];}a[j]=temp;}print(a,size);}

折半插入排序：

　折半插入排序（binary insertion sort）是对插入排序算法的一种改进，由于排序算法过程中，就是不断的依次将元素插入前面已排好序的序列中。由于前半部分为已排好序的数列，这样我们不用按顺序依次寻找插入点，可以采用折半查找的方法来加快寻找插入点的速度。

折半插入排序算法的具体操作为：在将一个新元素插入已排好序的数组的过程中，寻找插入点时，将待插入区域的首元素设置为a[low],末元素设置为a[high]，则轮比较时将待插入元素与a[m],其中m=(low+high)/2相比较,如果比参考元素小，则选择a[low]到a[m-1]为新的插入区域(即high=m-1)，否则选择a[m+1]到a[high]为新的插入区域（即low=m+1），如此直至low<=high不成立，即将此位置之后所有元素后移一位，并将新元素插入a[high+1]。

额 网上的方法 不是从数组a[1]开始 就是结果不正确 试了老半天 总算对了

[cpp] view plaincopyprint?

1. void binaryInsertSort(int *a,int size) 
2. { 
3.     int low,high,m,temp,j; 
4.     for (int i=1;i<size;++i){ 
5.        temp=a[i]; 
6.        low=0; 
7.        high=i-1; 
8.       /* if(a[i]>a[i-1])   //这句话可以稍微优化一下下速度 不影响结果
9.            continue;*/ 
10.        while (low<=high){ 
11.          m=(low+high)/2; 
12.          if (temp<=a[m]) 
13.              high=m-1;   //当程序跳出时 high指向的其实并不是 >=temp的值的位置 而是>=temp的值的左边的位置 所以.... 
14.          else   
15.              low=m+1; 
16.        } 
17.        for( j=i;j>high+1;--j)       //所以 这里的high要加一哇  
18.            a[j]=a[j-1]; 
19.        a[j]=temp; 
20.      } 
21.     print(a,size); 
22. } 

void binaryInsertSort(int *a,int size){int low,high,m,temp,j;for (int i=1;i<size;++i){       temp=a[i];   low=0;       high=i-1;  /* if(a[i]>a[i-1])   //这句话可以稍微优化一下下速度 不影响结果   continue;*/       while (low<=high){         m=(low+high)/2;         if (temp<=a[m]) high=m-1;   //当程序跳出时 high指向的其实并不是 >=temp的值的位置 而是>=temp的值的左边的位置 所以....         else   low=m+1;   }       for( j=i;j>high+1;--j)        //所以 这里的high要加一哇    a[j]=a[j-1];       a[j]=temp; }print(a,size);}

路插入 和 表插入 过几天再说.......

4，希尔排序

希尔算法思想：将整个无序序列分割成若干小的子序列分别进行插入排序。

如 一个长度为13的数组

81  94 11  96  12  35  17  95 28  58  41  75 15

先以13/2=5为gap进行比较 即对（81 35 41）（94 17 75）（11 95 15）分别进行排序  即对数组进行一次间距为5的插入排序

之后以3 和 1为间距 对数组进行插入排序

[cpp] view plaincopyprint?

1. void shellSort(int *a,int size)  // 代码取自 数据结构于问题求解（c++版） 
2. { 
3.     for(int gap=size/2;gap>0;gap=gap==2?1:static_cast<int>(gap/2.2)) // 这里计算出当前的 间距 
4.     { 
5.         for(int i=gap;i<size;i++) // 这里跟插入排序的代码一样 不过不在是每次与前一位比较 而是与前gap位进行比较 
6.         { 
7.             int  temp=a[i]; 
8.             int j; 
9.             for(j=i;j>=gap&&temp<a[j-1];j-=gap) 
10.             { 
11.                 a[j]=a[j-gap]; 
12.             } 
13.             a[j]=temp; 
14.         } 
15.     } 
16.     print(a,size); 
17. } 

void shellSort(int *a,int size)   // 代码取自 数据结构于问题求解（c++版）{for(int gap=size/2;gap>0;gap=gap==2?1:static_cast<int>(gap/2.2))  // 这里计算出当前的 间距{for(int i=gap;i<size;i++)  // 这里跟插入排序的代码一样 不过不在是每次与前一位比较 而是与前gap位进行比较{int  temp=a[i];    int j;for(j=i;j>=gap&&temp<a[j-1];j-=gap){a[j]=a[j-gap];}a[j]=temp;}}print(a,size);}

5，归并排序

归并操作(merge)，也叫归并算法，指的是将两个已经排序的序列合并成一个序列的操作。归并排序算法依赖归并操作。

归并操作的过程如下：

1. 申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列
2. 设定两个指针，最初位置分别为两个已经排序序列的起始位置
3. 比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置
4. 重复步骤3直到某一指针达到序列尾
5. 将另一序列剩下的所有元素直接复制到合并序列尾

[cpp] view plaincopyprint?

1. void mergeSort(int* a,int size,int* temp,int left,int right) 
2. { 
3.     if(left<right) 
4.     { 
5.         int mid=(left+right)/2; 
6.         mergeSort(a,size,temp,left,mid); 
7.         mergeSort(a,size,temp,mid+1,right); 
8.         merge(a,size,temp,left,mid+1,right); 
9.     } 
10. } 
11. void merge(int *a,int size,int *temp,int leftPos ,int rightPos,int rightEnd) 
12. { 
13.     int leftEnd=rightPos-1; 
14.     int tempPos=leftPos; 
15.     int num=rightEnd-leftPos+1; 
16.  
17.     while(leftPos<=leftEnd && rightPos<=rightEnd) 
18.         if(a[leftPos]<=a[rightPos]) 
19.             temp[tempPos++]=a[leftPos++]; 
20.         else 
21.             temp[tempPos++]=a[rightPos++]; 
22.     while(leftPos<=leftEnd) 
23.     { 
24.         temp[tempPos++]=a[leftPos++]; 
25.     } 
26.     while(rightPos<=rightEnd) 
27.     { 
28.         temp[tempPos++]=a[rightPos++]; 
29.     } 
30.     for(int i=0;i<num;i++,rightEnd--) 
31.     { 
32.         a[rightEnd]=temp[rightEnd]; 
33.     } 
34. } 

void mergeSort(int* a,int size,int* temp,int left,int right){if(left<right){int mid=(left+right)/2;    mergeSort(a,size,temp,left,mid);    mergeSort(a,size,temp,mid+1,right);merge(a,size,temp,left,mid+1,right);}}void merge(int *a,int size,int *temp,int leftPos ,int rightPos,int rightEnd){int leftEnd=rightPos-1;int tempPos=leftPos;int num=rightEnd-leftPos+1;while(leftPos<=leftEnd && rightPos<=rightEnd)if(a[leftPos]<=a[rightPos])temp[tempPos++]=a[leftPos++];elsetemp[tempPos++]=a[rightPos++];while(leftPos<=leftEnd){temp[tempPos++]=a[leftPos++];}while(rightPos<=rightEnd){temp[tempPos++]=a[rightPos++];}for(int i=0;i<num;i++,rightEnd--){a[rightEnd]=temp[rightEnd];}}

6，快速排序

一趟快速排序的算法是：

　1）设置两个变量I、J，排序开始的时候：I=0，J=N-1；

　2）以第一个数组元素作为关键数据，赋值给key，即 key=A[0]；

　3）从J开始向前搜索，即由后开始向前搜索（J=J-1即J--），找到第一个小于key的值A[j]，A[j]与A[i]交换；

　4）从I开始向后搜索，即由前开始向后搜索（I=I+1即I++），找到第一个大于key的A[i]，A[i]与A[j]交换；　

　5）重复第3、4、5步，直到 I=J； (3,4步是在程序中没找到时候j=j-1，i=i+1，直至找到为止。找到并交换的时候i， j指针位置不

变。另外当i=j这过程一定正好是i+或j-完成的最后另循环结束。）

[cpp] view plaincopyprint?

1. int partition(int *a,int low,int high) 
2. <//这里从两端开始 没有考虑抽取支点的过程 支点可以选取第一个 中间点 和最后一个点 选取中间大的值 交换到数组的最后面 
3. { 
4.     int pivot=a[high]; 
5.     int i,j; 
6.     for( i=low-1,j=high;;){ 
7.         while(a[++i]<pivot &&i<high){};//从前往后 找大于支点的 
8.         while(a[--j]>pivot &&j>low){}; //从前往前 找小于支点的 
9.         if(i<j){ 
10.             swap(a[i],a[j]);   //若找到 则交换 
11.         } 
12.         else 
13.             break; 
14.     } 
15.     swap(a[i],a[high]); // 将支点交换到小于与大于的分解处 
16.     return i;  
17. } 
18. void qucikSort(int*a,int low,int high) 
19. { 
20.     if(low<high) 
21.     { 
22.         int mid=partition(a,low,high);  
23.         qucikSort(a,low,mid-1);       //递归进行快排 
24.         qucikSort(a,mid+1,high); 
25.     } 
26. } 

int partition(int *a,int low,int high)<//这里从两端开始 没有考虑抽取支点的过程 支点可以选取第一个 中间点 和最后一个点 选取中间大的值 交换到数组的最后面{int pivot=a[high];int i,j;for( i=low-1,j=high;;){while(a[++i]<pivot &&i<high){}; //从前往后 找大于支点的while(a[--j]>pivot &&j>low){};  //从前往前 找小于支点的if(i<j){swap(a[i],a[j]);   //若找到 则交换}elsebreak;}swap(a[i],a[high]); // 将支点交换到小于与大于的分解处return i; }void qucikSort(int*a,int low,int high){if(low<high){int mid=partition(a,low,high); qucikSort(a,low,mid-1);       //递归进行快排qucikSort(a,mid+1,high);}}

7，堆排序 

取自算法导论

[cpp] view plaincopyprint?

1. int Left(int i)// 这里取左右和父节点 是以 顶节点index为0来考虑的 
2. { 
3.     return i*2+1; 
4. } 
5. int Right(int i) 
6. { 
7.     return i*2+2; 
8. } 
9. int Parent(int i) 
10. { 
11.     return (i-1)/2; 
12. } 
13. void max_heapify(int *a,int heapSize,int i)  
14.     // 是对最大堆进行操作的重要子程序  用于保持堆的性质 
15. { 
16.     int left=Left(i); 
17.     int right=Right(i); 
18.     int largest; 
19.     if(left<heapSize&&a[left]>a[i]) 
20.         largest=left; 
21.     else 
22.         largest=i; 
23.     if(right<heapSize&&a[right]>a[largest]) 
24.         largest=right; 
25.     if(largest!=i)   //如果该父节点不是最大 
26.     {  
27.         swap(a[i],a[largest]);  // 则将较大的子节点 与父节点交换 因为交换可能破坏之后的结构 
28.             max_heapify(a,heapSize,largest); // 故 继续对交换的那个子节点做一次最大堆操作 
29.     } 
30. } 
31. void build_max_heap(int *a,int size)  //构建最大堆     （堆的大小 小于等于 数组的大小 ）   
32. {  
33.     int heapSize=size; 
34.     for(int i=size/2-1;i>=0;i--) 
35.     { 
36.         max_heapify(a,heapSize,i); 
37.     } 
38.  
39. } 
40. void heapSort(int* a,int size) 
41. { 
42.     build_max_heap(a,size); 
43.     int heapSize=size; 
44.     for(int i=size-1;i>=1;i--) 
45.     { 
46.         swap(a[0],a[i]);   // 讲顶节点与最后一个交换 最后一个节点即存的最大值 
47.         heapSize--;    //最大堆的节点个数减一 不考虑 最后点 
48.         max_heapify(a,heapSize,0); // 交换后 重新保持最大堆的性质 
49.     } 
50. } 

int Left(int i) // 这里取左右和父节点 是以 顶节点index为0来考虑的{return i*2+1;}int Right(int i){return i*2+2;}int Parent(int i){return (i-1)/2;}void max_heapify(int *a,int heapSize,int i) // 是对最大堆进行操作的重要子程序  用于保持堆的性质{int left=Left(i);int right=Right(i);int largest;if(left<heapSize&&a[left]>a[i])largest=left;elselargest=i;if(right<heapSize&&a[right]>a[largest])largest=right;if(largest!=i)   //如果该父节点不是最大{     swap(a[i],a[largest]);  // 则将较大的子节点 与父节点交换 因为交换可能破坏之后的结构             max_heapify(a,heapSize,largest); // 故 继续对交换的那个子节点做一次最大堆操作}}void build_max_heap(int *a,int size)   //构建最大堆     （堆的大小 小于等于 数组的大小 ）  { int heapSize=size;for(int i=size/2-1;i>=0;i--){max_heapify(a,heapSize,i);}}void heapSort(int* a,int size){build_max_heap(a,size);int heapSize=size;    for(int i=size-1;i>=1;i--){swap(a[0],a[i]);   // 讲顶节点与最后一个交换 最后一个节点即存的最大值heapSize--;    //最大堆的节点个数减一 不考虑 最后点max_heapify(a,heapSize,0); // 交换后 重新保持最大堆的性质}}

8，计数排序

[cpp] view plaincopyprint?

1. void countingSort(int *a,int size,int k) 
2. { 
3.     int *c=newint[k+1]; 
4.     int *b=newint[size]; 
5.     for(int i=0;i<=k;i++) 
6.     { 
7.         c[i]=0; 
8.     } 
9.     for(int j=0;j<size;j++) 
10.     { 
11.         b[j]=0; 
12.         c[a[j]]++; 
13.     } 
14.     for(int t=1;t<k+1;t++) 
15.     { 
16.         c[t]=c[t]+c[t-1]; 
17.     } 
18.     for(int t=size-1;t>=0;t--) 
19.     {  
20.          b[c[a[t]]]=a[t]; 
21.          c[a[t]]--; 
22.     } 
23.  
24.     //int pos=0;    // 上面是算法导论的标准方法 下面的方式我觉得直观而且快一些 
25.     //for(int i=0;i<=k;i++) 
26.     //{ 
27.     //  for(int t=0;t<c[i];t++) 
28.     //      b[pos++]=i; 
29.     //   
30.     //} 
31.     print(b,size); 
32. } 

void countingSort(int *a,int size,int k){int *c=new int[k+1];int *b=new int[size];for(int i=0;i<=k;i++){c[i]=0;}for(int j=0;j<size;j++){b[j]=0;c[a[j]]++;}for(int t=1;t<k+1;t++){c[t]=c[t]+c[t-1];}for(int t=size-1;t>=0;t--){  b[c[a[t]]]=a[t]; c[a[t]]--;}//int pos=0;    // 上面是算法导论的标准方法 下面的方式我觉得直观而且快一些//for(int i=0;i<=k;i++)//{//for(int t=0;t<c[i];t++)//b[pos++]=i;////}print(b,size);}

9，桶排序

[cpp] view plaincopyprint?

1. class Node{ 
2. public: int key; 
3. public: Node* next; 
4. }; 
5.  
6. void bucketSort(int a[],int size,int bucketSize) 
7. { 
8.     //Node **bucketNode1=(Node**)malloc(bucketSize*sizeof(Node *)); 
9.     Node ** bucketTable=new Node*[bucketSize]; 
10.     for(int i=0;i<bucketSize;i++) 
11.     { 
12.         //bucketNode1[i]=(Node *)malloc(sizeof(Node)); 
13.         Node* node=new Node(); 
14.         node->key=0; 
15.         node->next=NULL; 
16.         bucketTable[i]=node; 
17.     } 
18.     for(int j=0;j<size;j++) 
19.     { 
20.         Node* node=new Node(); 
21.         node->key=a[j]; 
22.         node->next=NULL; 
23.         int index=a[j]/10; 
24.          
25.         Node *buketNode=bucketTable[index];  // 找到自己应当所在的桶 
26.         if(buketNode->key==0) 
27.         { 
28.             buketNode->next=node; 
29.             bucketTable[index]->key++; 
30.         }else{ 
31.             while(buketNode->next!=NULL && buketNode->next->key<=node->key)// 在该桶中的链表中寻找自己的位置 
32.                 buketNode=buketNode->next; 
33.             node->next=buketNode->next;                    // 链表的插入操作 
34.             buketNode->next=node; 
35.             bucketTable[index]->key++; 
36.         } 
37.         int pos=0; 
38.         for(int t=0;t<bucketSize;t++) 
39.         { 
40.             for(Node *p=bucketTable[t]->next;p!=NULL;p=p->next) 
41.             { 
42.                 a[pos++]=p->key; 
43.             } 
44.         } 
45.     } 
46. } 

class Node{public: int key;public: Node* next;};void bucketSort(int a[],int size,int bucketSize){//Node **bucketNode1=(Node**)malloc(bucketSize*sizeof(Node *));Node ** bucketTable=new Node*[bucketSize];for(int i=0;i<bucketSize;i++){//bucketNode1[i]=(Node *)malloc(sizeof(Node));Node* node=new Node();node->key=0;node->next=NULL;bucketTable[i]=node;}for(int j=0;j<size;j++){Node* node=new Node();node->key=a[j];node->next=NULL;int index=a[j]/10;Node *buketNode=bucketTable[index];  // 找到自己应当所在的桶if(buketNode->key==0){buketNode->next=node;bucketTable[index]->key++;}else{while(buketNode->next!=NULL && buketNode->next->key<=node->key) // 在该桶中的链表中寻找自己的位置buketNode=buketNode->next;node->next=buketNode->next;                    // 链表的插入操作buketNode->next=node;bucketTable[index]->key++;}int pos=0;for(int t=0;t<bucketSize;t++){for(Node *p=bucketTable[t]->next;p!=NULL;p=p->next){a[pos++]=p->key;}}}}

10，基数排序

11，位图排序

今后几天 会详细总结。。。。。