java中几种常见的排序算法

java中常见的排序算法有：冒泡排序、快速排序、选择排序、插入排序、希尔排序，甚至还有基数排序、鸡尾酒排序、桶排序、鸽巢排序、归并排序等。

1.冒泡排序

冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。

[java]  view plain  copy

 

1. /**   
2.  * 冒泡排序 
3.  *      比较相邻的元素。如果第一个比第二个大，就交换他们两个。 
4.  *      对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。 
5.  *      针对所有的元素重复以上的步骤，除了最后一个。 
6.  *      持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。 
7.  * @param numbers 
8.  */  
9. public static void bubbleSort(int[] numbers) {  
10.     int temp; // 记录临时中间值  
11.     int size = numbers.length; // 数组大小  
12.     for (int i = 0; i < size - 1; i++) {  
13.         for (int j = i + 1; j < size; j++) {  
14.             if (numbers[i] < numbers[j]) { // 交换两数的位置  
15.                 temp = numbers[i];  
16.                 numbers[i] = numbers[j];  
17.                 numbers[j] = temp;  
18.             }  
19.         }  
20.     }  
21. }  

2.快速排序

快速排序使用分治法策略来把一个序列分为两个子序列。

[java]  view plain  copy

 

1. /** 
2.  * 快速排序 
3.  *      从数列中挑出一个元素，称为“基准” 
4.  *      重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。 
5.  *      在这个分割之后，该基准是它的最后位置。这个称为分割（partition）操作。 
6.  *      递归地把小于基准值元素的子数列和大于基准值元素的子数列排序。 
7.  * @param numbers 
8.  * @param start 
9.  * @param end 
10.  */  
11. public static void quickSort(int[] numbers, int start, int end) {  
12.     if (start < end) {  
13.         int base = numbers[start]; // 选定的基准值（第一个数值作为基准值）  
14.         int temp; // 记录临时中间值  
15.         int i = start, j = end;  
16.         do {  
17.             while ((numbers[i] < base) && (i < end))  
18.                 i++;  
19.             while ((numbers[j] > base) && (j > start))  
20.                 j--;  
21.             if (i <= j) {  
22.                 temp = numbers[i];  
23.                 numbers[i] = numbers[j];  
24.                 numbers[j] = temp;  
25.                 i++;  
26.                 j--;  
27.             }  
28.         } while (i <= j);  
29.         if (start < j)  
30.             quickSort(numbers, start, j);  
31.         if (end > i)  
32.             quickSort(numbers, i, end);  
33.     }  
34. }  

3.选择排序

选择排序是一种简单直观的排序方法，每次寻找序列中的最小值，然后放在最末尾的位置。

[java]  view plain  copy

 

1. /** 
2.  * 选择排序 
3.  *      在未排序序列中找到最小元素，存放到排序序列的起始位置。 
4.  *      再从剩余未排序元素中继续寻找最小元素，然后放到排序序列末尾。 
5.  *      以此类推，直到所有元素均排序完毕。 
6.  * @param numbers 
7.  */  
8. public static void selectSort(int[] numbers) {  
9.     int size = numbers.length, temp;  
10.     for (int i = 0; i < size; i++) {  
11.         int k = i;  
12.         for (int j = size - 1; j >i; j--)  {  
13.             if (numbers[j] < numbers[k])  k = j;  
14.         }  
15.         temp = numbers[i];  
16.         numbers[i] = numbers[k];  
17.         numbers[k] = temp;  
18.     }  
19. }  

4.插入排序

插入排序的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。其具体步骤参见代码及注释。

[java]  view plain  copy

 

1. /** 
2.  * 插入排序 
3.  *      从第一个元素开始，该元素可以认为已经被排序 
4.  *      取出下一个元素，在已经排序的元素序列中从后向前扫描 
5.  *      如果该元素（已排序）大于新元素，将该元素移到下一位置 
6.  *      重复步骤3，直到找到已排序的元素小于或者等于新元素的位置 
7.  *      将新元素插入到该位置中 
8.  *      重复步骤2 
9.  * @param numbers   
10.  */    
11. public static void insertSort(int[] numbers) {     
12.     int size = numbers.length, temp, j;     
13.     for(int i=1; i<size; i++) {     
14.         temp = numbers[i];     
15.         for(j = i; j > 0 && temp < numbers[j-1]; j--)     
16.             numbers[j] = numbers[j-1];     
17.         numbers[j] = temp;     
18.     }     
19. }  

5.归并排序

归并排序是建立在归并操作上的一种有效的排序算法，归并是指将两个已经排序的序列合并成一个序列的操作。

[java]  view plain  copy

 

1. /** 
2.  * 归并排序 
3.  *      申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列 
4.  *      设定两个指针，最初位置分别为两个已经排序序列的起始位置 
5.  *      比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置  
6.  *      重复步骤3直到某一指针达到序列尾 
7.  *      将另一序列剩下的所有元素直接复制到合并序列尾  
8.  * @param numbers 
9.  */  
10. public static void mergeSort(int[] numbers, int left, int right) {  
11.     int t = 1;// 每组元素个数  
12.     int size = right - left + 1;  
13.     while (t < size) {  
14.         int s = t;// 本次循环每组元素个数  
15.         t = 2 * s;  
16.         int i = left;  
17.         while (i + (t - 1) < size) {  
18.             merge(numbers, i, i + (s - 1), i + (t - 1));  
19.             i += t;  
20.         }  
21.         if (i + (s - 1) < right)  
22.             merge(numbers, i, i + (s - 1), right);  
23.     }  
24. }  
25.   
26. /**   
27.  * 归并算法实现   
28.  * @param data   
29.  * @param p   
30.  * @param q   
31.  * @param r   
32.  */  
33. private static void merge(int[] data, int p, int q, int r) {  
34.     int[] B = new int[data.length];  
35.     int s = p;  
36.     int t = q + 1;  
37.     int k = p;  
38.     while (s <= q && t <= r) {  
39.         if (data[s] <= data[t]) {  
40.             B[k] = data[s];  
41.             s++;  
42.         } else {  
43.             B[k] = data[t];  
44.             t++;  
45.         }  
46.         k++;  
47.     }  
48.     if (s == q + 1)  
49.         B[k++] = data[t++];  
50.     else  
51.         B[k++] = data[s++];  
52.     for (int i = p; i <= r; i++)  
53.         data[i] = B[i];  
54. }  

6.希尔排序

希尔排序是直接插入排序的改进，该方法又称缩小增量排序。

[java]  view plain  copy

 

1. /** 
2.  * 希尔排序 
3.  *      将整个无序列分割成若干个小的子序列后，再分别进行插入排序。 
4.  *      然后依次缩减增量再次排序，待到增量足够小时，对全体元素直接进行插入排序。 
5.  * 
6.  */  
7. public static void bubbleSort(int[] score){  
8.     /** 
9.      * 打印未排序数组元素 
10.      */  
11.     System.out.print("未排序结果：");  
12.     for(int i=0;i<score.length;i++){  
13.         System.out.print(score[i]+" ");  
14.     }  
15.     System.out.println();  
16.        
17.     /** 
18.      * 希尔排序:从大到小排序 
19.      */  
20.     for(int incre=score.length/2;incre>0;incre=incre/2){//刚开始增量为5，后来为2，最后为1.  
21.         for(int i=incre;i<score.length;i++){  
22.             int temp=score[i];  
23.             int j=0;  
24.             for(j=i;j>=incre;j=j-incre){  
25.                 if(temp>score[j-incre]){//刚开始增量为5时，score[5]和score[0]比较，若score[5]>score[0],则因temp保存score[5]的值，把score[0]赋值给score[5]，相当于交换这两个数组元素的值，最终使score[0]保持较大的值。然后score[6]和score[1]比较，依次这样。  
26.                     score[j]=score[j-incre];  
27.                 }else{  
28.                     break;  
29.                 }  
30.             }          
31.             score[j]=temp;  
32.         }  
33.     }  
34.       
35.     /** 
36.      * 打印排序后数组元素 
37.      */  
38.     System.out.print("排序后结果：");  
39.     for(int i=0;i<score.length;i++){  
40.         System.out.print(score[i]+" ");  
41.     }  
42.     System.out.println();  
43. }