详细收集汇总排序方法，力图理解透彻 （勉强归为原创：））

排序方法是在编程中较经常要用到的，但是由于对排序方法理解的不透彻 经常会出现一些写了排序但是不知道用的什么排序方法 ，或者写了一些四不像的排序方法，虽然也能达到要求，但是算法的时间复杂度令人不敢恭维 ， 到了要求排序性能， 对排序方法作出要求时 经常手足无措 ，这次把经典的常用的排序方法搜集一下， 比较其优缺点 以备理解 ， 使用 。

1 [b]快速排序 [/b]
优点：极快，数据移动少。
缺点：不稳定。

[b]基本思想[/b]

快速排序（Quicksort）是对冒泡排序的一种改进。由C. A. R. Hoare在1962年提出。它的基本思想是：[b][u]通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，[/u][/b]整个排序过程可以递归进行，以此达到整个数据变成有序序列。

[img]http://imgsrc.baidu.com/baike/pic/item/4d497006cf0533560208819b.jpg[/img]

[b]　算法过程[/b]

　设要排序的数组是A[0]……A[N-1]，首先任意选取一个数据（通常选用第一个数据）作为关键数据，然后将所有比它小的数都放到它前面，所有比它大的数都放到它后面，这个过程称为一趟快速排序。一趟快速排序的算法是：
　　1）设置两个变量I、J，排序开始的时候：I=1，J=N-1；
　　2）以第一个数组元素作为关键数据，赋值给X，即 X=A[0]；
　　3）从J开始向前搜索，即由后开始向前搜索（J=J-1），找到第一个小于X的值，让该值与X交换；
　　4）从I开始向后搜索，即由前开始向后搜索（I=I+1），找到第一个大于X的值，让该值与X交换；
　　5）重复第3、4步，直到 I=J；
　　例如：待排序的数组A的值分别是：（初始关键数据：X=49）
　　A[0] 、 A[1]、 A[2]、 A[3]、 A[4]、 A[5]、 A[6]：
　　49 38 65 97 76 13 27
　　进行第一次交换后： 27 38 65 97 76 13 49
　　( 按照算法的第三步从后面开始找)
　　进行第二次交换后： 27 38 49 97 76 13 65
　　( 按照算法的第四步从前面开始找>X的值，65>49,两者交换，此时：I=3 )
　　进行第三次交换后： 27 38 13 97 76 49 65
　　( 按照算法的第五步将又一次执行算法的第三步从后开始找
　　进行第四次交换后： 27 38 13 49 76 97 65
　　( 按照算法的第四步从前面开始找大于X的值，97>49,两者交换，此时：J=4 )
　　此时再执行第三步的时候就发现I=J，从而结束一躺快速排序，那么经过一趟快速排序之后的结果是：27 38 13 49 76 97 65，即所以大于49的数全部在49的后面，所以小于49的数全部在49的前面。
　　快速排序就是递归调用此过程——在以49为中点分割这个数据序列，分别对前面一部分和后面一部分进行类似的快速排序，从而完成全部数据序列的快速排序，最后把此数据序列变成一个有序的序列，根据这种思想对于上述数组A的快速排序的全过程如图6所示：
　　初始状态 {49 38 65 97 76 13 27}
　　进行一次快速排序之后划分为 {27 38 13} 49 {76 97 65}
　　分别对前后两部分进行快速排序 {27 38 13} 经第三步和第四步交换后变成 {13 27 38} 完成排序。
　　{76 97 65} 经第三步和第四步交换后变成 {65 76 97} 完成排序。

[b]程序实例[/b]

　public class QuickSort {
　　/**
　　* 快速排序
　　*/
　　public static void main(String[] args) {
　　Random random=new Random();
　　int[] pData=new int[10];
　　for(int i=0;i<pData.length;i++){ //随机生成10个排序数
　　Integer a =random.nextInt(100);
　　pData[i]= a;
　　System.out.print(pData[i]+" ");
　　}
　　System.out.println();
　　int left=0;
　　int right=pData.length-1;
　　Sort(pData,left,right);
　　for(int i=0;i<pData.length;i++){
　　System.out.print(pData[i]+" ");
　　}
　　System.out.println();
　　}
　　public static int[] Sort(int[] pData, int left, int right){
　　int middle,strTemp;
　　int i = left;
　　int j = right;
　　middle = pData[(left+right)/2];
　　do{
　　while((pData[i]<middle) && (i<right))
　　i++;
　　while((pData[j]>middle) && (j>left))
　　j--;
　　if(i<=j){
　　strTemp = pData[i];
　　pData[i] = pData[j];
　　pData[j] = strTemp;
　　i++;
　　j--;
　　}
　　for(int k=0;k<pData.length;k++){
　　System.out.print(pData[k]+" ");
　　}
　　System.out.println();
　　}while(i<j);//如果两边扫描的下标交错，完成一次排序
　　if(left<j)
　　Sort(pData,left,j); //递归调用
　　if(right>i)
　　Sort(pData,i,right); //递归调用
　　return pData;
　　}
　　}

2 [b]冒泡排序[/b]

基本思路：对尚未排序的各元素从头到尾依次比较相邻的两个元素是否逆序（与欲排顺序相反），若逆序就交换这两元素，经过第一轮比较排序后便可把最大（或最小）的元素排好，然后再用同样的方法把剩下的元素逐个进行比较，就得到了你所要的顺序。可以看出如果有 n 个元素，那么一共要进行 n-1 轮比较，第 i 轮要进行 j=n-i 次比较。（如：有5个元素，则要进行5-1轮比较。第3轮则要进行5-3次比较）

　#include<stdio.h>
　　void main()
　　{
　　int a[10];
　　int i,j,t;
　　printf("输入10个整数：\n");
　　for( i = 0; i < 10; i ++ )
　　scanf("%d",&a[ i ]); //依次输入10个整数
　　for( j = 0; j < 9; j ++ ) //进行9轮排序 即n－1次
　　{
　　for( i = 0; i < 9-j; i ++) //每轮进行n－1－j 次比较，最多n－1－j 次交换
　　if( a[ i ] > a[ i + 1 ] )
　　{
　　t = a[ i ] ;
　　a[ i ] = a[ i + 1 ]; //大的沉底向a[9]（依次）逼进
　　a[ i + 1 ] = t;
　　}
　　}
　　printf("排序结果:");
　　for( i = 0; i < 10; i ++ ) //依次输出排序结果
　　printf("%d\t",a[ i ]);
　　printf("\n");
　　}

3[b] 插入排序 [/b]

优点：稳定，快；
缺点：比较次数不一定，比较次数越少，插入点后的数据移动越多，特别是当数据总量庞大的时候，但用链表可以解决这个问题。

[b]基本思想[/b]

将n个元素的数列分为已有序和无序两个部分，如下所示：
　　{，{a2，a3，a4，…,an}}
　　{{a1(1)，a2(1)}，{a3(1)，a4(1) …,an(1)}}
　　…
　　{{a1(n-1)，a2(n-1) ，…}, {an(n-1)}}
　　每次处理就是将无序数列的第一个元素与有序数列的元素从后往前逐个进行比较，找出插入位置，将该元素插入到有序数列的合适位置中。

　　假定这个数组的序是排好的,然后从头往后,如果有数比当前外层元素的值大,则将这个数的位置往后挪,直到当前外层元素的值大于或等于它前面的位置为止.这具算法在排完前k个数之后,可以保证a[1…k]是局部有序的,保证了插入过程的正确性.


[b]程序实例[/b]

　void InsertSort(char array[],unsigned int n)
　　{
　　int i,j;
　　int temp;
　　for(i=1;i<n;i++)
　　{
　　temp = array;//store the original sorted array in temp
　　for(j=i ; j>0 && temp < array[j-1] ; j--)//compare the new array with temp
　　{
　　array[j]=array[j-1];//all larger elements are moved one pot to the right
　　}
　　array[j]=temp;
　　}
　　}

4 [b]归并排序 [/b]

优点：快，数据移动少；
缺点：不稳定，d的取值是多少，应取多少个不同的值，都无法确切知道，只能凭经验来取。

　归并排序是多次将两个或两个以上的有序表合并成一个新的有序表。最简单的归并是直接将两个有序的子表合并成一个有序的表。
　　在内部排序中，通常采用的是2-路归并排序。即：将两个位置相邻的记录有序子序列归并为一个记录的有序序列。
　　每一趟归并的时间复杂度为 O(n)
　　在插入排序，选择排序，快速排序，归并排序这几种排序中，要求内存量最大的是归并排序。

　#include <stdio.h>
　　#include <stdlib.h>
　　#include <iostream.h >
　　void merge(int array[], int p, int q, int r)
　　{
　　int* temp = new int [r-p+1]; //申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列
　　int m=p;
　　int n=q+1;
　　int k = 0;
　　while((m<=q)&&( n<=r)) //比较两个下标所指向的元素，选择相对小的元素放入到合并空间，并移动下标到下一位置
　　{
　　if(array[m]<array[n])
　　{
　　temp[k] = array[m];
　　m++;
　　}
　　else
　　{
　　temp[k] = array[n];
　　n++;
　　}
　　k++;
　　}
　　while(m<=q) //若第一个序列有剩余，直接拷贝出来粘到合并序列尾
　　{
　　temp[k] = array[m];
　　k++;
　　m++;
　　}
　　while(n<=r) //若第二个序列有剩余，直接拷贝出来粘到合并序列尾
　　{
　　temp[k] = array[n];
　　k++;
　　n++;
　　}
　　for (int i = 0; i < (r - p +1); i++) //将排序好的序列拷贝回数组中
　　{
　　array[p+i] = temp[i];
　　}
　　}
　　void mergesort(int A[],int p,int r)
　　{
　　if (p<r)
　　{
　　int q = (p+r)/2;
　　mergesort(A,p,q);
　　mergesort(A,q+1,r);
　　merge(A,p,q,r);
　　}
　　}
　　int main()
　　{
　　int A[9]={9,3,6,1,4,7,2,8,5};
　　mergesort(A,0,8);
　　for (int i = 0; i < 9; i++) //打印数组
　　{
　　cout<<A[i] ;
　　}
　　return 1;
　　}

5[b]选择排序法[/b]

优点：稳定，比较次数与冒泡排序一样；
缺点：相对之下还是慢。

[b]基本思想[/b]

　每一趟从待排序的数据元素中选出最小（或最大）的一个元素，顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。
　　选择排序是不稳定的排序方法。
　　n个记录的文件的直接选择排序可经过n-1趟直接选择排序得到有序结果：
　　①初始状态：无序区为R[1..n]，有序区为空。
　　②第1趟排序
　　在无序区R[1..n]中选出关键字最小的记录R[k]，将它与无序区的第1个记录R[1]交换，使R[1..1]和R[2..n]分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区。
　　……
　　③第i趟排序
　　第i趟排序开始时，当前有序区和无序区分别为R[1..i-1]和R(1≤i≤n-1)。该趟排序从当前无序区中选出关键字最小的记录 R[k]，将它与无序区的第1个记录R交换，使R[1..i]和R分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区。
　　这样，n个记录的文件的直接选择排序可经过n-1趟直接选择排序得到有序结果。

[b]排序过程[/b]

　【示例】：
　　初始关键字 [49 38 65 97 76 13 27 49]
　　第一趟排序后 13 ［38 65 97 76 49 27 49]
　　第二趟排序后 13 27 ［65 97 76 49 38 49]
　　第三趟排序后 13 27 38 [97 76 49 65 49]
　　第四趟排序后 13 27 38 49 [76 97 65 49 ]
　　第五趟排序后 13 27 38 49 49 [97 65 76]
　　第六趟排序后 13 27 38 49 49 65 [97 76]
　　第七趟排序后 13 27 38 49 49 65 76 [97]
　　最后排序结果 13 27 38 49 49 65 76 97

[b]程序实例[/b]

　void selectionSort(Type* arr,long len)
　　{
　　long i=0,j=0;/*iterator value*/
　　long maxPos;
　　assertF(arr!=NULL,"In InsertSort sort,arr is NULL\n");
　　for(i=len-1;i>=1;i--)
　　{
　　maxPos=i;
　　for(j=0;j<i;j++)
　　if(arr[maxPos]<arr[j])maxPos=j;
　　if(maxPos!=i)swapArrData(arr,maxPos,i);
　　}
　　}