前言
上一篇文章写了一个自顶向下的归并排序，把一个完整的数组不断二分，然后再合并。其实换一种思路：把数组中相邻的N个元素看成是已经二分好了的，直接进行合并，就省掉了二分那一步骤
C++实现:
|
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
|
template<typename T>
void mergeSortButton2Top(T arr[], int n) {
for (int size = 1; size <= n; size += size) {
for (int i = 0; i+size < n; i+=2*size) //对[i,i+size-1]和[i+size,i+2*size-1]进行归并
__merge(arr, i, i + size - 1, min(i + size + size - 1,n-1));// arr left mid right 如果i+2*size>n了，越界了，就取n-1
}
}
template<typename T>
void __merge(T arr[], int left, int mid, int right) { //将arr[left,mid] 和 arr[mid+1,right] 两部分进行归并
T *tmp=new T[right-left+1];
for (int i = left; i <= right; i++)
tmp[i - left] = arr[i]; //先把arr（需要合并的左右片段） 复制给tmp
int i = left, j = mid + 1; // i 做为左半部分的指针 j作为右半部分的指针
for (int k = left; k <= right; k++) {
if (i > mid) { // 左半部分 已经合入完了，将右半部分剩下的 全部合入
arr[k] = tmp[j - left];
j++;
}
else if (j > right) { // 右半部分 已经合入完了，将左半部分剩下的 全部合入
arr[k] = tmp[i - left];
i++;
}
else if (tmp[i - left] < tmp[j - left]) {
arr[k] = tmp[i - left];
i++;
}
else {
arr[k] = tmp[j - left];
j++;
}
}
delete[] tmp;
}
int main() {
int arr[9] = { 1,5,6,78,12,5,1,12,54 };
mergeSortButton2Top(arr,9);
for (int i = 0; i < 9; i++) {
cout << arr[i]<<" ";
}
return 0;
}
|
GoLang实现:
|
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
|
func mergeSortButton2Top(arr [] int) {
var lenth int = len(arr)
for size := 1; size <= lenth; size += size {
for i := 0; i+size < lenth; i += 2 * size { //对[i,i+size-1]和[i+size,i+2*size-1]进行归并
merge(arr, i, i+size-1, int(math.Min(float64(i+2*size-1), float64(lenth-1))))// arr left mid right 如果i+2*size>n了，越界了，就取n-1
}
}
}
func merge(arr []int, left, mid, right int) {
// 将要合并的部分做个拷贝
var tmp []int = make([]int, right-left+1)
for i, j := left, 0; i <= right; i++ {
tmp[j] = arr[i]
j++
}
// i做为左半部分的指针 j作为右半部分的指针
var i, j int = left, mid+1
for k := left; k <= right; k++ {
if i > mid { // 左半部分 已经合入完了，将右半部分剩下的 全部合入
arr[k] = tmp[j-left]
j++
} else if j > right { // 右半部分 已经合入完了，将左半部分剩下的 全部合入
arr[k] = tmp[i-left]
i++
} else if tmp[i-left] > tmp[j-left] {
arr[k] = tmp[j-left]
j++
} else {
arr[k] = tmp[i-left]
i++
}
}
}
|
用golang对两种归并排序进行计时，观察性能：
|
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
|
func createRandomArray(count int) []int {
rand.Seed(time.Now().UnixNano())
var arr [] int = make([]int, 0)
for i := 0; i < count; i++ {
arr = append(arr, rand.Intn(100))
}
return arr
}
func main() {
count := 10000
arr := createRandomArray(count)
var arr2 []int = make([]int, count)
copy(arr2, arr)
start := time.Now()
mergeSort(arr, 0, len(arr)-1)
fmt.Println("自顶向下归并排序 用时：", time.Since(start))
start = time.Now()
mergeSortButton2Top(arr2)
fmt.Println("自底向上归并排序 用时：", time.Since(start))
}
//输出：
//自顶向下归并排序 用时： 4.997ms
//自底向上归并排序 用时： 3.9987ms
|
因为自底向上少了二分那个步骤，性能要优于自顶向下的归并排序
总结
到此这篇关于C++/GoLang如何实现自底向上的归并排序的文章就介绍到这了,更多相关C++/GoLang自底向上的归并排序内容请搜索服务器之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持服务器之家！
原文链接：https://www.jianshu.com/p/57e432a7676e