排序算法终结总结<Java实现>

1. /** 
2.  * 排序算法学习之希尔排序 
3.  * 实现方法： 
4.  * 希尔排序是特殊的插入排序 
5.  * 插入排序按照处理的子数组长度递增分为多趟插入操作 
6.  * 而每一趟插入操作处理的子数组元素索引间隔都是1（即步长） 
7.  * 希尔排序每趟处理的子数组元素索引间隔是动态的。 
8.  */  
9. package 排序算法.shellSort;  
10.   
11. public class ShellSort {  
12.     /** 
13.      * 对输入数组进行希尔排序 
14.      * @param a 待排序数组，索引有效范围从0开始 
15.      */  
16.     @SuppressWarnings({ "rawtypes", "unchecked" })  
17.     public static void shellSort(Comparable[] a) {  
18.         int incr = a.length / 2;//初始步长  
19.         while (incr >= 1) {  
20.             for (int i = incr; i < a.length; i++) {  
21.                 Comparable insertElement = a[i];  
22.                 int j;  
23.                 for (j = i - incr; j >= 0 &&        
24.                                      insertElement.compareTo(a[j]) < 0; j -= incr)  
25.                     a[j + incr] = a[j];  
26.                 a[j + incr] = insertElement;  
27.             }  
28.             if (incr == 2)  
29.                 incr = 1;   
30.             else  
31.                 incr = (int) (incr / 2.2);  
32.         }  
33.     }  
34. }  

 

[java]  view plain copy

1. /** 
2.  * 排序算法学习之选择排序 
3.  * 实现方法： 
4.  * 每次选择子数组中最大的元素依次排列在子数组末尾， 
5.  * 子数组的长度依次递减。 
6.  */  
7. package 排序算法.selectionSort;  
8.   
9. public class SelectionSort {  
10.     @SuppressWarnings({ "rawtypes", "unchecked" })  
11.     /** 
12.      * 查找指定长度的数组中最大元素的索引 
13.      * @param a 指定数组 
14.      * @param n 数组长度 
15.      * @return 最大元素的索引 
16.      */  
17.     public static int max(Comparable[] a, int n) {  
18.         if (n < 0)  
19.             throw new IllegalArgumentException("数组为空");  
20.         int positionOfCurrentMax = 0;  
21.         for (int i = 1; i <= n; i++)  
22.             if (a[positionOfCurrentMax].compareTo(a[i]) < 0)  
23.                 positionOfCurrentMax = i;  
24.         return positionOfCurrentMax;  
25.     }  
26.   
27.     /** 
28.      * 交换指定数组中指定索引的元素 
29.      * @param a 指定数组 
30.      * @param i 第一个索引 
31.      * @param j 第二个索引 
32.      */  
33.     public static void swap(Object[] a, int i, int j) {  
34.         Object temp = a[i];  
35.         a[i] = a[j];  
36.         a[j] = temp;  
37.     }  
38.   
39.     /** 
40.      * 对输入数组执行一般选择排序 
41.      * @param a 输入数组 
42.      */  
43.     @SuppressWarnings("rawtypes")  
44.     public void selectionSort(Comparable[] a) {  
45.         //按照子数组长度递减的顺序进行每趟的选择操作  
46.         for (int size = a.length; size > 1; size--) {  
47.             int j = max(a, size - 1);  
48.             swap(a, j, size - 1);  
49.         }  
50.     }  
51.   
52.     /** 
53.      * 对输入数组执行早结束版本的选择排序 
54.      * @param a 输入数组,数组索引有效范围从0开始 
55.      */  
56.     @SuppressWarnings({ "rawtypes", "unchecked" })  
57.     public  void selectionSort2(Comparable[] a) {  
58.         boolean sorted = false;//当前子数组是否有序的标志  
59.         for (int size = a.length; !sorted && (size > 1); size--) {  
60.             int pos = 0;  
61.             sorted = true;  
62.             for (int i = 1; i < size; i++)  
63.                 if (a[pos].compareTo(a[i]) <= 0)  
64.                     pos = i;  
65.                 else  
66.                     sorted = false;  
67.             swap(a, pos, size - 1);  
68.         }  
69.     }  
70.   
71. }  

 

[java]  view plain copy

1. /** 
2.  * 秩排序实现2 
3.  * @author Sking 
4.  */  
5. package 排序算法.rankSort;  
6.   
7. public class RankSort2 {  
8.     /** 
9.      * 对指定数组执行秩排序 
10.      * @param a 待排序数组 
11.      */  
12.     @SuppressWarnings("rawtypes")  
13.     private  void rankSort2(Comparable[] a) {  
14.         int[] r = new int[a.length];  
15.         rank(a, r);//求数组元素的秩  
16.         rearrange(a, r);//移动元素到索引为其秩的位置  
17.     }  
18.     /** 
19.      * 交换指定数组中的两个元素 
20.      * @param a 指定数组 
21.      * @param i 第一个元素的索引值 
22.      * @param j 第二个元素的索引值 
23.      */  
24.       @SuppressWarnings("rawtypes")  
25.     private static void swap(Comparable[] a, int i, int j)  
26.        {  
27.           Comparable temp = a[i];  
28.           a[i] = a[j];  
29.           a[j] = temp;  
30.        }  
31.         
32.         /** 
33.          * 交换秩数组中的两个元素 
34.          * @param a 指定的秩数组 
35.          * @param i 第一个元素的索引值 
36.          * @param j 第二个元素的索引值 
37.          */  
38.       private static void swap(int[] a, int i, int j)//重载交换方法  
39.        {  
40.           int temp = a[i];  
41.           a[i] = a[j];  
42.           a[j] = temp;  
43.        }  
44.         
45.      /** 
46.       * 根据秩数组对待排序数组进行排序 
47.       * @param a 待排序数组 
48.       * @param r 待排序数组的秩数组 
49.       */  
50.     @SuppressWarnings("rawtypes")  
51.     private static void rearrange(Comparable[] a, int[] r) {  
52.         for (int i = 0; i < a.length; i++)  
53.             //依次检查位置i，如果有i=r[i]则表示元素i位置正确  
54.             //否则交换位置i和位置r[i]上的元素（r[i]指出索引i位置  
55.             //上的元素在排序数组中药位于r[i]的位置。  
56.             while (r[i] != i) {  
57.                 int t = r[i];  
58.                 swap(a, i, t);  
59.                 swap(r, i, t);  
60.             }  
61.     }  
62.     /** 
63.      * 求指定数组元素的秩，存放在给定数组中 
64.      * @param a 待排序数组 
65.      * @param r 给定的存放元素秩的数组 
66.      */  
67.     @SuppressWarnings({ "rawtypes", "unchecked" })  
68.     private static void rank(Comparable[] a, int[] r) {  
69.         if (r.length < a.length)  
70.             throw new IllegalArgumentException("秩数组长度异常!");  
71.         for (int i = 0; i < a.length; i++)  
72.             r[i] = 0;  
73.         for (int i = 1; i < a.length; i++)  
74.             for (int j = 0; j < i; j++)  
75.                 //当左边的元素小于等于右边的元素时，右边元素的秩加1  
76.                 if (a[j].compareTo(a[i]) <= 0)  
77.                     r[i]++;  
78.                 else  
79.                 //当左边的元素不小于右边的元素时，左边的元素的秩加1  
80.                     r[j]++;  
81.     }  
82.       
83. }  

 

[java]  view plain copy

1. /** 
2.  * 排序算法学习之秩排序 
3.  *@author Sking 
4.  秩的定义： 一个序列中元素的秩被定义为序列中小于该元素的的元素 
5.   个数加上出现在其左边的相等元素的个数。则可知一个元素在排序序列 
6.   中的位置索引就是它们的秩。 
7.    
8.  实现方法： 
9.  1.计算待排序数组元素的秩 
10.  2.将数组元素移动到索引值为他们的秩的位置   
11.  */  
12.   
13. package 排序算法.rankSort;  
14.   
15. public class RankSort1 {  
16.     /** 
17.      * 对指定数组执行秩排序 
18.      * @param a 待排序的数组 
19.      */  
20.     @SuppressWarnings("rawtypes")  
21.     public  void rankSort(Comparable[] a) {  
22.         int[] r = new int[a.length];  
23.         rank(a, r);//求待排序数组元素的秩  
24.         rearrange(a, r);//移动元素到索引为他们秩的位置，实现排序  
25.     }  
26.       
27.     /** 
28.      * 使用数组元素的秩数组对数组进行排序 
29.      * @param a 待排序数组 
30.      * @param r 待排序数组元素的秩数组 
31.      */  
32.     @SuppressWarnings("rawtypes")  
33.     private static void rearrange(Comparable[] a, int[] r) {  
34.         Comparable[] u = new Comparable[a.length];  
35.         for (int i = 0; i < a.length; i++)  
36.             //移动元素到索引为他们秩的位置，实现排序  
37.             u[r[i]] = a[i];  
38.         for (int i = 0; i < a.length; i++)  
39.             a[i] = u[i];  
40.     }  
41.       
42.     /** 
43.      * 求指定数组元素的秩，存放在给定数组中 
44.      * @param a 待排序数组 
45.      * @param r 给定的存放元素秩的数组 
46.      */  
47.     @SuppressWarnings({ "rawtypes", "unchecked" })  
48.     private static void rank(Comparable[] a, int[] r) {  
49.         if (r.length < a.length)  
50.             throw new IllegalArgumentException("秩数组长度异常!");  
51.         for (int i = 0; i < a.length; i++)  
52.             r[i] = 0;  
53.         for (int i = 1; i < a.length; i++)  
54.             for (int j = 0; j < i; j++)  
55.                 //当左边的元素小于等于右边的元素时，右边元素的秩加1  
56.                 if (a[j].compareTo(a[i]) <= 0)  
57.                     r[i]++;  
58.                 else  
59.               //当左边的元素不小于右边的元素时，左边的元素的秩加1  
60.                     r[j]++;  
61.     }  
62.       
63.   
64. }  

 

[java]  view plain copy

1. /** 
2.  * 排序算法学习之快速排序的非递归实现，使用辅助栈 
3.  * @author Sking 
4.  */  
5. package 排序算法.quickSort;  
6.   
7. import 栈.ArrayStack;  
8. public class QuickSort2 {  
9.     /** 
10.      * 使用子数组的首个元素作为枢纽，划分子数组 划分后， 
11.      * 枢纽左边的元素均小于枢纽，右边的元素均大于枢纽  
12.      * 并返回划分的位置索引，是快速排序的核心方法 
13.      *  
14.      * @param a 待排序数组 
15.      * @param p 子数组的开始索引 
16.      * @param r 子数组的结束索引 
17.      * @return 划分的索引位置 
18.      */  
19.     @SuppressWarnings({ })  
20.     private int partition(int[] a, int p, int r) {  
21.         int i = p, j = r + 1;  
22.         int x = a[p];// 使用子数组的首个元素作为枢纽  
23.         while (true) {  
24.             // 从左边开始找到大于枢纽的元素索引  
25.             while (a[++i] < x && i < r);  
26.             // 同时从右边开始找到小于枢纽的元素索引  
27.             while (a[--j]> x);  
28.             if (i >= j)  
29.                 break;  
30.             // 交换大于枢纽的元素到右边，小于枢纽的元素导左边  
31.             swap(a, i, j);  
32.         }// a[i]>=枢纽,a[j]<=枢纽,i>=j的时候表示已经划分完毕  
33.         a[p] = a[j];// 交换枢纽索引位置所在元素和枢纽  
34.         a[j] = x;  
35.         return j;// j为枢纽索引  
36.     }  
37.   
38.     /** 
39.      * 交换指定数组中的两个元素 
40.      * @param a 指定数组 
41.      * @param i  第一个元素的索引 
42.      * @param j  第二个元素的索引 
43.      */  
44.     public static void swap(int[] a, int i, int j) {  
45.         int temp = a[i];  
46.         a[i] = a[j];  
47.         a[j] = temp;  
48.     }  
49.   
50.     /** 
51.      * 快速排序算法的非递归实现，使用辅助栈 
52.      * @param a 待排序的数组段 
53.      * @param p  数组段的左端索引 
54.      * @param r 数组段的右端索引 
55.      */  
56.     @SuppressWarnings({ "unused" })  
57.     private void qSort(int[] a, int p, int r) {  
58.         ArrayStack stack = new ArrayStack();// 栈  
59.         if (p < r) {  
60.             int mid = partition(a, p, r);  
61.             if (p < mid - 1) {  
62.                 stack.push(p);  
63.                 stack.push(mid - 1);  
64.             }  
65.             if (mid + 1 < r) {  
66.                 stack.push(mid + 1);  
67.                 stack.push(r);  
68.             }  
69.             while (!stack.empty()) {  
70.                 int m = (int) stack.pop();  
71.                 int n = (int) stack.pop();  
72.                 int l = partition(a, n, m);  
73.                 if (n < l - 1) {  
74.                     stack.push(n);  
75.                     stack.push(l - 1);  
76.                 }  
77.                 if (l + 1 < m) {  
78.                     stack.push(l + 1);  
79.                     stack.push(m);  
80.                 }  
81.             }  
82.         }  
83.     }  
84.   
85. }  

 

[java]  view plain copy

1. /** 
2.  * 排序算法学习之快速排序 
3.  * @author Sking 
4.  实现方法： 
5. 通过把一个数组递归的划分为两个子数组。  
6. 递归的基本步骤： 
7. 1. 把数组划分成以一个元素为枢纽的左右两个子数组。  
8. 2. 调用自身的左边和右边以步骤1递归。  
9.  
10. 性能障碍： 
11. 对枢纽数据的选择是影响排序的效率。 
12.   
13.  性能： 
14.  最坏时间复杂度：O(n^2) 
15.  平均时间复杂度：O(n*log(n)) 
16.  辅助空间：O(n)或O(log(n)) 
17.  稳定性：不稳定 
18.  时间复杂度是O(n*log(n)) 
19.  */  
20. package 排序算法.quickSort;  
21.   
22. public class QuickSort {  
23.     @SuppressWarnings("rawtypes")  
24.     /** 
25.      * 递归划分子数组a[p....r] 
26.      * @param a 指定数组，索引有效范围从0开始 
27.      * @param p 子数组的开始索引 
28.      * @param r 子数组的结束索引 
29.      */  
30.     private void qSort(Comparable[] a,int p, int r) {  
31.         if (p < r) {  
32.             int q = partition(a,p, r);//划分的位置索引  
33.             qSort(a,p, q - 1);//递归划分  
34.             qSort(a,q + 1, r);  
35.         }  
36.     }  
37.   
38.     /** 
39.      * 使用子数组的首个元素作为枢纽，划分子数组 
40.      * 划分后，枢纽左边的元素均小于枢纽，右边的元素均大于枢纽 
41.      * 并返回划分的位置索引，是快速排序的核心方法 
42.      * @param a 待排序数组 
43.      * @param p 子数组的开始索引 
44.      * @param r 子数组的结束索引 
45.      * @return 划分的索引位置 
46.      */  
47.     @SuppressWarnings({ "rawtypes", "unchecked" })  
48.     private int partition(Comparable[] a,int p, int r) {  
49.         int i = p, j = r + 1;  
50.         Comparable x = a[p];//使用子数组的首个元素作为枢纽  
51.         while (true) {  
52.             //从左边开始找到大于枢纽的元素索引  
53.             while (a[++i].compareTo(x) < 0 && i < r);  
54.             //同时从右边开始找到小于枢纽的元素索引  
55.             while (a[--j].compareTo(x) > 0);  
56.             if (i >= j)  
57.                 break;  
58.             //交换大于枢纽的元素到右边，小于枢纽的元素导左边  
59.             swap(a,i, j);  
60.         }//a[i]>=枢纽,a[j]<=枢纽,i>=j的时候表示已经划分完毕  
61.         a[p] = a[j];//交换枢纽索引位置所在元素和枢纽  
62.         a[j] = x;  
63.         return j;//j为枢纽索引  
64.     }  
65.   
66.     /** 
67.      * 交换指定数组中的两个元素 
68.      * @param a 指定数组 
69.      * @param i 第一个元素的索引 
70.      * @param j 第二个元素的索引 
71.      */  
72.     @SuppressWarnings("rawtypes")  
73.     public static void swap(Comparable[] a,int i, int j) {  
74.         Comparable temp = a[i];  
75.         a[i] = a[j];  
76.         a[j] = temp;  
77.     }  
78.   
79. }  

 

[java]  view plain copy

1. /** 
2.  * 排序算法学习之一般合并排序 
3.  * @author Sking 
4.  
5. 实现方法： 
6. 将待排序数组分为大小大致相等的2个子数组 
7. 分别对两个子数组进行排序，如此递归划分排序 
8. 最后将排序号的子数组再递归合并为更大的已排序数组 
9. 直到整个数组已排序为止。 
10.  */  
11. package 排序算法.mergeSort;  
12.   
13. public class MergeSort2 {  
14.   
15.     /** 
16.      * 对指定数组的指定范围执行一般合并排序 
17.      *  
18.      * @param a 
19.      *            指定数组 
20.      * @param left 
21.      *            指定范围的左边索引 
22.      * @param right 
23.      *            指定范围的右边索引 
24.      */  
25.     @SuppressWarnings("rawtypes")  
26.     public void mergeSort2(Comparable[] a, int left, int right) {  
27.         Comparable[] b = new Comparable[a.length];  
28.         if (left < right) {  
29.             int i = (left + right) / 2;  
30.             mergeSort2(a, left, i);//左子段递归排序  
31.             mergeSort2(a, i + 1, right);//右子段递归排序  
32.             merge(a, b, left, i, right);//合并子段到新数组中  
33.             copy(a, b, left, right);//复制排序后的元素到原数组  
34.         }  
35.   
36.     }  
37.   
38.     /** 
39.      * 合并已排序子数组c[l...m]和c[m+1,r]到新数组中，新数组保持有序 
40.      *  
41.      * @param c存放两个已排序数组的数组 
42.      * @param d 
43.      *            新数组，用于存放合并后的数组 
44.      * @param l 
45.      *            左边子数组的起始索引 
46.      * @param m 
47.      *            左边子数组的结束索引 
48.      * @param r 
49.      *            右边子数组的结束索引 
50.      */  
51.     @SuppressWarnings({ "rawtypes", "unchecked" })  
52.     private static void merge(Comparable[] c, Comparable[] d, int l, int m,  
53.             int r) {  
54.         int i = l;  
55.         int j = m + 1;  
56.         int k = l;  
57.         while ((i <= m) && (j <= r))  
58.             if (c[i].compareTo(c[j]) <= 0)  
59.                 d[k++] = c[i++];  
60.             else  
61.                 d[k++] = c[j++];  
62.         if (i > m)  
63.             for (int q = j; q <= r; q++)  
64.                 d[k++] = c[q];  
65.         else  
66.             for (int q = i; q <= m; q++)  
67.                 d[k++] = c[q];  
68.     }  
69.   
70.     /** 
71.      * 复制源数组中指定索引范围内的元素到目标数组 
72.      *  
73.      * @param a 
74.      *            源数组 
75.      * @param b 
76.      *            目标数组 
77.      * @param left 
78.      *            指定范围的左边索引 
79.      * @param right 
80.      *            指定范围的右边索引 
81.      */  
82.     @SuppressWarnings("rawtypes")  
83.     private static void copy(Comparable[] a, Comparable[] b, int left, int   
84.                                           right) {  
85.         int i = left;  
86.         int j = left;  
87.         while (i <= right)  
88.             a[i++] = b[j++];  
89.     }  
90.   
91. }  

 

[java]  view plain copy

1. /** 
2.  * 排序算法学习之合并排序 
3.  * @author Sking 
4.   
5.  实现方法： 
6. 将待排序数组中相邻元素两两配对作为子数组，排序各个子数组， 
7.  构成n/2组长度为2的排序好的子数组；然后将长度为2的子排序 
8.  子数组再两两配对，并排序，构成长度为4的已排序子数组。如此递归 
9.  直到整个数组是已排序为止。 
10.   
11.   最坏时间复杂度：O(n*log(n)) 
12.   平均时间复杂度：O(n*log(n)) 
13.   辅助空间：O(n) 
14.   稳定性：稳定 
15.  */  
16. package 排序算法.mergeSort;  
17.   
18. public class MergeSort {  
19.     @SuppressWarnings("rawtypes")  
20.     /** 
21.      * 对输入数组执行合并排序 
22.      * @param a 指定数组，索引有效位置从0开始 
23.      */  
24.     public void mergeSort(Comparable[] a) {  
25.         Comparable[] b = new Comparable[a.length];// 辅助空间  
26.         int s = 1;// 初始子数组长度设置为1  
27.         while (s < a.length) {  
28.             mergePass(a, b, s);  
29.             s += s;  
30.             mergePass(b, a, s);  
31.             s += s;  
32.         }  
33.     }  
34.   
35.     /** 
36.      * 合并相邻的已排序子数组为更大的已排序子数组 
37.      *  
38.      * @param x 
39.      *            包含了已排序子数组的数组 
40.      * @param y 
41.      *            包含更大的已排序子数组的数组 
42.      * @param s 
43.      *            已排序子数组的长度 
44.      */  
45.     @SuppressWarnings("rawtypes")  
46.     public static void mergePass(Comparable[] x, Comparable[] y, int s) {  
47.         int i = 0;  
48.         while (i <= x.length - 2 * s) {// 合并两相邻的长度为s的已排序子数组  
49.             merge(x, y, i, i + s - 1, i + 2 * s - 1);  
50.             i = i + 2 * s;  
51.         }// 当i>x.length-2*s的时候退出while循环  
52.             // 处理剩下的部分，可以是s长度的已排序数组+“零片”  
53.             // 也可能只是“零片“，此时不需要合并。  
54.         if (i + s < x.length) {  
55.             // 合并相邻的长度s的已排序子数组和长度小于s的“零片”  
56.             merge(x, y, i, i + s - 1, x.length - 1);  
57.         } else  
58.             // 处理”零片“  
59.             for (int j = i; j < x.length; j++)  
60.                 y[j] = x[j];  
61.     }  
62.   
63.     /** 
64.      * 合并已排序子数组c[l...m]和c[m+1,r]到新数组中，新数组保持有序 
65.      *  
66.      * @param c存放两个已排序数组的数组 
67.      * @param d 
68.      *            新数组，用于存放合并后的数组 
69.      * @param l 
70.      *            左边子数组的起始索引 
71.      * @param m 
72.      *            左边子数组的结束索引 
73.      * @param r 
74.      *            右边子数组的结束索引 
75.      */  
76.     @SuppressWarnings({ "unchecked", "rawtypes" })  
77.     static void merge(Comparable[] c, Comparable[] d, int l, int m, int r) {  
78.         int i = l;// 第一个子数组的索引指针  
79.         int j = m + 1;// 第二个子数组的索引指针  
80.         int k = l;// 新数组的索引指针  
81.         while ((i <= m) && (j <= r))  
82.             if (c[i].compareTo(c[j]) <= 0)  
83.                 d[k++] = c[i++];  
84.             else  
85.                 d[k++] = c[j++];  
86.         if (i > m)// 将右边子数组剩下的元素添加到新数组中  
87.             for (int q = j; q <= r; q++)  
88.                 d[k++] = c[q];  
89.         else  
90.             // 将左边子数组剩下的元素添加到新数组中  
91.             for (int q = i; q <= m; q++)  
92.                 d[k++] = c[q];  
93.     }  
94.   
95. }  

 

[java]  view plain copy

1. /** 
2.  * 排序算法学习之插入排序 
3.  * @author Sking 
4.  */  
5. package 排序算法.insertionSort;  
6.   
7. public class InsertionSort {  
8.     @SuppressWarnings({ "rawtypes", "unchecked" })  
9.     /** 
10.      * 一次元素插入的实现，在n长度的子数组中插入元素x到合适位置 
11.      * @param a 带排序数组，索引有效范围从0开始 
12.      * @param n 子数组元素个数 
13.      * @param x 待插入的元素 
14.      */  
15.     public static void insert(Comparable[] a, int n, Comparable x) {  
16.         if (a.length < n + 1)//数组已满，不可插入  
17.             throw new IllegalArgumentException("数组不够大");  
18.         int i;//当前被比较元素索引  
19.         for (i = n - 1; i >= 0 && x.compareTo(a[i]) < 0; i--)  
20.             a[i + 1] = a[i];//比x大的元素后移，寻找x插入的位置  
21.         a[i + 1] = x;//插入x  
22.     }  
23.   
24.     /** 
25.      * 对输入数组执行插入排序 
26.      * @param a 待排序数组，索引有效位置从0开始 
27.      */  
28.     @SuppressWarnings("rawtypes")  
29.     public static void insertionSort(Comparable[] a) {  
30.         //i表示一次元素插入步骤所考虑的子数组长度,大小递增  
31.         for (int i = 1; i < a.length; i++)  
32.             insert(a, i, a[i]);  
33.     }  
34. }  

 

[java]  view plain copy

1. /** 
2.  * 排序算法学习之冒泡排序 
3.  * 使用时，将Comparable类型替换为指定类型，必要时，要定义比较方法 
4.  * @author Sking 
5.  */  
6. package 排序算法.bubbleSort;  
7.   
8. public class BubbleSort {  
9.     /** 
10.      * 交换数组元素方法 
11.      * @param a 指定数组 
12.      * @param i 第一个索引 
13.      * @param j 第二个索引 
14.      */  
15.     @SuppressWarnings("rawtypes")  
16.     public static void swap(Comparable[] a, int i, int j) {  
17.         Comparable t = a[i];  
18.         a[i] = a[j];  
19.         a[j] = t;  
20.     }  
21.   
22.     /** 
23.      * 一次冒泡迭代,分别比较相邻元素选择单趟的最大元素 
24.      * @param a 指定数组 
25.      * @param n 冒泡子序列的长度 
26.      */  
27.     @SuppressWarnings({ "rawtypes", "unchecked" })  
28.     private static void bubble(Comparable[] a, int n) {  
29.         for (int i = 0; i < n - 1; i++)  
30.             if (a[i].compareTo(a[i + 1]) > 0)  
31.                 swap(a, i, i + 1);  
32.     }  
33.     /** 
34.      * 一般冒泡排序 
35.      * @param a 指定数组 
36.      */  
37.     @SuppressWarnings("rawtypes")  
38.     public static void bubbleSort(Comparable[] a) {  
39.         for (int i = a.length; i > 1; i--)  
40.             bubble(a, i);  
41.     }  
42.       
43.     /** 
44.      * 早结束版本的冒泡排序方法的一次迭代 
45.      * @param a 指定数组 
46.      * @param n 冒泡子序列的长度 
47.      * @return 如果该次迭代中进行了元素交换位置，则返回true，否则返回false 
48.      */  
49.     @SuppressWarnings({ "rawtypes", "unchecked" })  
50.     private static boolean haveBubble(Comparable[] a,int n){  
51.         boolean swapped=false;//标志一次冒泡是否进行交换  
52.         for(int i=0;i<n-1;i++)  
53.             if(a[i].compareTo(a[i+1])>0){  
54.                 swap(a,i,i+1);  
55.                 swapped=true;  
56.             }  
57.         return swapped;  
58.     }  
59.       
60.     /** 
61.      * 早结束版本的冒泡排序 
62.      * @param a 指定排序的数组 
63.      */  
64.     @SuppressWarnings("rawtypes")  
65.     public static void bubbleSort2(Comparable[] a){  
66.         for(int i=a.length;i>1&&haveBubble(a,i);i--);  
67.     }  
68. }