java实现各种基础排序

前言

经过两个月的各种笔试面试，对各种基础排序算法原理了然于胸，用c闭着眼都能写出完美ac的代码来，今天刚看完java的数组，忍不住用java将各种排序实现一遍

注意，这篇文章只是为了锻炼java语法，不会深入讲各种排序原理，有兴趣的同学可以看我之前的博客，各自排序我都用c讲的非常清楚了

冒泡排序

[java]  view plain copy print ?

1. public static void bubbleSort(int A[], int n) {  
2.     int i, j;  
3.       
4.     for (i = 0; i < n - 1; i ++) {  
5.         for (j = 0; j < n - i - 1; j ++) {  
6.             if (A[j] > A[j + 1]) {  
7.                 A[j] = A[j] ^ A[j + 1];  
8.                 A[j + 1] = A[j] ^ A[j + 1];  
9.                 A[j] = A[j] ^ A[j + 1];  
10.             }  
11.         }  
12.     }  
13. }  

直接插入排序

[java]  view plain copy print ?

1. public static void insertSort(int A[], int n) {  
2.     int i, j, tmp;  
3.   
4.     for (i = 1; i < n; i++) {  
5.         tmp = A[i];  
6.   
7.         for (j = i - 1; j >= 0; j--) {  
8.             if (A[j] > tmp) {  
9.                 A[j + 1] = A[j];  
10.             } else {  
11.                 break;  
12.             }  
13.         }  
14.   
15.         A[j + 1] = tmp;  
16.     }  
17. }  

直接选择排序

[java]  view plain copy print ?

1. public static void selectSort(int A[], int n) {  
2.     int i, j, loc;  
3.   
4.     for (i = 0; i < n; i++) {  
5.         loc = i;  
6.   
7.         for (j = i + 1; j < n; j++) {  
8.             if (A[j] < A[loc]) {  
9.                 loc = j;  
10.             }  
11.         }  
12.   
13.         if (loc != i) {  
14.             A[i] = A[i] ^ A[loc];  
15.             A[loc] = A[i] ^ A[loc];  
16.             A[i] = A[i] ^ A[loc];  
17.         }  
18.     }  
19. }  

堆排序

[java]  view plain copy print ?

1. /** 
2.  * 堆排序（从小到大） 
3.  *  
4.  * @param A 
5.  * @param n 
6.  */  
7. public static void heapSort(int A[], int n) {  
8.     int tmp;  
9.   
10.     // 构建大根堆  
11.     buildMaxHeap(A, n);  
12.   
13.     for (int j = n - 1; j >= 1; j--) {  
14.         tmp = A[0];  
15.         A[0] = A[j];  
16.         A[j] = tmp;  
17.   
18.         maxheapIfy(A, 0, j);  
19.     }  
20. }  
21.   
22. /** 
23.  * 构建大根堆 
24.  *  
25.  * @param A 
26.  * @param n 
27.  */  
28. private static void buildMaxHeap(int A[], int n) {  
29.     for (int i = (n - 2) / 2; i >= 0; i--) {  
30.         maxheapIfy(A, i, n);  
31.     }  
32. }  
33.   
34. /** 
35.  * 维护从下标i开始的最大堆 
36.  *  
37.  * @param A 
38.  * @param i 
39.  * @param n 
40.  */  
41. private static void maxheapIfy(int A[], int i, int n) {  
42.     int left, right, loc;  
43.   
44.     while (i < n) {  
45.         left = 2 * i + 1;  
46.         right = 2 * i + 2;  
47.         loc = i;  
48.   
49.         if (left < n && A[left] > A[i]) {  
50.             i = left;  
51.         }  
52.   
53.         if (right < n && A[right] > A[i]) {  
54.             i = right;  
55.         }  
56.   
57.         if (loc != i) {  
58.             A[i] = A[loc] ^ A[i];  
59.             A[loc] = A[loc] ^ A[i];  
60.             A[i] = A[loc] ^ A[i];  
61.         } else {  
62.             break;  
63.         }  
64.     }  
65. }  

快速排序

[java]  view plain copy print ?

1. public static void quickSort(int A[], int bt, int ed) {  
2.     if (bt < ed) {  
3.         int pivot = pivotPartition(A, bt, ed);  
4.   
5.         quickSort(A, bt, pivot - 1);  
6.   
7.         quickSort(A, pivot + 1, ed);  
8.     }  
9. }  
10.   
11. private static void swapVar(int A[], int bt, int ed) {  
12.     int mid = bt + (ed - bt) / 2;  
13.   
14.     if (mid != bt) {  
15.         A[bt] = A[bt] ^ A[mid];  
16.         A[mid] = A[bt] ^ A[mid];  
17.         A[bt] = A[bt] ^ A[mid];  
18.     }  
19. }  
20.   
21. private static int pivotPartition(int A[], int bt, int ed) {  
22.     // 取中间值作为stand，防止数组有序出现O(n^2)情况  
23.     swapVar(A, bt, ed);  
24.   
25.     int stand = A[bt];  
26.   
27.     while (bt < ed) {  
28.         while (bt < ed && A[ed] >= stand) {  
29.             ed--;  
30.         }  
31.         if (bt < ed) {  
32.             A[bt++] = A[ed];  
33.         }  
34.   
35.         while (bt < ed && A[bt] <= stand) {  
36.             bt++;  
37.         }  
38.         if (bt < ed) {  
39.             A[ed--] = A[bt];  
40.         }  
41.     }  
42.   
43.     A[bt] = stand;  
44.   
45.     return bt;  
46. }  

归并排序

[java]  view plain copy print ?

1. public static void mergeSort(int A[], int bt, int ed) {  
2.     if (bt < ed) {  
3.         int mid = bt + (ed - bt) / 2;  
4.   
5.         mergeSort(A, bt, mid);  
6.   
7.         mergeSort(A, mid + 1, ed);  
8.   
9.         mergeArray(A, bt, mid, ed);  
10.     }  
11. }  
12.   
13. private static void mergeArray(int A[], int bt, int mid, int ed) {  
14.     int i, j, k, len = ed - bt + 1;  
15.     int tmp[] = new int[len];  
16.   
17.     for (i = bt, j = mid + 1, k = 0; i <= mid && j <= ed; k++) {  
18.         if (A[i] <= A[j]) {  
19.             tmp[k] = A[i++];  
20.         } else {  
21.             tmp[k] = A[j++];  
22.         }  
23.     }  
24.   
25.     while (i <= mid) {  
26.         tmp[k++] = A[i++];  
27.     }  
28.   
29.     while (j <= ed) {  
30.         tmp[k++] = A[j++];  
31.     }  
32.   
33.     for (i = 0; i < k; i++) {  
34.         A[bt + i] = tmp[i];  
35.     }  
36. }  

测试程序

[java]  view plain copy print ?

1. import java.util.Scanner;  
2.   
3. public class JavaSort {  
4.     public static void main(String args[]) {  
5.         Scanner cin = new Scanner(System.in);  
6.   
7.         int A[], n;  
8.   
9.         while (cin.hasNext()) {  
10.             n = cin.nextInt();  
11.             A = new int[n];  
12.   
13.             for (int i = 0; i < n; i++) {  
14.                 A[i] = cin.nextInt();  
15.             }  
16.   
17.             // bubbleSort(A, n);  
18.   
19.             // insertSort(A, n);  
20.   
21.             // selectSort(A, n);  
22.   
23.             // heapSort(A, n);  
24.   
25.             // quickSort(A, 0, n - 1);  
26.   
27.             mergeSort(A, 0, n - 1);  
28.   
29.             printArr(A);  
30.         }  
31.     }  
32.   
33.     /** 
34.      * 归并排序 
35.      *  
36.      * @param A 
37.      * @param bt 
38.      * @param ed 
39.      */  
40.     public static void mergeSort(int A[], int bt, int ed) {  
41.         if (bt < ed) {  
42.             int mid = bt + (ed - bt) / 2;  
43.   
44.             mergeSort(A, bt, mid);  
45.   
46.             mergeSort(A, mid + 1, ed);  
47.   
48.             mergeArray(A, bt, mid, ed);  
49.         }  
50.     }  
51.   
52.     /** 
53.      * 合并数组 
54.      *  
55.      * @param A 
56.      * @param bt 
57.      * @param mid 
58.      * @param ed 
59.      */  
60.     private static void mergeArray(int A[], int bt, int mid, int ed) {  
61.         int i, j, k, len = ed - bt + 1;  
62.         int tmp[] = new int[len];  
63.   
64.         for (i = bt, j = mid + 1, k = 0; i <= mid && j <= ed; k++) {  
65.             if (A[i] <= A[j]) {  
66.                 tmp[k] = A[i++];  
67.             } else {  
68.                 tmp[k] = A[j++];  
69.             }  
70.         }  
71.   
72.         while (i <= mid) {  
73.             tmp[k++] = A[i++];  
74.         }  
75.   
76.         while (j <= ed) {  
77.             tmp[k++] = A[j++];  
78.         }  
79.   
80.         for (i = 0; i < k; i++) {  
81.             A[bt + i] = tmp[i];  
82.         }  
83.     }  
84.   
85.     /** 
86.      * 快速排序 
87.      *  
88.      * @param A 
89.      * @param bt 
90.      * @param ed 
91.      */  
92.     public static void quickSort(int A[], int bt, int ed) {  
93.         if (bt < ed) {  
94.             int pivot = pivotPartition(A, bt, ed);  
95.   
96.             quickSort(A, bt, pivot - 1);  
97.   
98.             quickSort(A, pivot + 1, ed);  
99.         }  
100.     }  
101.   
102.     private static void swapVar(int A[], int bt, int ed) {  
103.         int mid = bt + (ed - bt) / 2;  
104.   
105.         if (mid != bt) {  
106.             A[bt] = A[bt] ^ A[mid];  
107.             A[mid] = A[bt] ^ A[mid];  
108.             A[bt] = A[bt] ^ A[mid];  
109.         }  
110.     }  
111.   
112.     /** 
113.      * 快排寻找基准点位置 
114.      *  
115.      * @param A 
116.      * @param bt 
117.      * @param ed 
118.      * @return 
119.      */  
120.     private static int pivotPartition(int A[], int bt, int ed) {  
121.         // 取中间值作为stand，防止数组有序出现O(n^2)情况  
122.         swapVar(A, bt, ed);  
123.   
124.         int stand = A[bt];  
125.   
126.         while (bt < ed) {  
127.             while (bt < ed && A[ed] >= stand) {  
128.                 ed--;  
129.             }  
130.             if (bt < ed) {  
131.                 A[bt++] = A[ed];  
132.             }  
133.   
134.             while (bt < ed && A[bt] <= stand) {  
135.                 bt++;  
136.             }  
137.             if (bt < ed) {  
138.                 A[ed--] = A[bt];  
139.             }  
140.         }  
141.   
142.         A[bt] = stand;  
143.   
144.         return bt;  
145.     }  
146.   
147.     /** 
148.      * 堆排序（从小到大） 
149.      *  
150.      * @param A 
151.      * @param n 
152.      */  
153.     public static void heapSort(int A[], int n) {  
154.         int tmp;  
155.   
156.         // 构建大根堆  
157.         buildMaxHeap(A, n);  
158.   
159.         for (int j = n - 1; j >= 1; j--) {  
160.             tmp = A[0];  
161.             A[0] = A[j];  
162.             A[j] = tmp;  
163.   
164.             maxheapIfy(A, 0, j);  
165.         }  
166.     }  
167.   
168.     /** 
169.      * 构建大根堆 
170.      *  
171.      * @param A 
172.      * @param n 
173.      */  
174.     private static void buildMaxHeap(int A[], int n) {  
175.         for (int i = (n - 2) / 2; i >= 0; i--) {  
176.             maxheapIfy(A, i, n);  
177.         }  
178.     }  
179.   
180.     /** 
181.      * 维护从下标i开始的最大堆 
182.      *  
183.      * @param A 
184.      * @param i 
185.      * @param n 
186.      */  
187.     private static void maxheapIfy(int A[], int i, int n) {  
188.         int left, right, loc;  
189.   
190.         while (i < n) {  
191.             left = 2 * i + 1;  
192.             right = 2 * i + 2;  
193.             loc = i;  
194.   
195.             if (left < n && A[left] > A[i]) {  
196.                 i = left;  
197.             }  
198.   
199.             if (right < n && A[right] > A[i]) {  
200.                 i = right;  
201.             }  
202.   
203.             if (loc != i) {  
204.                 A[i] = A[loc] ^ A[i];  
205.                 A[loc] = A[loc] ^ A[i];  
206.                 A[i] = A[loc] ^ A[i];  
207.             } else {  
208.                 break;  
209.             }  
210.         }  
211.     }  
212.   
213.     /** 
214.      * 直接选择排序 
215.      *  
216.      * @param A 
217.      * @param n 
218.      */  
219.     public static void selectSort(int A[], int n) {  
220.         int i, j, loc;  
221.   
222.         for (i = 0; i < n; i++) {  
223.             loc = i;  
224.   
225.             for (j = i + 1; j < n; j++) {  
226.                 if (A[j] < A[loc]) {  
227.                     loc = j;  
228.                 }  
229.             }  
230.   
231.             if (loc != i) {  
232.                 A[i] = A[i] ^ A[loc];  
233.                 A[loc] = A[i] ^ A[loc];  
234.                 A[i] = A[i] ^ A[loc];  
235.             }  
236.         }  
237.     }  
238.   
239.     /** 
240.      * 直接插入排序 
241.      *  
242.      * @param A 
243.      * @param n 
244.      */  
245.     public static void insertSort(int A[], int n) {  
246.         int i, j, tmp;  
247.   
248.         for (i = 1; i < n; i++) {  
249.             tmp = A[i];  
250.   
251.             for (j = i - 1; j >= 0; j--) {  
252.                 if (A[j] > tmp) {  
253.                     A[j + 1] = A[j];  
254.                 } else {  
255.                     break;  
256.                 }  
257.             }  
258.   
259.             A[j + 1] = tmp;  
260.         }  
261.     }  
262.   
263.     /** 
264.      * 冒泡排序 
265.      *  
266.      * @param A 
267.      * @param n 
268.      */  
269.     public static void bubbleSort(int A[], int n) {  
270.         int i, j;  
271.   
272.         for (i = 0; i < n - 1; i++) {  
273.             for (j = 0; j < n - i - 1; j++) {  
274.                 if (A[j] > A[j + 1]) {  
275.                     A[j] = A[j] ^ A[j + 1];  
276.                     A[j + 1] = A[j] ^ A[j + 1];  
277.                     A[j] = A[j] ^ A[j + 1];  
278.                 }  
279.             }  
280.         }  
281.     }  
282.   
283.     /** 
284.      * 打印数组 
285.      *  
286.      * @param A 
287.      */  
288.     public static void printArr(int A[]) {  
289.         for (int i = 0; i < A.length; i++) {  
290.             if (i == A.length - 1) {  
291.                 System.out.printf("%d\n", A[i]);  
292.             } else {  
293.                 System.out.printf("%d ", A[i]);  
294.             }  
295.         }  
296.     }  
297. }