Collections.sort()
Java的排序可以用Collections.sort() 排序函數實現。
用Collections.sort方法對list排序有兩種方法：
第一種是list中的對象實現Comparable接口，如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
/*** 根據order對User排序*/public class User implements Comparable<User>{ private String name; private Integer order; public String getName() { return name; } public void setName(String name) { this.name = name; } public Integer getOrder() { return order; } public void setOrder(Integer order) { this.order = order; } public int compareTo(User arg0) { return this.getOrder().compareTo(arg0.getOrder()); }} |
測試一下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
public class Test{ public static void main(String[] args) { User user1 = new User(); user1.setName("a"); user1.setOrder(1); User user2 = new User(); user2.setName("b"); user2.setOrder(2); List<User> list = new ArrayList<User>(); //此處add user2再add user1 list.add(user2); list.add(user1); Collections.sort(list); for(User u : list){ System.out.println(u.getName()); } }} |
輸出結果如下
|
1
2
|
ab |
第二種方法是根據Collections.sort重載方法來實現，例如：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
/*** 根據order對User排序*/public class User { //此處無需實現Comparable接口 private String name; private Integer order; public String getName() { return name; } public void setName(String name) { this.name = name; } public Integer getOrder() { return order; } public void setOrder(Integer order) { this.order = order; }} |
主類中這樣寫即可：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
public class Test{ public static void main(String[] args) { User user1 = new User(); user1.setName("a"); user1.setOrder(1); User user2 = new User(); user2.setName("b"); user2.setOrder(2); List<User> list = new ArrayList<User>(); list.add(user2); list.add(user1); Collections.sort(list,new Comparator<User>(){ public int compare(User arg0, User arg1) { return arg0.getOrder().compareTo(arg1.getOrder()); } }); for(User u : list){ System.out.println(u.getName()); } }} |
輸出結果如下
|
1
2
|
ab |
前者代碼結構簡單，但是只能根據固定的屬性排序，后者靈活，可以臨時指定排序項，但是代碼不夠簡潔
擇優用之。
常用排序算法
下面來看幾種經典排序算法的Java代碼實踐：
冒泡排序
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
public static void bubbleSort(int A[], int n) { int i, j; for (i = 0; i < n - 1; i ++) { for (j = 0; j < n - i - 1; j ++) { if (A[j] > A[j + 1]) { A[j] = A[j] ^ A[j + 1]; A[j + 1] = A[j] ^ A[j + 1]; A[j] = A[j] ^ A[j + 1]; } } } } |
直接插入排序
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
public static void insertSort(int A[], int n) { int i, j, tmp; for (i = 1; i < n; i++) { tmp = A[i]; for (j = i - 1; j >= 0; j--) { if (A[j] > tmp) { A[j + 1] = A[j]; } else { break; } } A[j + 1] = tmp; } } |
直接選擇排序
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
public static void selectSort(int A[], int n) { int i, j, loc; for (i = 0; i < n; i++) { loc = i; for (j = i + 1; j < n; j++) { if (A[j] < A[loc]) { loc = j; } } if (loc != i) { A[i] = A[i] ^ A[loc]; A[loc] = A[i] ^ A[loc]; A[i] = A[i] ^ A[loc]; } } } |
堆排序
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
|
/** * 堆排序（從小到大） * * @param A * @param n */public static void heapSort(int A[], int n) { int tmp; // 構建大根堆 buildMaxHeap(A, n); for (int j = n - 1; j >= 1; j--) { tmp = A[0]; A[0] = A[j]; A[j] = tmp; maxheapIfy(A, 0, j); } } /** * 構建大根堆 * * @param A * @param n */private static void buildMaxHeap(int A[], int n) { for (int i = (n - 2) / 2; i >= 0; i--) { maxheapIfy(A, i, n); } } /** * 維護從下標i開始的最大堆 * * @param A * @param i * @param n */private static void maxheapIfy(int A[], int i, int n) { int left, right, loc; while (i < n) { left = 2 * i + 1; right = 2 * i + 2; loc = i; if (left < n && A[left] > A[i]) { i = left; } if (right < n && A[right] > A[i]) { i = right; } if (loc != i) { A[i] = A[loc] ^ A[i]; A[loc] = A[loc] ^ A[i]; A[i] = A[loc] ^ A[i]; } else { break; } } } |
快速排序
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
|
public static void quickSort(int A[], int bt, int ed) { if (bt < ed) { int pivot = pivotPartition(A, bt, ed); quickSort(A, bt, pivot - 1); quickSort(A, pivot + 1, ed); } } private static void swapVar(int A[], int bt, int ed) { int mid = bt + (ed - bt) / 2; if (mid != bt) { A[bt] = A[bt] ^ A[mid]; A[mid] = A[bt] ^ A[mid]; A[bt] = A[bt] ^ A[mid]; } } private static int pivotPartition(int A[], int bt, int ed) { // 取中間值作為stand，防止數組有序出現O(n^2)情況 swapVar(A, bt, ed); int stand = A[bt]; while (bt < ed) { while (bt < ed && A[ed] >= stand) { ed--; } if (bt < ed) { A[bt++] = A[ed]; } while (bt < ed && A[bt] <= stand) { bt++; } if (bt < ed) { A[ed--] = A[bt]; } } A[bt] = stand; return bt; } |
歸并排序
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
|
public static void mergeSort(int A[], int bt, int ed) { if (bt < ed) { int mid = bt + (ed - bt) / 2; mergeSort(A, bt, mid); mergeSort(A, mid + 1, ed); mergeArray(A, bt, mid, ed); } } private static void mergeArray(int A[], int bt, int mid, int ed) { int i, j, k, len = ed - bt + 1; int tmp[] = new int[len]; for (i = bt, j = mid + 1, k = 0; i <= mid && j <= ed; k++) { if (A[i] <= A[j]) { tmp[k] = A[i++]; } else { tmp[k] = A[j++]; } } while (i <= mid) { tmp[k++] = A[i++]; } while (j <= ed) { tmp[k++] = A[j++]; } for (i = 0; i < k; i++) { A[bt + i] = tmp[i]; } } |
測試程序
來將以上算法歸納總結一下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
|
import java.util.Scanner; public class JavaSort { public static void main(String args[]) { Scanner cin = new Scanner(System.in); int A[], n; while (cin.hasNext()) { n = cin.nextInt(); A = new int[n]; for (int i = 0; i < n; i++) { A[i] = cin.nextInt(); } // bubbleSort(A, n); // insertSort(A, n); // selectSort(A, n); // heapSort(A, n); // quickSort(A, 0, n - 1); mergeSort(A, 0, n - 1); printArr(A); } } /** * 歸并排序 * * @param A * @param bt * @param ed */ public static void mergeSort(int A[], int bt, int ed) { if (bt < ed) { int mid = bt + (ed - bt) / 2; mergeSort(A, bt, mid); mergeSort(A, mid + 1, ed); mergeArray(A, bt, mid, ed); } } /** * 合并數組 * * @param A * @param bt * @param mid * @param ed */ private static void mergeArray(int A[], int bt, int mid, int ed) { int i, j, k, len = ed - bt + 1; int tmp[] = new int[len]; for (i = bt, j = mid + 1, k = 0; i <= mid && j <= ed; k++) { if (A[i] <= A[j]) { tmp[k] = A[i++]; } else { tmp[k] = A[j++]; } } while (i <= mid) { tmp[k++] = A[i++]; } while (j <= ed) { tmp[k++] = A[j++]; } for (i = 0; i < k; i++) { A[bt + i] = tmp[i]; } } /** * 快速排序 * * @param A * @param bt * @param ed */ public static void quickSort(int A[], int bt, int ed) { if (bt < ed) { int pivot = pivotPartition(A, bt, ed); quickSort(A, bt, pivot - 1); quickSort(A, pivot + 1, ed); } } private static void swapVar(int A[], int bt, int ed) { int mid = bt + (ed - bt) / 2; if (mid != bt) { A[bt] = A[bt] ^ A[mid]; A[mid] = A[bt] ^ A[mid]; A[bt] = A[bt] ^ A[mid]; } } /** * 快排尋找基準點位置 * * @param A * @param bt * @param ed * @return */ private static int pivotPartition(int A[], int bt, int ed) { // 取中間值作為stand，防止數組有序出現O(n^2)情況 swapVar(A, bt, ed); int stand = A[bt]; while (bt < ed) { while (bt < ed && A[ed] >= stand) { ed--; } if (bt < ed) { A[bt++] = A[ed]; } while (bt < ed && A[bt] <= stand) { bt++; } if (bt < ed) { A[ed--] = A[bt]; } } A[bt] = stand; return bt; } /** * 堆排序（從小到大） * * @param A * @param n */ public static void heapSort(int A[], int n) { int tmp; // 構建大根堆 buildMaxHeap(A, n); for (int j = n - 1; j >= 1; j--) { tmp = A[0]; A[0] = A[j]; A[j] = tmp; maxheapIfy(A, 0, j); } } /** * 構建大根堆 * * @param A * @param n */ private static void buildMaxHeap(int A[], int n) { for (int i = (n - 2) / 2; i >= 0; i--) { maxheapIfy(A, i, n); } } /** * 維護從下標i開始的最大堆 * * @param A * @param i * @param n */ private static void maxheapIfy(int A[], int i, int n) { int left, right, loc; while (i < n) { left = 2 * i + 1; right = 2 * i + 2; loc = i; if (left < n && A[left] > A[i]) { i = left; } if (right < n && A[right] > A[i]) { i = right; } if (loc != i) { A[i] = A[loc] ^ A[i]; A[loc] = A[loc] ^ A[i]; A[i] = A[loc] ^ A[i]; } else { break; } } } /** * 直接選擇排序 * * @param A * @param n */ public static void selectSort(int A[], int n) { int i, j, loc; for (i = 0; i < n; i++) { loc = i; for (j = i + 1; j < n; j++) { if (A[j] < A[loc]) { loc = j; } } if (loc != i) { A[i] = A[i] ^ A[loc]; A[loc] = A[i] ^ A[loc]; A[i] = A[i] ^ A[loc]; } } } /** * 直接插入排序 * * @param A * @param n */ public static void insertSort(int A[], int n) { int i, j, tmp; for (i = 1; i < n; i++) { tmp = A[i]; for (j = i - 1; j >= 0; j--) { if (A[j] > tmp) { A[j + 1] = A[j]; } else { break; } } A[j + 1] = tmp; } } /** * 冒泡排序 * * @param A * @param n */ public static void bubbleSort(int A[], int n) { int i, j; for (i = 0; i < n - 1; i++) { for (j = 0; j < n - i - 1; j++) { if (A[j] > A[j + 1]) { A[j] = A[j] ^ A[j + 1]; A[j + 1] = A[j] ^ A[j + 1]; A[j] = A[j] ^ A[j + 1]; } } } } /** * 打印數組 * * @param A */ public static void printArr(int A[]) { for (int i = 0; i < A.length; i++) { if (i == A.length - 1) { System.out.printf("%d\n", A[i]); } else { System.out.printf("%d ", A[i]); } } } } |
