归并排序

目前我掌握的排序算法有冒泡排序、插入排序、堆排序、快速排序，这几个排序算法的过程和思想包括时间复杂度我都能快速的讲出个1234来，唯独对归并排序理解的不够深入，这里重新学习一下归并排序

分治思想

将原问题分解为几个规模较小但类似于原问题的子问题，递归地求解这些子问题，然后再合并这些子问题的解建立原问题的解，归并排序完全遵循分治模式：

1. 分解：分解待排序的n个元素的序列成各具n/2个元素的两个子序列
2. 解决：使用归并排序递归地排序两个子序列
3. 合并：合并两个已排序的子序列以产生已排序的答案

归并排序算法

归并排序算法的关键操作是“合并”步骤中两个已排序序列的合并。我们通过调用一个辅助过程merge(A, p, q, r, T)来完成合并，其中A是一个数组，p，q，r是数组下标，满足p <= q < r， T是一个辅助数组空间。该过程假设子数组A[p..q]和A[q+1..r]都已排好序。它合并这两个子数组形成单一的已排好的子数组并代替当前的子数组A[p..r]n

过程merge需要O(n)的时间，其中n = r - p + 1是待合并元素的总数。

实现代码：

[cpp]  view plain copy

1. /** 
2.  * 将有二个有序数列a[first...mid]和a[mid...last]合并 
3.  */  
4. void merge(int *arr, int first, int mid, int end, int *temp)  
5. {  
6.     int i, j, k, m, n;  
7.     i = first;  
8.     j = mid + 1;  
9.     k = 0;  
10.   
11.     while (i <= mid && j <= end) {  
12.         if (arr[i] <= arr[j]) {  
13.             temp[k] = arr[i];  
14.         } else {  
15.             temp[k] = arr[j];  
16.         }  
17.         k ++;  
18.     }  
19.   
20.     while (i <= mid) {  
21.         temp[k ++] = arr[i ++];  
22.     }  
23.   
24.     while (j <= end) {  
25.         temp[k ++] = arr[j ++];  
26.     }  
27.   
28.     // 对arr重新赋值，合并  
29.     for (i = 0; i < k; i ++)   
30.         arr[first + i] = temp[i];  
31. }  

现在，我们可以过程merge作为归并排序算法中的一个子程序来用。下面的过程mereg_sort(A, p, r)排序子数组A[p...r]中的元素。若p >= r,则该子数组最多有一个元素，所以已经排好序。否则，分解步骤简单地计算一个下标q，将A[p...r]分成两个子数组A[p...q]和A[q...r],前者包含n / 2个元素，后者包含n / 2个元素

[cpp]  view plain copy

1. /** 
2.  * 归并排序递归过程 
3.  */  
4. void merge_sort(int *arr, int begin, int end, int *temp)  
5. {  
6.     int mid;  
7.     if (begin < end) {  
8.         mid = (begin + end) / 2;  
9.         merge_sort(arr, begin, mid, temp);  
10.         merge_sort(arr, mid + 1, end, temp);  
11.         merge(arr, begin, mid, end, temp);  
12.     }  
13. }  

写一个基础的归并排序代码，要求可以接收n组测试数据：

[cpp]  view plain copy

1. #include <stdio.h>  
2. #include <stdlib.h>  
3.   
4. /** 
5.  * 将有二个有序数列a[first...mid]和a[mid...last]合并 
6.  */  
7. void merge(int *arr, int first, int mid, int end, int *temp)  
8. {  
9.     int i, j, k;  
10.     i = first;  
11.     j = mid + 1;  
12.     k = 0;  
13.   
14.     while (i <= mid && j <= end) {  
15.         if (arr[i] <= arr[j]) {  
16.             temp[k] = arr[i ++];  
17.         } else {  
18.             temp[k] = arr[j ++];  
19.         }  
20.         k ++;  
21.     }  
22.   
23.     while (i <= mid) {  
24.         temp[k ++] = arr[i ++];  
25.     }  
26.   
27.     while (j <= end) {  
28.         temp[k ++] = arr[j ++];  
29.     }  
30.   
31.     // 对arr重新赋值，合并  
32.     for (i = 0; i < k; i ++)   
33.         arr[first + i] = temp[i];  
34. }  
35.   
36. /** 
37.  * 归并排序递归过程 
38.  */  
39. void merge_sort(int *arr, int begin, int end, int *temp)  
40. {  
41.     int mid;  
42.     if (begin < end) {  
43.         mid = (begin + end) / 2;  
44.         merge_sort(arr, begin, mid, temp);  
45.         merge_sort(arr, mid + 1, end, temp);  
46.         merge(arr, begin, mid, end, temp);  
47.     }  
48. }  
49.   
50. int main()  
51. {  
52.     int i, n, *arr, *temp;  
53.   
54.     while (scanf("%d", &n) != EOF) {  
55.         arr = (int *)malloc(sizeof(int) * n);  
56.         temp = (int *)malloc(sizeof(int) * n);  
57.   
58.         for (i = 0; i < n; i ++) {  
59.             scanf("%d", &arr[i]);  
60.         }  
61.   
62.         merge_sort(arr, 0, n - 1, temp);  
63.   
64.         for (i = 0; i < n; i ++)   
65.             printf("%d ", arr[i]);  
66.         printf("\n");  
67.   
68.         free(arr);  
69.         free(temp);  
70.     }  
71.   
72.     return 0;  
73. }  

截图：

过程分析（手写分析过程，图片未压缩）：

时间复杂度

归并排序的时间复杂度为O(nlgn),因为每次合并需要O(n)的时间复杂度，总共需要进行lg次（可以考虑成树的层数），因此为n * lgn

分享到：