常用排序算法比较

1.稳定性比较

 插入排序、冒泡排序、二叉树排序、二路归并排序及其他线形排序是稳定的

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

2.时间复杂性比较

 插入排序、冒泡排序、选择排序的时间复杂性为O(n2)

 其它非线形排序的时间复杂性为O(nlog2n)

 线形排序的时间复杂性为O(n);

3.辅助空间的比较

 线形排序、二路归并排序的辅助空间为O(n),其它排序的辅助空间为O(1);

4.其它比较

插入、冒泡排序的速度较慢，但参加排序的序列局部或整体有序时，这种排序能达到较快的速度。

反而在这种情况下，快速排序反而慢了。

当n较小时，对稳定性不作要求时宜用选择排序，对稳定性有要求时宜用插入或冒泡排序。

若待排序的记录的关键字在一个明显有限范围内时,且空间允许是用桶排序。

当n较大时，关键字元素比较随机，对稳定性没要求宜用快速排序。

当n较大时，关键字元素可能出现本身是有序的，对稳定性有要求时，空间允许的情况下。

宜用归并排序。

当n较大时，关键字元素可能出现本身是有序的，对稳定性没有要求时宜用堆排序。

5、算法思想简述：

（1）冒泡排序：在要排序的一组数中，对当前还未排好序的范围内的全部数，自上而下对相邻的两个数依次进行比较和调整，让较大的数往下沉，较小的往上冒。即：每当两相邻的数比较后发现它们的排序与排序要求相反时，就将它们互换。冒泡排序是稳定的。算法时间复杂度O(n2)。

（2）选择排序：在要排序的一组数中，选出最小的一个数与第一个位置的数交换，然后在剩下的数当中再找最小的与第二个位置的数交换，如此循环到倒数第二个数和最后一个数比较为止。选择排序是不稳定的。算法复杂度O(n2)。

（3）插入排序：在要排序的一组数中，假设前面(n-1) [n>=2] 个数已经是排 好顺序的，现在要把第n个数插到前面的有序数中，使得这n个数也是排好顺序的。如此反复循环，直到全部排好顺序。直接插入排序是稳定的。算法时间复杂度O(n2)。

（4）希尔排序：算法先将要排序的一组数按某个增量d分成若干组，每组中记录的下标相差d.对每组中全部元素进行排序，然后再用一个较小的增量对它进行，在每组中再进行排序。当增量减到1时，整个要排序的数被分成一组，排序完成。希尔排序是不稳定的。

（5）快速排序：快速排序是对冒泡排序的一种本质改进。它的基本思想是通过一趟扫描后，使得排序序列的长度能大幅度地减少。在冒泡排序中，一次扫描只能确保最大数值的数移到正确位置，而待排序序列的长度可能只减少1。快速排序通过一趟扫描，就能确保某个数（以它为基准点吧）的左边各数都比它小，右边各数都比它大。然后又用同样的方法处理它左右两边的数，直到基准点的左右只有一个元素为止。

下面贴代码：

// sort_study.cpp : Defines the entry point for the console application. // #include "stdafx.h" #include <stdio.h> int data1[]={25, 18, 12 ,10, 2 }; int data2[]={34,32,20,16,6}; int data3[10]; int data[10]={75,23,98,44,57,12,29,64,38,82}; void bubleSort(int data[] , int size); void select_sort(int data[] , int size); void insertion_sort(int data[] , int size); void merge_sort(int data1[],int size1,int data2[],int size2,int data3[]); void quick_sort(int data[] ,int left ,int right,int size); void deleteMax(int data[] , int size); void percolateDown(int data[],int target ,int size); void buildMaxHeap(int data[] , int size); void heapSort(int data[], int size); void shell_Sort(int data[],int size); void shell_Sort(int data[],int size); int main(int argc, char* argv[]) { // bubleSort(data ,5); // select_sort(data ,5); // insertion_sort(data,5); // merge_sort(data1,5,data2,5,data3); // quick_sort( data1 ,0 ,4,5); // heapSort(data1,5); // shell_Sort(data,11); return 0; } //冒泡排序 void bubleSort(int data[] , int size) { int i,j,k; int temp; int flag=0; printf("buble Sorting Proceddure/n"); for (i=0;i<size-1;i++) { flag =0; for (j=0;j<size-i-1;j++) { if (data[j] > data[j+1]) { flag = 1; temp = data[j]; data[j] = data[j+1]; data[j+1] = temp; } } printf("Sorting %d times: ",i+1); for(k=0;k<size;k++) printf("%d ",data[k]); printf("/n"); if(!flag)break; } printf("_______________________________/n"); } //选择排序 void select_sort(int data[] , int size) { int i,j,k; int temp,pos; printf("Select Sorting Proceddure/n"); for (i=0;i<size-1;i++) { pos = i; for(j=i+1;j<size;j++) { if(data[j] < data[pos]) pos = j; } temp =data[i]; data[i] = data[pos]; data[pos] = temp; printf("Sorting %d times: ",i+1); for(k=0;k<size;k++) printf("%d ",data[k]); printf("/n"); } printf("_______________________________/n"); } //插入排序 void insertion_sort(int data[] , int size) { int i,k; int temp,pos; printf("Insertion Sorting Proceddure/n"); for (i=1;i<size;i++) { temp = data[i]; pos = i; while (pos>0 && data[pos-1]>temp) { data[pos] = data[pos-1]; pos--; } data[pos] = temp; printf("Sorting %d times: ",i); for(k=0;k<size;k++) printf("%d ",data[k]); printf("/n"); } printf("_______________________________/n"); } //归并排序 void merge_sort(int data1[],int size1,int data2[],int size2,int data3[]) { int arg1=0,arg2=0; int arg3,i; printf("Merge Sorting Proceddure/n"); select_sort(data1,size1); select_sort(data2,size2); for(arg3=0;arg3<size1+size2&&arg1<size1&&arg2<size2;arg3++) { if (data1[arg1]<data2[arg2]) { data3[arg3] = data1[arg1]; arg1++; } else if (data1[arg1]>data2[arg2]) { data3[arg3]= data2[arg2]; arg2++; } else { data3[arg3] = data1[arg1]; arg1++; arg2++; } } while (arg1<size1) { data3[arg3++]=data1[arg1++]; } while (arg2<size2) { data3[arg3++]=data2[arg2++]; } printf("Merge sort: "); for (i=0;i<size1+size2;i++) printf("%d ",data3[i]); printf("/n"); printf("___________________________________________________________/n"); } //快速排序 void quick_sort(int data[] ,int left ,int right,int size) { int lbase,rbase,temp,i; lbase = left+1; rbase = right; if(left<right) { lbase = left+1; rbase = right; while (data[lbase] < data[left]) lbase++; while(data[rbase]>data[left]) rbase--; while (lbase<rbase) { temp = data[lbase]; data[lbase] = data[rbase]; data[rbase] = temp; lbase++; rbase--; while (data[lbase] < data[left]) lbase++; while(data[rbase]>data[left]) rbase--; } temp = data[left]; data[left] = data[rbase]; data[rbase] = temp; for (i=0;i<size;i++) printf("%d ",data[i]); printf("/n"); quick_sort(data,left,rbase-1,size); quick_sort(data,rbase+1,right,size); } } /**********************堆排序begin*************************/ //改造大根堆 void buildMaxHeap(int data[] , int size) { int i; for (i=size/2-1;i>=0;i--) { percolateDown(data,i,size); } } //删除最大值 void deleteMax(int data[] , int size) { int tmp; tmp = data[0]; data[0] =data[size-1]; data[size-1] = tmp; percolateDown(data, 0, --size); } //下滤 void percolateDown(int data[],int target ,int size) { int child=0; int temp=data[target]; for (; (target*2+1)<=(size-1); target=child) { child = target*2 + 1; if (child<size-1 && (data[child+1] > data[child])) child++; if (data[child]>temp) data[target] = data[child]; else break; } data[target] = temp; } void heapSort(int data[], int size) { int j; buildMaxHeap(data, size); for (int i=size; i>=1; i--) { deleteMax(data, i); for (j=0;j<size;j++) printf("%d ",data[j]); printf("/n"); } } //希尔排序 void shell_Sort(int data[],int size) { int step,i,j,temp,k; step=size/2; while (step>0) { for (i=step+1;i<size;i++) { j=i-step; while (j>0) { if (data[j] > data[j+step]) { temp = data[j]; data[j] = data[j+step]; data[j+step] = temp; j-=step; } else j=0; } } for (k=0;k<size;k++) printf("%d ",data[k]); printf("/n"); step/=2; } printf("sorting result : "); for (k=0;k<size;k++) printf("%d ",data[k]); }