Java各种排序算法汇总(冒泡,选择,归并,希尔及堆排序等)

这篇文章主要介绍了Java各种排序算法,以大量实例形式汇总分析了Java常用的各种排序算法,包括冒泡排序、快速排序、堆排序、插入排序、希尔排序、选择排序、归并排序等,需要的朋友可以参考下

本文实例汇总了Java各种排序算法。分享给大家供大家参考，具体如下：

1. 冒泡排序：

1. public class SortTest {  
2. public static void main(String[] args) {  
3. int[] a = {345,7,32,5,4,-1,3,12,23,110,45645,321,456,78,-1,78,78,32,444,345};  
4. show(a);  
5. bubbleSort(a);  
6. show(a);  
7. }  
8. private static void bubbleSort(int[] a) {  
9. for(int i=0;i<a.length-1;i++){  
10. for(int j=0;j<a.length-i-1;j++){  
11. if(a[j]>a[j+1]){  
12. int tmp = a[j];  
13. a[j] = a[j+1];  
14. a[j+1] = tmp;  
15. }  
16. }  
17. }  
18. }  
19. private static void show(int[] a) {  
20. System.out.println(Arrays.toString(a));  
21. }  
22. } 

2. 快速排序(无重复值)：

1. public class SortTest {  
2. public static void main(String[] args) {  
3. int[] a = {345,7,32,5,4,3,12,23,110};  
4. show(a);  
5. quickSort(a,0,a.length-1);  
6. show(a);  
7. }  
8. private static void quickSort(int[] a, int start, int end) {  
9. if (start>=end)  
10. return;  
11. int i=start;  
12. int j=end;  
13. int index = start;  
14. while(i<j){  
15. while(a[j]>a[index]){  
16. j--;  
17. }  
18. index = swap(a,j,index);  
19. while(a[index]>a[i]){  
20. i++;  
21. }  
22. index = swap(a,i,index);  
23. }  
24. quickSort(a, start, index-1);  
25. quickSort(a, index+1, end);  
26. }  
27. private static int swap(int[] a, int n, int index) {  
28. int tmp = a[n];  
29. a[n] = a[index];  
30. a[index] = tmp;  
31. return n;  
32. }  
33. private static void show(int[] a) {  
34. System.out.println(Arrays.toString(a));  
35. }  
36. }  

3. 快速排序(可含重复值)

1. public class SortTest {  
2. public static void main(String[] args) {  
3. int[] a = {345,7,32,5,4,-1,3,12,23,110,45645,321,456,78,-1,78,78,32,345};  
4. show(a);  
5. quickSort2(a,0,a.length-1);  
6. show(a);  
7. }  
8. private static void quickSort2(int[] a, int start, int end) {  
9. if (start>=end)  
10. return;  
11. int i=start;  
12. int j=end;  
13. int index = end;  
14. while(i<j){  
15. while(a[j]>a[index]){  
16. j--;  
17. }  
18. if (j!=index && a[j]==a[index]){  
19. index = swap(a,--j,index);  
20. }else{  
21. index = swap(a,j,index);  
22. }  
23. while(a[index]>a[i]){  
24. i++;  
25. }  
26. if (i!=index && a[i]==a[index]){  
27. index = swap(a,++i,index);  
28. }else{  
29. index = swap(a,i,index);  
30. }  
31. }  
32. quickSort2(a, start, index-1);  
33. quickSort2(a, index+1, end);  
34. }  
35. private static int swap(int[] a, int n, int index) {  
36. int tmp = a[n];  
37. a[n] = a[index];  
38. a[index] = tmp;  
39. return n;  
40. }  
41. private static void show(int[] a) {  
42. System.out.println(Arrays.toString(a));  
43. }  
44. }  

4. 堆排序

1. public class SortTest {  
2. public static void main(String[] args) {  
3. int[] a = {345,7,32,5,4,-1,3,12,23,110,45645,321,456,78,-1,78,78,32,444,345};  
4. show(a);  
5. heapSort(a);  
6. show(a);  
7. }  
8. private static void heapSort(int[] a) {  
9. //建立最大堆  
10. int size = a.length;  
11. for(int i=size/2-1;i>=0;i--){  
12. createBigHeap(a,i,size-1);  
13. }  
14. //排序  
15. for(int j=0;j<size-1;j++){  
16. int tmp=a[0];  
17. a[0]=a[size-1-j];  
18. a[size-1-j]=tmp;  
19. createBigHeap(a,0,size-2-j);  
20. }  
21. }  
22. private static void createBigHeap(int[] a, int start, int end) {  
23. int tmp = a[start];  
24. int j = 2*start+1;  
25. while(j<=end){  
26. if (j<end && a[j]<a[j+1]){  
27. j++;  
28. }  
29. if (a[j]>tmp){  
30. a[start] = a[j];  
31. start = j;  
32. j = 2*j+1;  
33. }else{  
34. break;  
35. }  
36. }  
37. a[start] = tmp;  
38. }  
39. private static void show(int[] a) {  
40. System.out.println(Arrays.toString(a));  
41. }  
42. }  

5. 插入排序

1. public class SortTest {  
2. public static void main(String[] args) {  
3. int[] a = {345,7,32,5,4,-1,3};  
4. show(a);  
5. insertSort(a);  
6. show(a);  
7. }  
8. private static void insertSort(int[] a) {  
9. for(int i=0;i<a.length-1;i++){  
10. int n = i+1;  
11. int tmp = a[n];  
12. for(int j=i;j>=0;j--){  
13. if(tmp<a[j]){  
14. a[n] = a[j];  
15. n=j;  
16. }  
17. }  
18. if (a[n]!=tmp)  
19. a[n] = tmp;  
20. }  
21. }  
22. private static void show(int[] a) {  
23. System.out.println(Arrays.toString(a));  
24. }  
25. }  

6. 折半插入排序

1. public class SortTest {  
2. public static void main(String[] args) {  
3. int[] a = {345,7,7,345,2,2,7,2,7,23,2,345,7,32,5,4,-1,3,7,2,3,2,3,4,2,1,2,4,5,3,345,3,2};  
4. show(a);  
5. insertSort2(a);  
6. show(a);  
7. }  
8. private static void insertSort2(int[] a) {  
9. for(int i=0;i<a.length-1;i++){  
10. int n = i+1;  
11. int tmp = a[n];  
12. if (tmp>a[i])  
13. continue;  
14. int low = 0;  
15. int high = i;  
16. int mid = (high+low)/2;  
17. while(high>=low){  
18. mid = (high+low)/2;  
19. if(tmp<a[mid]){  
20. high = mid -1;  
21. }else if(tmp>a[mid]){  
22. low = mid + 1;  
23. } else{  
24. low=mid;  
25. break;  
26. }  
27. }  
28. for(int j=n;j>mid;j--){  
29. a[j] = a[j-1];  
30. }  
31. a[low] = tmp;  
32. }  
33. }  
34. private static void show(int[] a) {  
35. System.out.println(Arrays.toString(a));  
36. }  
37. }  

7. 希尔排序

1. public class SortTest {  
2. public static void main(String[] args) {  
3. int[] a = {345,7,32,5,4,-1,3,2,3,5,7,8,90,1};  
4. show(a);  
5. shellSort(a);  
6. show(a);  
7. }  
8. private static void shellSort(int[] a) {  
9. shellSort(a,a.length);  
10. }  
11. private static void shellSort (int[] a, int n){  
12. int i, j, k, temp, gap;  
13. int[] gaps = { 1,5,13,43,113,297,815,1989,4711,11969,27901,84801,  
14. 213331,543749,1355339,3501671,8810089,21521774,  
15. 58548857,157840433,410151271,1131376761,2147483647 };  
16. for (k=0; gaps[k]<n; k++);  
17. while (--k >= 0){  
18. gap = gaps[k];  
19. for (i=gap; i<n; i++){  
20. temp = a[i];  
21. j = i;  
22. while (j>=gap && a[j-gap]>temp){  
23. a[j] = a[j-gap];  
24. j = j-gap;  
25. }  
26. a[j] = temp;  
27. }  
28. }  
29. }  
30. private static void show(int[] a) {  
31. System.out.println(Arrays.toString(a));  
32. }  
33. }  

8. 选择排序

1. public class SortTest {  
2. public static void main(String[] args) {  
3. int[] a = {345,7,32,5,4,-1};  
4. show(a);  
5. selectSort(a);  
6. show(a);  
7. }  
8. private static void selectSort(int[] a) {  
9. for (int i = 0; i < a.length-1; i++) {  
10. int min = i;  
11. for (int j = i+1; j < a.length; j++) {  
12. if (a[j]<a[min])  
13. min = j;  
14. }  
15. if (min!=i){  
16. int tmp = a[i];  
17. a[i] = a[min];  
18. a[min] = tmp;  
19. }  
20. }  
21. }  
22. private static void show(int[] a) {  
23. System.out.println(Arrays.toString(a));  
24. }  
25. }  

9. 归并排序

1. public class SortTest {  
2. public static void main(String[] args) {  
3. int[] a = {345,7,32,5,4,-1,3,2,3,5,7,8,90,1,432,1};  
4. show(a);  
5. mergeSort(a);  
6. show(a);  
7. }  
8. private static void mergeSort(int[] a) {  
9. //找出中间值  
10. int mid = a.length/2;  
11. //申请空间存储中间索引以左的值  
12. int[] left = setValue(a,0,mid);  
13. if (left.length>1){//继续拆分左边，直到元素值为1个  
14. mergeSort(left);  
15. }  
16. //申请空间存储中间索引以右的值  
17. int[] right = setValue(a,mid,a.length);  
18. if (right.length>1){//继续拆分右边，直到元素值为1个  
19. mergeSort(right);  
20. }  
21. //将左右值合并  
22. merge(a,left,right);  
23. }  
24. private static void merge(int[] a , int[] left, int[] right) {  
25. int i=0,j=0,k=0;  
26. for(;i<left.length && j<right.length;){  
27. if (left[i]<right[j]){  
28. a[k++] = left[i++];  
29. }else{  
30. a[k++] = right[j++];  
31. }  
32. }  
33. for(;i<left.length;i++){  
34. a[k++] = left[i];  
35. }  
36. for(;j<right.length;j++){  
37. a[k++] = right[j];  
38. }  
39. }  
40. private static int[] setValue(int[] a, int start,int length) {  
41. int[] x = new int[length-start];  
42. for (int i = 0; i < x.length; i++) {  
43. x[i] = a[start++];  
44. }  
45. return x;  
46. }  
47. private static void show(int[] a) {  
48. System.out.println(Arrays.toString(a));  
49. }  
50. }  

汇总：

1. public class SortUtil {  
2. public final static int DESC = -1;  
3. public final static int ASC = 1;  
4. /**  
5. * 冒泡排序  
6. * @param a sort Array  
7. * @param sort SortUtil.ASC,SortUtil.DESC  
8. */ 
9. public static void bubbleSort(int[] a,int sort) {  
10. if (sort==ASC)  
11. bubbleSortAsc(a);  
12. else 
13. bubbleSortDesc(a);  
14. }  
15. public static void bubbleSortAsc(int[] a) {  
16. for(int i=0;i<a.length-1;i++){  
17. for(int j=0;j<a.length-i-1;j++){  
18. if(a[j]>a[j+1]){  
19. int tmp = a[j];  
20. a[j] = a[j+1];  
21. a[j+1] = tmp;  
22. }  
23. }  
24. }  
25. }  
26. public static void bubbleSortDesc(int[] a) {  
27. for(int i=0;i<a.length-1;i++){  
28. for(int j=0;j<a.length-i-1;j++){  
29. if(a[j]<a[j+1]){  
30. int tmp = a[j];  
31. a[j] = a[j+1];  
32. a[j+1] = tmp;  
33. }  
34. }  
35. }  
36. }  
37. // ----------------华-丽-的-功-能-分割-线-----------------------  
38. /**  
39. * 快速排序（不允许有重复值）  
40. *  
41. * @param a sort Array  
42. * @param sort SortUtil.ASC,SortUtil.DESC  
43. */ 
44. public static void quickNoRepeatSort(int[] a,int sort) {  
45. if (sort==ASC)  
46. quickNoRepeatSortAsc(a, 0, a.length-1);  
47. else 
48. quickNoRepeatSortDesc(a, 0, a.length-1);  
49. }  
50. private static void quickNoRepeatSortAsc(int[] a, int start, int end) {  
51. if (start >= end)  
52. return;  
53. int i = start;  
54. int j = end;  
55. int index = start;  
56. while (i < j) {  
57. while (a[j] > a[index]) {  
58. j--;  
59. }  
60. index = swap(a, j, index);  
61. while (a[index] > a[i]) {  
62. i++;  
63. }  
64. index = swap(a, i, index);  
65. }  
66. quickNoRepeatSortAsc(a, start, index - 1);  
67. quickNoRepeatSortAsc(a, index + 1, end);  
68. }  
69. private static void quickNoRepeatSortDesc(int[] a, int start, int end) {  
70. if (start >= end)  
71. return;  
72. int i = start;  
73. int j = end;  
74. int index = start;  
75. while (i < j) {  
76. while (a[j] < a[index]) {  
77. j--;  
78. }  
79. index = swap(a, j, index);  
80. while (a[index] < a[i]) {  
81. i++;  
82. }  
83. index = swap(a, i, index);  
84. }  
85. quickNoRepeatSortDesc(a, start, index - 1);  
86. quickNoRepeatSortDesc(a, index + 1, end);  
87. }  
88. /**  
89. * 快速排序（允许有重复值）  
90. *  
91. * @param a sort Array  
92. * @param sort SortUtil.ASC,SortUtil.DESC  
93. */ 
94. public static void quickSort(int[] a,int sort) {  
95. if (sort==ASC)  
96. quickSortAsc(a, 0, a.length-1);  
97. else 
98. quickSortDesc(a, 0, a.length-1);  
99. }  
100. private static void quickSortAsc(int[] a, int start, int end) {  
101. if (start >= end)  
102. return;  
103. int i = start;  
104. int j = end;  
105. int index = end;  
106. while (i < j) {  
107. while (a[j] > a[index]) {  
108. j--;  
109. }  
110. if (j != index && a[j] == a[index]) {  
111. index = swap(a, --j, index);  
112. } else {  
113. index = swap(a, j, index);  
114. }  
115. while (a[index] > a[i]) {  
116. i++;  
117. }  
118. if (i != index && a[i] == a[index]) {  
119. index = swap(a, ++i, index);  
120. } else {  
121. index = swap(a, i, index);  
122. }  
123. }  
124. quickSortAsc(a, start, index - 1);  
125. quickSortAsc(a, index + 1, end);  
126. }  
127. private static void quickSortDesc(int[] a, int start, int end) {  
128. if (start >= end)  
129. return;  
130. int i = start;  
131. int j = end;  
132. int index = end;  
133. while (i < j) {  
134. while (a[j] < a[index]) {  
135. j--;  
136. }  
137. if (j != index && a[j] == a[index]) {  
138. index = swap(a, --j, index);  
139. } else {  
140. index = swap(a, j, index);  
141. }  
142. while (a[index] < a[i]) {  
143. i++;  
144. }  
145. if (i != index && a[i] == a[index]) {  
146. index = swap(a, ++i, index);  
147. } else {  
148. index = swap(a, i, index);  
149. }  
150. }  
151. quickSortDesc(a, start, index - 1);  
152. quickSortDesc(a, index + 1, end);  
153. }  
154. private static int swap(int[] a, int n, int index) {  
155. int tmp = a[n];  
156. a[n] = a[index];  
157. a[index] = tmp;  
158. return n;  
159. }  
160. // ----------------华-丽-的-功-能-分割-线------------------ 
161. /**  
162. * 堆排序  
163. *  
164. * @param a sort Array  
165. * @param sort SortUtil.ASC,SortUtil.DESC  
166. */ 
167. public static void heapSort(int[] a,int sort){  
168. if (sort==ASC)  
169. heapSortAsc(a);  
170. else 
171. heapSortDesc(a);  
172. }  
173. public static void heapSortAsc(int[] a) {  
174. // 建立最大堆  
175. int size = a.length;  
176. for (int i = size / 2 - 1; i >= 0; i--) {  
177. createBigHeap(a, i, size - 1);  
178. }  
179. // 排序  
180. for (int j = 0; j < size - 1; j++) {  
181. int tmp = a[0];  
182. a[0] = a[size - 1 - j];  
183. a[size - 1 - j] = tmp;  
184. createBigHeap(a, 0, size - 2 - j);  
185. }  
186. }  
187. private static void createBigHeap(int[] a, int start, int end) {  
188. int tmp = a[start];  
189. int j = 2 * start + 1;  
190. while (j <= end) {  
191. if (j < end && a[j] < a[j + 1]) {  
192. j++;  
193. }  
194. if (a[j] > tmp) {  
195. a[start] = a[j];  
196. start = j;  
197. j = 2 * j + 1;  
198. } else {  
199. break;  
200. }  
201. }  
202. a[start] = tmp;  
203. }  
204. public static void heapSortDesc(int[] a) {  
205. // 建立最小堆  
206. int size = a.length;  
207. for (int i = size / 2 - 1; i >= 0; i--) {  
208. createSmallHeap(a, i, size - 1);  
209. }  
210. // 排序  
211. for (int j = 0; j < size - 1; j++) {  
212. int tmp = a[0];  
213. a[0] = a[size - 1 - j];  
214. a[size - 1 - j] = tmp;  
215. createSmallHeap(a, 0, size - 2 - j);  
216. }  
217. }  
218. private static void createSmallHeap(int[] a, int start, int end) {  
219. int tmp = a[start];  
220. int j = 2 * start + 1;  
221. while (j <= end) {  
222. if (j < end && a[j] > a[j + 1]) {  
223. j++;  
224. }  
225. if (a[j] < tmp) {  
226. a[start] = a[j];  
227. start = j;  
228. j = 2 * j + 1;  
229. } else {  
230. break;  
231. }  
232. }  
233. a[start] = tmp;  
234. }  
235. // ----------------华-丽-的-功-能-分割-线---------------------  
236. /**  
237. * 插入排序  
238. *  
239. * @param a sort Array  
240. * @param sort SortUtil.ASC,SortUtil.DESC  
241. */ 
242. public static void insertSort(int[] a,int sort){  
243. if (sort==ASC){  
244. insertSortAsc(a);  
245. }else{  
246. insertSortDesc(a);  
247. }  
248. }  
249. public static void insertSortAsc(int[] a) {  
250. for (int i = 0; i < a.length - 1; i++) {  
251. int n = i + 1;  
252. int tmp = a[n];  
253. for (int j = i; j >= 0; j--) {  
254. if (tmp < a[j]) {  
255. a[n] = a[j];  
256. n = j;  
257. }  
258. }  
259. if (a[n] != tmp)  
260. a[n] = tmp;  
261. }  
262. }  
263. public static void insertSortDesc(int[] a) {  
264. for (int i = 0; i < a.length - 1; i++) {  
265. int n = i + 1;  
266. int tmp = a[n];  
267. for (int j = i; j >= 0; j--) {  
268. if (tmp > a[j]) {  
269. a[n] = a[j];  
270. n = j;  
271. }  
272. }  
273. if (a[n] != tmp)  
274. a[n] = tmp;  
275. }  
276. }  
277. // ----------------华-丽-的-功-能-分割-线-------------------- 
278. /**  
279. * 折半插入排序  
280. *  
281. * @param a sort Array  
282. * @param sort SortUtil.ASC,SortUtil.DESC  
283. */ 
284. public static void halfInsertSort(int[] a,int sort){  
285. if (sort==ASC){  
286. halfInsertSortAsc(a);  
287. }else{  
288. halfInsertSortDesc(a);  
289. }  
290. }  
291. public static void halfInsertSortAsc(int[] a) {  
292. for (int i = 0; i < a.length - 1; i++) {  
293. int n = i + 1;  
294. int tmp = a[n];  
295. if (tmp > a[i])  
296. continue;  
297. int low = 0;  
298. int high = i;  
299. int mid = (high + low) / 2;  
300. while (high >= low) {  
301. mid = (high + low) / 2;  
302. if (tmp < a[mid]) {  
303. high = mid - 1;  
304. } else if (tmp > a[mid]) {  
305. low = mid + 1;  
306. } else {  
307. low = mid;  
308. break;  
309. }  
310. }  
311. for (int j = n; j > mid; j--) {  
312. a[j] = a[j - 1];  
313. }  
314. a[low] = tmp;  
315. }  
316. }  
317. public static void halfInsertSortDesc(int[] a) {  
318. for (int i = 0; i < a.length - 1; i++) {  
319. int n = i + 1;  
320. int tmp = a[n];  
321. if (tmp < a[i])  
322. continue;  
323. int low = 0;  
324. int high = i;  
325. int mid = (high + low) / 2;  
326. while (high >= low) {  
327. mid = (high + low) / 2;  
328. if (tmp > a[mid]) {  
329. high = mid - 1;  
330. } else if (tmp < a[mid]) {  
331. low = mid + 1;  
332. } else {  
333. low = mid;  
334. break;  
335. }  
336. }  
337. for (int j = n; j > mid; j--) {  
338. a[j] = a[j - 1];  
339. }  
340. a[low] = tmp;  
341. }  
342. }  
343. // ----------------华-丽-的-功-能-分割-线---------------------- 
344. /**  
345. * 希尔排序  
346. *  
347. * @param a sort Array  
348. * @param sort SortUtil.ASC,SortUtil.DESC  
349. */ 
350. public static void shellSort(int[] a,int sort){  
351. if (sort==ASC){  
352. shellSortAsc(a,a.length);  
353. }else{  
354. shellSortDesc(a,a.length);  
355. }  
356. }  
357. public static void shellSortAsc(int[] a, int n) {  
358. int i, j, k, temp, gap;  
359. int[] gaps = { 1, 5, 13, 43, 113, 297, 815, 1989, 4711, 11969, 27901,  
360. 84801, 213331, 543749, 1355339, 3501671, 8810089, 21521774,  
361. 58548857, 157840433, 410151271, 1131376761, 2147483647 };  
362. for (k = 0; gaps[k] < n; k++)  
363. ;  
364. while (--k >= 0) {  
365. gap = gaps[k];  
366. for (i = gap; i < n; i++) {  
367. temp = a[i];  
368. j = i;  
369. while (j >= gap && a[j - gap] > temp) {  
370. a[j] = a[j - gap];  
371. j = j - gap;  
372. }  
373. a[j] = temp;  
374. }  
375. }  
376. }  
377. public static void shellSortDesc(int[] a, int n) {  
378. int i, j, k, temp, gap;  
379. int[] gaps = { 1, 5, 13, 43, 113, 297, 815, 1989, 4711, 11969, 27901,  
380. 84801, 213331, 543749, 1355339, 3501671, 8810089, 21521774,  
381. 58548857, 157840433, 410151271, 1131376761, 2147483647 };  
382. for (k = 0; gaps[k] < n; k++)  
383. ;  
384. while (--k >= 0) {  
385. gap = gaps[k];  
386. for (i = gap; i < n; i++) {  
387. temp = a[i];  
388. j = i;  
389. while (j >= gap && a[j - gap] < temp) {  
390. a[j] = a[j - gap];  
391. j = j - gap;  
392. }  
393. a[j] = temp;  
394. }  
395. }  
396. }  
397. // ----------------华-丽-的-功-能-分割-线--------------------- 
398. /**  
399. * 选择排序  
400. *  
401. * @param a sort Array  
402. * @param sort SortUtil.ASC,SortUtil.DESC  
403. */ 
404. public static void selectSort(int[] a,int sort){  
405. if (sort==ASC){  
406. selectSortAsc(a);  
407. }else{  
408. selectSortDesc(a);  
409. }  
410. }  
411. public static void selectSortAsc(int[] a) {  
412. for (int i = 0; i < a.length - 1; i++) {  
413. int min = i;  
414. for (int j = i + 1; j < a.length; j++) {  
415. if (a[j] < a[min])  
416. min = j;  
417. }  
418. if (min != i) {  
419. int tmp = a[i];  
420. a[i] = a[min];  
421. a[min] = tmp;  
422. }  
423. }  
424. }  
425. public static void selectSortDesc(int[] a) {  
426. for (int i = 0; i < a.length - 1; i++) {  
427. int max = i;  
428. for (int j = i + 1; j < a.length; j++) {  
429. if (a[j] > a[max])  
430. max = j;  
431. }  
432. if (max != i) {  
433. int tmp = a[i];  
434. a[i] = a[max];  
435. a[max] = tmp;  
436. }  
437. }  
438. }  
439. // ----------------华-丽-的-功-能-分割-线--------------------- 
440. /**  
441. * 归并排序  
442. *  
443. * @param a sort Array  
444. * @param sort SortUtil.ASC,SortUtil.DESC  
445. */ 
446. public static void mergeSort(int[] a,int sort){  
447. // 找出中间值  
448. int mid = a.length / 2;  
449. // 申请空间存储中间索引以左的值  
450. int[] left = setValue(a, 0, mid);  
451. if (left.length > 1) {// 继续拆分左边，直到元素值为1个  
452. mergeSort(left,sort);  
453. }  
454. // 申请空间存储中间索引以右的值  
455. int[] right = setValue(a, mid, a.length);  
456. if (right.length > 1) {// 继续拆分右边，直到元素值为1个  
457. mergeSort(right,sort);  
458. }  
459. if (sort==ASC){  
460. mergeAsc(a, left, right);  
461. }else{  
462. mergeDesc(a, left, right);  
463. }  
464. }  
465. private static void mergeAsc(int[] a, int[] left, int[] right) {  
466. int i = 0, j = 0, k = 0;  
467. for (; i < left.length && j < right.length;) {  
468. if (left[i] < right[j]) {  
469. a[k++] = left[i++];  
470. } else {  
471. a[k++] = right[j++];  
472. }  
473. }  
474. for (; i < left.length; i++) {  
475. a[k++] = left[i];  
476. }  
477. for (; j < right.length; j++) {  
478. a[k++] = right[j];  
479. }  
480. }  
481. private static void mergeDesc(int[] a, int[] left, int[] right) {  
482. int i = 0, j = 0, k = 0;  
483. for (; i < left.length && j < right.length;) {  
484. if (left[i] > right[j]) {  
485. a[k++] = left[i++];  
486. } else {  
487. a[k++] = right[j++];  
488. }  
489. }  
490. for (; i < left.length; i++) {  
491. a[k++] = left[i];  
492. }  
493. for (; j < right.length; j++) {  
494. a[k++] = right[j];  
495. }  
496. }  
497. private static int[] setValue(int[] a, int start, int length) {  
498. int[] x = new int[length - start];  
499. for (int i = 0; i < x.length; i++) {  
500. x[i] = a[start++];  
501. }  
502. return x;  
503. }  
504. }  

希望本文所述对大家Java程序设计有所帮助。