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。快速排序通过一趟扫描,就能确保某个数(以它为基准点吧)的左边各数都比它小,右边各数都比它大。然后又用同样的方法处理它左右两边的数,直到基准点的左右只有一个元素为止。
下面贴代码:
- #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]);
- }