各种排序之间的比较和实现

 hi，有强迫症麽？是不是每次看见乱七八糟的数字，都慌慌慌的~ 嘿嘿，介绍几个排序给你认识，从此让你过上整齐哒幸福生活~

 每个人都有优缺点，辣么，排序当然也有啦，先放个镇家之宝（自我感觉蛮漂亮的，O(∩_∩)O）~~~

下来，轮到每个排序的自我介绍啦~

一、插入排序法

开场白：我的特点呢，就是插插插，当然必须找合适的位置插入咯。

花样展示：啊呜~默认从小到大排序哦~~

代码实现：

#include<iostream>using namespace std;void Insertsort(int *arr,int len){if(arr == NULL || len<=0)   //判断参数是否合理{return;}for(int i=1;i<len;++i) //关键词从第二个数据开始{int j = i-1;int tmp = arr[i]; //一定要记得保存成临时变量，因为挪动数据很可能把它盖住。while(tmp < arr[j] && j>=0) //如果比关键字大，就往后找，直到找到比它小的{arr[j+1] = arr[j];--j;}arr[j+1] = tmp; //把关键字插入到合适的位置}}int main(){int num = 0;cin>>num; //输入数组长度int *array = new int[num];for(int i=0;i<num;++i){cin>>array[i]; //输入数组内容}Insertsort(array,num); //调用排序函数for(int i=0;i<num;++i){cout<<array[i]<<" "; //输出数组内容}cout<<endl;delete[] array;return 0;}

 总结：不难看出，我关键字的左边都是有序的，最好的情况呢，就是按序排着呢，走走走，不用换的，最坏呢，就是

倒序，走一部，挪n步的。所以呢，我最大的优点就是排有序的快啊，而且，我老老实实一个一个比较，当然稳定啦，哈哈~~~

二、希尔排序

开场白：我的特点就是分组咯，组内进行排序，然后减少组数。

花样展示：啊呜~默认从小到大排序哦~~

代码展示：

#include<iostream>#include<math.h>using namespace std;void shell(int *arr,int len,int gap) //gap 组数{if(arr == NULL || len<=0 ||gap<0)   //判断参数是否合理{return;}int j = 0;for(int i=gap;i<len;++i) //从第gap个元素往后排{int tmp = arr[i];for(j=i-gap;j>=0;j-=gap){if(arr[j] > tmp) //如果前面的组内有大于它的，就往后走，保证了组内关键字之前有序{arr[j+gap] = arr[j];}else{break;}}arr[j+gap] = tmp;}}void shellsort(int *arr,int len) {if(arr == NULL || len<=0)   //判断参数是否合理{return;}int num = (int)sqrt(len) +1;//这个可以按照自己的想法写，想分几组分几组，我是觉得这样合理一些。int *gap = new int[num]; cout<<"the number is: "<<num<<endl;cout<<"please input gaps: "<<endl;for(int i=0;i<num;++i)  //输入分组情况{cin>>gap[i];}for(int i=0;i<num;++i)  //分别调用子函数{shell(arr,len,gap[i]);}}int main(){int num = 0;cin>>num; //输入数组长度int *array = new int[num];for(int i=0;i<num;++i){cin>>array[i]; //输入数组内容}shellsort(array,num); //调用排序函数for(int i=0;i<num;++i){cout<<array[i]<<" "; //输出数组内容}cout<<endl;delete[] array;return 0;}

总结：希尔排序比插入排序多了一个分组过程，组内的排序方式和插入是一样的，插入法排序在有序的情况下快嘛，所以它就利用这个特性进一步优化，使得数组越来越逼近于有序，从而达到时间复杂度较为小一点，所以，他也可以称为是插入法排序的“哥”，但是呢，它不稳定，因为组内排序，有可能相同的数据并没有分在一个组里，所以整体看起来数据就在飞。

三、冒泡排序

开场白：咿呀呀，吐呀吐呀吐泡泡，两两比较，轻的往上走，重的往下沉~

花样展示：

代码展示：

#include<iostream>using namespace std;void Bubblesort(int *arr,int len){if(arr == NULL || len<=0)   //判断参数是否合理{return;}for(int i=len-1;i>0;--i) {for(int j=0;j<i;++j){if(arr[j] > arr[j+1]){int tmp = arr[j];arr[j] = arr[j+1];arr[j+1] = tmp;}}}}int main(){int num = 0;cin>>num; //输入数组长度int *array = new int[num];for(int i=0;i<num;++i){cin>>array[i]; //输入数组内容}Bubblesort(array,num); //调用排序函数for(int i=0;i<num;++i){cout<<array[i]<<" "; //输出数组内容}cout<<endl;delete[] array;return 0;}

总结：冒泡最大的优点就是思路简单，代码简单，但是如果它有序的话，可以遍历一次就结束，当然，你得加一个计数器，保证它这一遍的遍历没有任何交换数据的现象出现~

四、快速排序

开场白：我叫快速排序，那么我快呀~找个基准，小于我的往前走，大于我的往后走，找准位置，插入进去，然后换个基准，重复过程，直到走完~

花样展示：

代码展示：

#include<iostream>#include<math.h>using namespace std;int Partion(int *arr,int low,int high)//一次划分过程{     if(arr == NULL || low>=high || low<0 || high<0)           return -1;     int tmp = arr[low];     while(low < high)     {           while((arr[high]>=tmp) && (low<high))//因为high在变，所以第二个条件不能省略           {                high --;           }           if(low == high) //判断是否结束循环                break;           else                arr[low] = arr[high]; //小值往前           while((arr[low]<=tmp) && (low<high))//因为low在变，所以第二个条件不能省略           {                low ++;           }           if(low == high)//判断是否结束循环                break;           else                arr[high] = arr[low];//大值往后     }     arr[low] = tmp; //关键词入位     return low;}/////////////递归////////////////////void Quick(int *arr,int low,int high){     int par = Partion(arr,low,high); //调用一次划分函数     if(par != -1)     {           if(low<par-1) //至少有两个元素           {                Quick(arr,low,par-1);//左边继续调用划分函数           }           if(par<high)  //至少有两个元素           {                Quick(arr,par+1,high);//右边继续调用划分函数           }     }}void QuickSort(int *arr,int len) //马甲函数，方便调用{     if(arr == NULL || len <= 0)           return;     Quick(arr,0,len-1);}int main(){int num = 0;cin>>num; //输入数组长度int *array = new int[num];for(int i=0;i<num;++i){cin>>array[i]; //输入数组内容}QuickSort(array,num); //调用排序函数for(int i=0;i<num;++i){cout<<array[i]<<" "; //输出数组内容}cout<<endl;delete[] array;return 0;}

总结：这个方法呢，时间复杂度是比较小的，但是它的缺点一个是需要辅助空间，因为有递归啊，所以空间复杂度就是log2n。

五、选择排序

 开场白：原则就是挑最小的一直往前走， 挑待排序中最小的与第一个交换。

 花样展示：

代码展示：

#include<iostream>#include<math.h>using namespace std;void ChooseSort(int *arr,int len)//选择排序{if(arr == NULL || len <= 0)//参数判断{return;}for(int i=0;i<len-1;++i){int tmp = arr[i]; //用一个临时变量保存当前最小值int pos = -1;    //当前最小值所对应的下标int j = i + 1;   //待排序中，找最小的值以及它的下标for(;j<len;++j){if(tmp > arr[j]){tmp = arr[j];pos = j;}}if(pos != -1)//证明待排序中有比第一个数据小的值{arr[pos] = arr[i]; //把第一个数据放在最小值处}arr[i] = tmp; //把最小值挪到第一个位置}}int main(){int num = 0;cin>>num; //输入数组长度int *array = new int[num];for(int i=0;i<num;++i){cin>>array[i]; //输入数组内容}ChooseSort(array,num); //调用排序函数for(int i=0;i<num;++i){cout<<array[i]<<" "; //输出数组内容}cout<<endl;delete[] array;return 0;}

总结：感觉跟冒泡有点相似，不同的是冒泡两两比较，顺序不对就交换，而选择排序一直是找最小的与第一个交换，

六、归并排序

开场白：哥两好呀，二路并呀，二路并完四路并，四路并完八路并，越并越整齐呀~

花样展示：

代码展示：

#include<iostream>using namespace std;void Merge(int *arr,int len,int gap)//一次归并过程，gap是组的元素个数，假设二路每组一个元素，四路每组两个元素{if(arr==NULL || len<=0 || gap <1){return;}int low1 = 0;//不管几路归并，都是从头开始的；int high1 = low1 + gap - 1;//n个元素应该走n-1步int low2 = low1 + gap;int high2 = low2+gap< len ? low2 + gap -1:len-1;//有可能凑不够，一定要注意不可以越界int *brr = new int[len];//申请一个临时数组，保存归并后的新数组int index = 0;//表示brr的下标值//只要low2小于len，则证明有两个组可以进行归并while(low2 < len){//组内都有元素剩余while(low1<=high1 && low2<=high2){if (arr[low2] < arr[low1]){brr[index++] = arr[low2++];}else{brr[index++] = arr[low1++];}}//第一组有剩余while(low1 <= high1){brr[index++] = arr[low1 ++];}//第二组有剩余while(low2 <= high2){brr[index++] = arr[low2 ++];}//更新组low1 = high2+1;high1 = low1+gap-1;low2 = high1+1;high2 = low2+gap<len ? low2+gap-1 : len-1;}//归并段不成对,则只有一个组，直接挪动数据即可while(low1 < len){brr[index++] = arr[low1++];}//把临时数组的值赋值给旧数组for(int i=0;i<len;i++){arr[i] = brr[i];}delete[] brr;}void MergeSort(int *arr,int len){if(arr==NULL || len<=0) //参数检查{return;}for(int i=1;i<len;i*=2){Merge(arr,len,i);}}int main(){int num = 0;cin>>num; //输入数组长度int *array = new int[num];for(int i=0;i<num;++i){cin>>array[i]; //输入数组内容}MergeSort(array,num); //调用排序函数for(int i=0;i<num;++i){cout<<array[i]<<" "; //输出数组内容}cout<<endl;delete[] array;return 0;}

总结：归并的思想很重要哟，在某些问题上，可以考虑考虑这种分治思想，过程中一定要注意下标，千万不要越界。不管他很有序还是很无序，该干哈的还是在干哈，所以说他的最好最坏和平均时间复杂度都是一样的，因为他是按序慢慢排的，也不牵扯数据的飞来飞去，所以他还是稳定的~

七、堆排序

 开场白：大根堆，小根堆，调整一次找到一个~

花样展示：

代码展示：

#include<iostream>#include<assert.h>using namespace std;void HeapAdjust(int *arr,int start,int end) //调整函数{//O(logn),O(1),int tmp = arr[start]; int parent = start;for(int i=2*parent+1;i<=end;i=2*i+1){if((i+1<=end) && (arr[i]<arr[i+1])){++i;}//i一定是左右孩子较大值的下标if(tmp < arr[i]){arr[parent] = arr[i];parent = i;}else{//arr[parent] = tmp;//return ;break;}}arr[parent] = tmp;}void HeapSort(int *arr,int len)//O(nlogn),O(1),不稳定{//第一个建大根堆int i;int tmp;for(i=(len-1-1)/2;i>=0;i--)//O(nlogn){HeapAdjust(arr,i,len-1);}for(i=0;i<len-1;i++)//O(nlogn){tmp = arr[0];arr[0] = arr[len-1-i];arr[len-1-i] = tmp;HeapAdjust(arr,0,len-i-1-1);//已经有序的数据不参与调整}}int main(){int num = 0;cin>>num; //输入数组长度int *array = new int[num];for(int i=0;i<num;++i){cin>>array[i]; //输入数组内容}HeapSort(array,num); //调用排序函数for(int i=0;i<num;++i){cout<<array[i]<<" "; //输出数组内容}cout<<endl;delete[] array;return 0;}

总结：堆函数就是建好一个大根堆，以后就容易多啦，它特别适合去找一个最大的呀，前十个最大的呀，这种问题。

大大大大大总结：每个排序都各有千秋，根据题目的要求选择最适合的算法才是最重要哒，么么哒~~~ 整理不易~~~~给自己一个么么么么么哒~~~~~~