常用几种种排序方法！

一、冒泡（Bubble）排序

[csharp]  view plain copy

1. void BubbleSortArray()  
2. {  
3.       for(int i=1;i<n;i++)  
4.       {  
5.         for(int j=0;i<n-i;j++)  
6.          {  
7.               if(a[j]>a[j+1])//比较交换相邻元素  
8.                {  
9.                    int temp;  
10.                    temp=a[j]; a[j]=a[j+1]; a[j+1]=temp;  
11.                }  
12.          }  
13.       }  
14. }  

二、选择排序

 

[cpp]  view plain copy

1. void SelectSortArray()  
2. {  
3.     int min_index;  
4.     for(int i=0;i<n-1;i++)  
5.     {  
6.          min_index=i;  
7.          for(int j=i+1;j<n;j++)//每次扫描选择最小项  
8.             if(arr[j]<arr[min_index])  min_index=j;  
9.          if(min_index!=i)//找到最小项交换，即将这一项移到列表中的正确位置  
10.          {  
11.              int temp;  
12.              temp=arr[i]; arr[i]=arr[min_index]; arr[min_index]=temp;  
13. }  
14. }  
15. }  

三、插入排序

 

[cpp]  view plain copy

1. void InsertSortArray()  
2. {  
3. for(int i=1;i<n;i++)//循环从第二个数组元素开始，因为arr[0]作为最初已排序部分  
4. {  
5.     int temp=arr[i];//temp标记为未排序第一个元素  
6.     int j=i-1;  
7. while (j>=0 && arr[j]>temp)/*将temp与已排序元素从小到大比较，寻找temp应插入的位置*/  
8. {  
9.     arr[j+1]=arr[j];  
10.     j--;  
11. }  
12. arr[j+1]=temp;  
13. }  
14. }  

四、壳（Shell）排序

 

 

[cpp]  view plain copy

1. void ShellSortArray()  
2. {  
3.   for(int incr=3;incr<0;incr--)//增量递减，以增量3，2，1为例  
4. {  
5.        for(int L=0;L<(n-1)/incr;L++)//重复分成的每个子列表  
6. {  
7.    for(int i=L+incr;i<n;i+=incr)//对每个子列表应用插入排序  
8.    {  
9.       int temp=arr[i];  
10.       int j=i-incr;  
11.       while(j>=0&&arr[j]>temp)  
12.       {  
13.           arr[j+incr]=arr[j];  
14.           j-=incr;  
15. }  
16. arr[j+incr]=temp;  
17. }  
18. }  
19. }  
20. }  

五、归并排序五、归并排序

 

[cpp]  view plain copy

1. void MergeSort(int low,int high)  
2. {  
3.    if(low>=high)   return;//每个子列表中剩下一个元素时停止  
4.    else int mid=(low+high)/2;/*将列表划分成相等的两个子列表,若有奇数个元素，则在左边子列表大于右侧子列表*/  
5.    MergeSort(low,mid);//子列表进一步划分  
6.    MergeSort(mid+1,high);  
7.    int [] B=new int [high-low+1];//新建一个数组，用于存放归并的元素  
8.    for(int i=low,j=mid+1,k=low;i<=mid && j<=high;k++)/*两个子列表进行排序归并，直到两个子列表中的一个结束*/  
9.    {  
10.        if (arr[i]<=arr[j];)  
11. {  
12.     B[k]=arr[i];  
13.     I++;  
14. }  
15. else  
16.     { B[k]=arr[j]; j++; }  
17. }  
18. for(   ;j<=high;j++,k++)//如果第二个子列表中仍然有元素，则追加到新列表  
19.       B[k]=arr[j];  
20.    for(   ;i<=mid;i++,k++)//如果在第一个子列表中仍然有元素，则追加到新列表中  
21.       B[k]=arr[i];  
22.    for(int z=0;z<high-low+1;z++)//将排序的数组B的 所有元素复制到原始数组arr中  
23.       arr[z]=B[z];  
24. }  

六、快速排序

 

[cpp]  view plain copy

1. int Partition(int [] arr,int low,int high)  
2. {  
3.     int pivot=arr[low];//采用子序列的第一个元素作为枢纽元素  
4.     while (low < high)  
5.     {  
6.         //从后往前栽后半部分中寻找第一个小于枢纽元素的元素  
7.         while (low < high && arr[high] >= pivot)  
8.         {  
9.             --high;  
10.         }  
11.         //将这个比枢纽元素小的元素交换到前半部分  
12.         swap(arr[low], arr[high]);  
13.         //从前往后在前半部分中寻找第一个大于枢纽元素的元素  
14.         while (low <high &&arr [low ]<=pivot )  
15.         {  
16.             ++low ;  
17.         }  
18.         swap (arr [low ],arr [high ]);//将这个枢纽元素大的元素交换到后半部分  
19.     }  
20.     return low ;//返回枢纽元素所在的位置  
21. }  
22. void QuickSort(int [] a,int low,int high)  
23. {  
24.     if (low <high )  
25.     {  
26.         int n=Partition (a ,low ,high );  
27.         QuickSort (a ,low ,n );  
28.         QuickSort (a ,n +1,high );  
29.     }  
30. }  

七、堆排序

 

[cpp]  view plain copy

1. void HeapSort(SeqIAst R)  
2. {    //对R[1..n]进行堆排序，不妨用R[0]做暂存单元  
3.     int I;  
4.     BuildHeap(R)； //将R[1-n]建成初始堆  
5.     for(i=n;i>1；i--) //对当前无序区R[1..i]进行堆排序，共做n-1趟。  
6.     {  
7.         R[0]=R[1];  
8.         R[1]=R[i];  
9.         R[i]=R[0]; //将堆顶和堆中最后一个记录交换  
10.         Heapify(R,1,i-1);  //将R[1..i-1]重新调整为堆，仅有R[1]可能违反堆性质  
11.     }  
12. }