分治法:分治法是将原问题分解成n个规模较小而结构与原问题相似的子问题,然后递归地解决这些子问题,然后再合并其结果,就得到原问题的解。
归并排序就采用了分治策略,首先将n个元素分成各含n/2个元素的子序列(2个子序列),使用归并排序法对两个子序列递归的排序,最后合并两个已排序的子序列得到最终结果。
归并排序的关键在于合并两个已排序的子序列,还是以扑克牌为例。假设有两堆牌面朝上的扑克牌,每一堆都是已排序的,最小的牌在最上面,最终结果是要将两堆牌合并成一个排好序的牌面朝下的扑克牌。基本步骤是选取两堆牌中最顶上两张牌中较小的一张,将其取出后面朝下的摆放在桌子上,重复这个步骤,知道某一堆牌为空为止,最后将一堆中剩余的牌面朝上的牌放置在牌面朝下的牌上。
合并步骤的伪代码如下:
A _ _ _ _ _ _ _ _
L 2 4 5 7 R 1 2 3 6
(a)
A 1 _ _ _ _ _ _ _
L 2 4 5 7 R 2 3 6
(b)
A 1 2 _ _ _ _ _ _
L 4 5 7 R 2 3 6
(c)
A 1 2 2 _ _ _ _ _
L 4 5 7 R 3 6
(d)
A 1 2 2 3 _ _ _ _
L 4 5 7 R 6
(e)
A 1 2 2 3 4 _ _ _
L 5 7 R 6
(f)
A 1 2 2 3 4 5 _ _
L 7 R 6
(h)
A 1 2 2 3 4 5 6 _
L 7 R
(i)
A 1 2 2 3 4 5 6 7
L R
合并过程c代码如下:
以上只是一个合并过程,下面的MERGE-SORT过程对子数组A[p..r]进行排序,如果p>=r,则说明该子数组中只有一个元素,当然是已排序的,否则分解子数组,直到只有一个元素为止,伪代码如下:
1 2 2 3 4 5 6 7
/ \
2 4 5 7 1 2 3 6
/ \ / \
2 5 4 7 1 3 2 6
/ \ / \ / \ / \
5 2 4 7 1 3 2 6
执行结果为:
3 1 0 4 6 2 9 8 7 5
0 1 2 3 4 5 6 7 8 9
归并排序就采用了分治策略,首先将n个元素分成各含n/2个元素的子序列(2个子序列),使用归并排序法对两个子序列递归的排序,最后合并两个已排序的子序列得到最终结果。
归并排序的关键在于合并两个已排序的子序列,还是以扑克牌为例。假设有两堆牌面朝上的扑克牌,每一堆都是已排序的,最小的牌在最上面,最终结果是要将两堆牌合并成一个排好序的牌面朝下的扑克牌。基本步骤是选取两堆牌中最顶上两张牌中较小的一张,将其取出后面朝下的摆放在桌子上,重复这个步骤,知道某一堆牌为空为止,最后将一堆中剩余的牌面朝上的牌放置在牌面朝下的牌上。
合并步骤的伪代码如下:
MERGE(A, p, q, r)
n1 <-- q - p + 1
n2 <-- r - q
create arrays L[1..n1] and R[1..n2]
for i <-- 1 to n1
do L[i] <-- A[p+i-1]
for j <-- 1 to n2
do R[j] <-- A[q+j]
i <-- 1
j <-- 1
for k <-- p to r
do if L[i] <= R[j]
then A[k] <-- L[i]
i <-- i + 1
else A[k] <-- R[j]
j <-- j + 1
例如:A _ _ _ _ _ _ _ _
L 2 4 5 7 R 1 2 3 6
(a)
A 1 _ _ _ _ _ _ _
L 2 4 5 7 R 2 3 6
(b)
A 1 2 _ _ _ _ _ _
L 4 5 7 R 2 3 6
(c)
A 1 2 2 _ _ _ _ _
L 4 5 7 R 3 6
(d)
A 1 2 2 3 _ _ _ _
L 4 5 7 R 6
(e)
A 1 2 2 3 4 _ _ _
L 5 7 R 6
(f)
A 1 2 2 3 4 5 _ _
L 7 R 6
(h)
A 1 2 2 3 4 5 6 _
L 7 R
(i)
A 1 2 2 3 4 5 6 7
L R
合并过程c代码如下:
void merge(int A[], int p, int q, int r)
{
int i, j, k;
int n1 = q - p + 1;
int n2 = r - q;
int L[n1];
int R[n2];
for (i = 0; i < n1; i++) {
L[i] = A[p+i];
}
for (j = 0; j < n2; j++) {
R[j] = A[q+1+j];
}
i = j = 0;
for (k = p; i < n1 && j < n2; k++) {
if (L[i] <= R[j]) {
A[k] = L[i++];
} else {
A[k] = R[j++];
}
}
for (; i < n1; i++, k++) {
A[k] = L[i];
}
for (; j < n2; j++, k++) {
A[k] = R[j];
}
}
解释一下上面的代码,变量p, q, r是数组A的下标,p是起始下标,r是结束下标,q是中间下标,相当于q将数组A分成了两个子数组。首先计算出两个子数组的长度为n1和n2,然后创建了两个子数组L和R,表示left和right,两个for循环将数组中A中到数据复制到子数组L和R中,再一个for循环合并数组L和R中的数据到数组A中,最后如果L或R有剩余的数据直接复制到数组A中,这就是整个归并程序的合并过程。以上只是一个合并过程,下面的MERGE-SORT过程对子数组A[p..r]进行排序,如果p>=r,则说明该子数组中只有一个元素,当然是已排序的,否则分解子数组,直到只有一个元素为止,伪代码如下:
MERGE-SORT(A, p, r)
if p < r
then q <-- (p+r) / 2
MERGE-SORT(A, p, q)
MERGE-SORT(A, q+1, r)
MERGE(A, p, q, r)
c代码如下:void merge_sort(int A[], int p, int r)
{
int q;
if (p < r) {
q = (p + r) / 2;
merge_sort(A, p, q);
merge_sort(A, q+1, r);
merge(A, p, q, r);
}
}
归并排序可由下图形象表示:1 2 2 3 4 5 6 7
/ \
2 4 5 7 1 2 3 6
/ \ / \
2 5 4 7 1 3 2 6
/ \ / \ / \ / \
5 2 4 7 1 3 2 6
归并排序完整代码如下:
#include <stdio.h>
void dump(int a[], int len)
{
int i;
for (i = 0; i < len; i++) {
printf("%3d", a[i]);
}
printf("\n");
}
void merge(int A[], int p, int q, int r)
{
int i, j, k;
int n1 = q - p + 1;
int n2 = r - q;
int L[n1];
int R[n2];
for (i = 0; i < n1; i++) {
L[i] = A[p+i];
}
for (j = 0; j < n2; j++) {
R[j] = A[q+1+j];
}
i = j = 0;
for (k = p; i < n1 && j < n2; k++) {
if (L[i] <= R[j]) {
A[k] = L[i++];
} else {
A[k] = R[j++];
}
}
for (; i < n1; i++, k++) {
A[k] = L[i];
}
for (; j < n2; j++, k++) {
A[k] = R[j];
}
}
void merge_sort(int A[], int p, int r)
{
int q;
if (p < r) {
q = (p + r) / 2;
merge_sort(A, p, q);
merge_sort(A, q+1, r);
merge(A, p, q, r);
}
}
int main(void)
{
int a[] = {3, 1, 0, 4, 6, 2, 9, 8, 7, 5};
int len = sizeof(a) / sizeof(a[0]);
dump(a, len);
merge_sort(a, 0, len-1);
dump(a, len);
return 0;
}
执行结果为:
3 1 0 4 6 2 9 8 7 5
0 1 2 3 4 5 6 7 8 9