八大排序算法总结

原文：http://blog.csdn.net/yexinghai/article/details/4649923

插入排序

1.直接插入排序

原理：将数组分为无序区和有序区两个区，然后不断将无序区的第一个元素按大小顺序插入到有序区中去，最终将所有无序区元素都移动到有序区完成排序。

要点：设立哨兵，作为临时存储和判断数组边界之用。

实现：

[html]  view plain copy print ?

1. /**   
2.  * 直接插入排序   
3.  * 将一个数据插入到已经排好序的有序数据中,从而得到一个新的、个数加一的有序数据   
4.  * 算法适用于少量数据的排序，时间复杂度为O(n^2)。是稳定的排序方法。   
5.  */   
6.  private static void directInsertSort(int[] sort) {    
7.         for (int i = 1; i < sort.length; i++) {    
8.             int index = i - 1;    
9.             int temp = sort[i];    
10.             while (index >= 0 && sort[index] > temp) {    
11.                 sort[index + 1] = sort[index];    
12.                 index--;    
13.             }    
14.             sort[index + 1] = temp;    
15.         }    
16.     }    

2.希尔排序

原理：又称增量缩小排序。先将序列按增量划分为元素个数相同的若干组，使用直接插入排序法进行排序，然后不断缩小增量直至为1，最后使用直接插入排序完成排序。

要点：增量的选择以及排序最终以1为增量进行排序结束。

实现：

[html]  view plain copy print ?

1. Void shellSort(Node L[],int d)  
2. {  
3. While(d>=1)//直到增量缩小为1  
4. {  
5. Shell(L,d);  
6. d=d/2;//缩小增量  
7. }  
8. }  
9. Void Shell(Node L[],int d)  
10. {  
11. Int i,j;  
12. For(i=d+1;i<length;i++)  
13. {  
14. if(L[i]<L[i-d])  
15. {  
16. L[0]=L[i];  
17. j=i-d;  
18. While(j>0&&L[j]>L[0])  
19. {  
20. L[j+d]=L[j];//移动  
21. j=j-d;//查找  
22. }  
23. L[j+d]=L[0];  
24. }  
25. }  
26. }  

交换排序

1.冒泡排序

原理：将序列划分为无序和有序区，不断通过交换较大元素至无序区尾完成排序。

要点：设计交换判断条件，提前结束以排好序的序列循环。

实现：

[html]  view plain copy print ?

1. Void BubbleSort(Node L[])  
2. {  
3. Int i ,j;  
4. Bool ischanged;//设计跳出条件  
5. For(j=n;j<0;j--)  
6. {  
7. ischanged =false;  
8. For(i=0;i<j;i++)  
9. {  
10. If(L[i]>L[i+1])//如果发现较重元素就向后移动  
11. {  
12. Int temp=L[i];  
13. L[i]=L[i+1];  
14. L[i+1]=temp;  
15. Ischanged =true;  
16. }  
17. }  
18. If(!ischanged)//若没有移动则说明序列已经有序，直接跳出  
19. Break;  
20. }  
21. }  

2.快速排序

原理：不断寻找一个序列的中点，然后对中点左右的序列递归的进行排序，直至全部序列排序完成，使用了分治的思想。

要点：递归、分治

实现：

选择排序

1.直接选择排序

原理：将序列划分为无序和有序区，寻找无序区中的最小值和无序区的首元素交换，有序区扩大一个，循环最终完成全部排序。

要点：

实现：

[html]  view plain copy print ?

1. /**   
2.  * 选择排序   
3.  * 每一趟从待排序的数据元素中选出最小（或最大）的一个元素，   
4.  * 顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。    
5.  * 选择排序是不稳定的排序方法。   
6.  * @author liangge   
7.  *    
8.  */    
9. public class Main {    
10.     public static void main(String[] args) {    
11.         Random ran = new Random();    
12.         int[] sort = new int[10];    
13.         for (int i = 0; i < 10; i++) {    
14.             sort[i] = ran.nextInt(50);    
15.         }    
16.         System.out.print("排序前的数组为");    
17.         for (int i : sort) {    
18.             System.out.print(i + " ");    
19.         }    
20.         selectSort(sort);    
21.         System.out.println();    
22.         System.out.print("排序后的数组为");    
23.         for (int i : sort) {    
24.             System.out.print(i + " ");    
25.         }    
26.     }    
27.     /**   
28.      * 选择排序   
29.      * @param sort   
30.      */    
31.     private static void selectSort(int[] sort){    
32.         for(int i =0;i<sort.length-1;i++){    
33.             for(int j = i+1;j<sort.length;j++){    
34.                 if(sort[j]<sort[i]){    
35.                     int temp = sort[j];    
36.                     sort[j] = sort[i];    
37.                     sort[i] = temp;    
38.                 }    
39.             }    
40.         }    
41.     }    
42. }    

2.堆排序

原理：利用大根堆或小根堆思想，首先建立堆，然后将堆首与堆尾交换，堆尾之后为有序区。

要点：建堆、交换、调整堆

实现：

[html]  view plain copy print ?

1. Void HeapSort(Node L[])  
2. {  
3. BuildingHeap(L);//建堆（大根堆）  
4. For(int i=n;i>0;i--)//交换  
5. {  
6. Int temp=L[i];  
7. L[i]=L[0];  
8. L[0]=temp;  
9. Heapify(L,0,i);//调整堆  
10. }  
11. }  
12.   
13. Void BuildingHeap(Node L[])  
14. { For(i=length/2 -1;i>0;i--)  
15. Heapify(L,i,length);  
16. }  

归并排序

原理：将原序列划分为有序的两个序列，然后利用归并算法进行合并，合并之后即为有序序列。

要点：归并、分治

实现：

[html]  view plain copy print ?

1. Void MergeSort(Node L[],int m,int n)  
2. {  
3. Int k;  
4. If(m<n)  
5. {  
6. K=(m+n)/2;  
7. MergeSort(L,m,k);  
8. MergeSort(L,k+1,n);  
9. Merge(L,m,k,n);  
10. }  
11. }  

基数排序

原理：将数字按位数划分出n个关键字，每次针对一个关键字进行排序，然后针对排序后的序列进行下一个关键字的排序，循环至所有关键字都使用过则排序完成。

要点：对关键字的选取，元素分配收集。

实现：

[html]  view plain copy print ?

1. Void RadixSort(Node L[],length,maxradix)  
2. {  
3. Int m,n,k,lsp;  
4. k=1;m=1;  
5. Int temp[10][length-1];  
6. Empty(temp); //清空临时空间  
7. While(k<maxradix) //遍历所有关键字  
8. {  
9. For(int i=0;i<length;i++) //分配过程  
10. {  
11. If(L[i]<m)  
12. Temp[0][n]=L[i];  
13. Else  
14. Lsp=(L[i]/m)%10; //确定关键字  
15. Temp[lsp][n]=L[i];  
16. n++;  
17. }  
18. CollectElement(L,Temp); //收集  
19. n=0;  
20. m=m*10;  
21. k++;  
22. }  
23. }  

 二分法排序

实现：

[html]  view plain copy print ?

1. public class Main {    
2.     public static void main(String[] args) {    
3.         int[] sort = {1,2,3,4,5,6,7,8,9,10};    
4.         int mask = binarySearch(sort,6);    
5.         System.out.println(mask);    
6.             
7.     }    
8.         
9.         
10.     /**   
11.      * 二分搜索法，返回座标，不存在返回-1   
12.      * @param sort   
13.      * @return   
14.      */    
15.     private static int binarySearch(int[] sort,int data){    
16.         if(data<sort[0] || data>sort[sort.length-1]){    
17.             return -1;    
18.         }    
19.         int begin = 0;    
20.         int end = sort.length;    
21.         int mid = (begin+end)/2;    
22.         while(begin <= end){    
23.             mid = (begin+end)/2;    
24.             if(data > sort[mid]){    
25.                 begin = mid + 1;    
26.             }else if(data < sort[mid]){    
27.                 end = mid - 1;    
28.             }else{    
29.                 return mid;    
30.             }    
31.         }    
32.         return -1;    
33.             
34.     }    
35. }