歸併排序 遞歸and非遞歸

什麼是歸併排序

• 歸併排序其實就作兩件事： 
  
  1. 「分解」——將序列每次折半劃分。
  2. 「合併」——將劃分後的序列段兩兩合併後排序。

 

首先咱們來看一下分解是怎樣實現的呢？

 

1. // 遞歸退出條件，及left》=right的時候
2. if (left < right) {
3. // 找出中間索引
4. center = (left + right) / 2;
5. // 對左邊數組進行遞歸
6. mSort(k, 0, center);
7. // 對右邊數組進行遞歸
8. mSort(k, center + 1, right);
9. // 合併
10. merging(k, left, center, right);
11. }

 

接着合併是怎樣實現的呢？

1. 初始化一個數組，將左右數組的數進行比較，將較小的數存入中間數組
2. 再將左右數組剩下的數存到中間數組
3. 最後，將中間數組複製回原來的數組

 

1. private static void merging(int[] k, int left, int center, int right) {
2. int tempArr[] = new int[k.length];// 存放數據的數組
3. // third記錄中間數組的索引
4. int mid = center + 1;
5. int third = left;
6. int temp = left;
7. while (left <= center && mid <= right) {
8. // 從左右兩個數組找出最小的數存入tempArr數組
9. if (k[left] < k[mid]) {
10. tempArr[third++] = k[left++];
11. } else {
12. tempArr[third++] = k[mid++];
13. }
14. }
16. // 剩餘部分依次放入中間數組
17. while (mid <= right) {
18. tempArr[third++] = k[mid++];
19. }
21. while (left <= center) {
22. tempArr[third++] = k[left++];
23. }
24. // 將中間數組中的內容複製回原數組
25. while (temp <= right) {
26. k[temp] = tempArr[temp++];
27. }
28. }
30. }

 

遞歸版 的源碼實現以下

 

1. //下面是遞歸版的
2. package com.xujun.mergesort;
4. public class MergeSort {
6. static int[] a = new int[] { 20, 9, 3, 5, 26, 100, 8, -1, 7, 50, -5 };
8. public static void main(String[] args) {
9. System.out.println("before sort");
10. ArrayUtils.printArray(a);
11. mergeSort(a);
12. System.out.println("after sort");
13. ArrayUtils.printArray(a);
15. }
17. private static void mergeSort(int[] k) {
18. mSort(k, 0, k.length - 1);
19. }
21. private static void mSort(int[] k, int left, int right) {
22. int center
23. // 遞歸退出條件，及left》=right的時候
24. if (left < right) {
25. // 找出中間索引
26. center = (left + right) / 2;
27. // 對左邊數組進行遞歸
28. mSort(k, 0, center);
29. // 對右邊數組進行遞歸
30. mSort(k, center + 1, right);
31. // 合併
32. merging(k, left, center, right);
34. }
35. }
37. private static void merging(int[] k, int left, int center, int right) {
38. // 存放數據的數組
39. int tempArr[] = new int[k.length];
40. // third記錄中間數組的索引
41. int mid = center + 1;
42. int third = left;
43. int temp = left;
44. while (left <= center && mid <= right) {
45. // 從左右兩個數組找出最小的數存入tempArr數組
46. if (k[left] < k[mid]) {
47. tempArr[third++] = k[left++];
48. } else {
49. tempArr[third++] = k[mid++];
50. }
51. }
53. // 剩餘部分依次放入中間數組
54. while (mid <= right) {
55. tempArr[third++] = k[mid++];
56. }
58. while (left <= center) {
59. tempArr[third++] = k[left++];
60. }
61. // 將中間數組中的內容複製回原數組
62. while (temp <= right) {
63. k[temp] = tempArr[temp++];
64. }
65. }
67. }

 

下面說一下分遞歸版的實現思路

1. 從歸併段的長度爲1開始，一次使歸併段的長度變爲原來的2倍。
2. 在每趟歸併的過程當中，要注意處理歸併段的長度爲奇數和 最後一個歸併段的長度和前面的不等的狀況，須要作一下處理

 

1. // 程序邊界的處理很是重要
2. while (len <= t.length) {
3. for (int i = 0; i + len <= t.length - 1; i += len * 2) {
4. // System.out.println("len="+len);
5. low = i;
6. mid = i + len - 1;
7. high = i + len * 2 - 1;
8. if (high > t.length - 1)
9. high = t.length - 1;
10. merge(t, i, mid, high);
11. }
12. //長度加倍
13. len += len;
14. }
15. return true;
16. }

源碼以下：

 

1. package com.xujun.mergesort1;
3. public class MergeSort2 {
4. /**
5. * 二路歸併排序的遞歸算法-入口
6. *
7. * @param <T>
8. * @param t
9. * @return
10. */
11. public static <T extends Comparable> boolean mergeSortRecursive(T[] t) {
12. if (t == null || t.length <= 1)
13. return true;
15. MSortRecursive(t, 0, t.length - 1);
17. return true;
18. }
20. /**
21. * 二路歸併排序的遞歸算法-遞歸主體
22. *
23. * @param <T>
24. * @param t
25. * @param low
26. * @param high
27. * @return
28. */
29. private static <T extends Comparable> boolean MSortRecursive(T[] t,
30. int low, int high) {
31. if (t == null || t.length <= 1 || low == high)
32. return true;
34. int mid = (low + high) / 2;
35. MSortRecursive(t, low, mid);
36. MSortRecursive(t, mid + 1, high);
37. merge(t, low, mid, high);
39. return true;
40. }
43. public static <T extends Comparable> boolean mergeSortNonRecursive(T[] t) {
44. if (t == null || t.length <= 1)
45. return true;
47. int len = 1;
48. int low = 0;
49. int mid;
50. int high;
51. // 程序邊界的處理很是重要
52. while (len <= t.length) {
53. for (int i = 0; i + len <= t.length - 1; i += len * 2) {
54. // System.out.println("len="+len);
55. low = i;
56. mid = i + len - 1;
57. high = i + len * 2 - 1;
58. if (high > t.length - 1)
59. high = t.length - 1;
60. merge(t, i, mid, high);
61. }
62. //長度加倍
63. len += len;
64. }
65. return true;
66. }
68. /**
69. * 將兩個歸併段合併成一個歸併段
70. *
71. * @param <T>
72. * @param t
73. * @param low
74. * @param mid
75. * @param high
76. * @return
77. */
78. private static <T extends Comparable> boolean merge(T[] t, int low,
79. int mid, int high) {
80. T[] s = t.clone();// 先複製一個輔助數組
82. int i, j, k;// 三個指示器，i指示t[low...mid]，j指示t[mid+1...high]，k指示s[low...high]
83. for (i = low, j = mid + 1, k = low; i <= mid && j <= high; k++) {
84. if (t[i].compareTo(t[j]) <= 0) {
85. s[k] = t[i++];
86. } else {
87. s[k] = t[j++];
88. }
89. }
91. // 將剩下的元素複製到s中
92. if (i <= mid) {
93. for (; k <= high; k++) {
94. s[k] = t[i++];
95. }
96. } else {
97. for (; k <= high; k++) {
98. s[k] = s[j++];
99. }
100. }
101. for (int m = low; m <= high; m++) {// 將輔助數組中的排序好的元素複製回原數組
102. t[m] = s[m];
103. }
105. return true;
106. }
108. public static void main(String[] args) {
109. Integer[] arr = new Integer[] { 2, 3, 6, 8, 9, 2, 0, 1 };
110. long startTime = System.currentTimeMillis(); // 獲取開始時間
111. mergeSortRecursive(arr);
112. long endTime = System.currentTimeMillis(); // 獲取開始時間
113. System.out.println("執行時間：" + (endTime - startTime));
114. for (int i : arr) {
115. System.out.println(i);
116. }
117. startTime = System.currentTimeMillis(); // 獲取開始時間
118. mergeSortNonRecursive(arr);
119. endTime = System.currentTimeMillis(); // 獲取開始時間
120. System.out.println("執行時間：" + (endTime - startTime));
121. for (int i : arr) {
122. System.out.println(i);
123. }
124. }
125. }