归并排序递归and非递归

最新推荐文章于 2023-12-09 16:22:40 发布

weixin_30709061

最新推荐文章于 2023-12-09 16:22:40 发布

阅读量65

点赞数

原文链接：http://www.cnblogs.com/he-px/p/7489464.html

版权

什么是归并排序

归并排序其实就做两件事：
1. “分解”——将序列每次折半划分。
2. “合并”——将划分后的序列段两两合并后排序。

首先我们来看一下分解是怎样实现的呢？

// 递归退出条件，及left》=right的时候
if (left < right) {
// 找出中间索引
center = (left + right) / 2;
// 对左边数组进行递归
mSort(k, 0, center);
// 对右边数组进行递归
mSort(k, center + 1, right);
// 合并
merging(k, left, center, right);
}

接着合并是怎样实现的呢？

初始化一个数组，将左右数组的数进行比较，将较小的数存入中间数组
再将左右数组剩下的数存到中间数组
最后，将中间数组复制回原来的数组

private static void merging(int[] k, int left, int center, int right) {
int tempArr[] = new int[k.length];// 存放数据的数组
// third记录中间数组的索引
int mid = center + 1;
int third = left;
int temp = left;
while (left <= center && mid <= right) {
// 从左右两个数组找出最小的数存入tempArr数组
if (k[left] < k[mid]) {
tempArr[third++] = k[left++];
} else {
tempArr[third++] = k[mid++];
}
}
// 剩余部分依次放入中间数组
while (mid <= right) {
tempArr[third++] = k[mid++];
}
while (left <= center) {
tempArr[third++] = k[left++];
}
// 将中间数组中的内容复制回原数组
while (temp <= right) {
k[temp] = tempArr[temp++];
}
}
}

递归版的源码实现如下

//下面是递归版的
package com.xujun.mergesort;
public class MergeSort {
static int[] a = new int[] { 20, 9, 3, 5, 26, 100, 8, -1, 7, 50, -5 };
public static void main(String[] args) {
System.out.println("before sort");
ArrayUtils.printArray(a);
mergeSort(a);
System.out.println("after sort");
ArrayUtils.printArray(a);
}
private static void mergeSort(int[] k) {
mSort(k, 0, k.length - 1);
}
private static void mSort(int[] k, int left, int right) {
int center
// 递归退出条件，及left》=right的时候
if (left < right) {
// 找出中间索引
center = (left + right) / 2;
// 对左边数组进行递归
mSort(k, 0, center);
// 对右边数组进行递归
mSort(k, center + 1, right);
// 合并
merging(k, left, center, right);
}
}
private static void merging(int[] k, int left, int center, int right) {
// 存放数据的数组
int tempArr[] = new int[k.length];
// third记录中间数组的索引
int mid = center + 1;
int third = left;
int temp = left;
while (left <= center && mid <= right) {
// 从左右两个数组找出最小的数存入tempArr数组
if (k[left] < k[mid]) {
tempArr[third++] = k[left++];
} else {
tempArr[third++] = k[mid++];
}
}
// 剩余部分依次放入中间数组
while (mid <= right) {
tempArr[third++] = k[mid++];
}
while (left <= center) {
tempArr[third++] = k[left++];
}
// 将中间数组中的内容复制回原数组
while (temp <= right) {
k[temp] = tempArr[temp++];
}
}
}

下面说一下分递归版的实现思路

从归并段的长度为1开始，一次使归并段的长度变为原来的2倍。
在每趟归并的过程中，要注意处理归并段的长度为奇数和最后一个归并段的长度和前面的不等的情况，需要做一下处理

// 程序边界的处理非常重要
while (len <= t.length) {
for (int i = 0; i + len <= t.length - 1; i += len * 2) {
// System.out.println("len="+len);
low = i;
mid = i + len - 1;
high = i + len * 2 - 1;
if (high > t.length - 1)
high = t.length - 1;
merge(t, i, mid, high);
}
//长度加倍
len += len;
}
return true;
}

源码如下：

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. }

转载于:https://www.cnblogs.com/he-px/p/7489464.html

weixin_30709061

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
归并排序递归and非递归

什么是归并排序归并排序其实就做两件事：“分解”——将序列每次折半划分。“合并”——将划分后的序列段两两合并后排序。首先我们来看一下分解是怎样实现的呢？// 递归退出条件，及left》=right的时候 if (left < right) { // 找出中间索引 center = (left + right) /...
复制链接

扫一扫