算法导论——分治法、归并排序——伪代码和Java实现

第二章第三节：分治法

    我们首先先介绍分治法。分治法的思想：将原问题分解为几个规模较小但类似于原问题的子问题，递归地求解这些子问题，然后在合并这些子问题的解来解决原问题的解。

    还是拿扑克牌举例子，假设桌上有两堆牌面朝上的牌(牌面朝上：有值)，每堆都已排序，最小的牌在顶上。我们希望把这两堆牌合并成单一的排好序的输出堆，牌面朝下地放在桌上。应该怎么做呢？
    我们的做法是：在牌面朝上的两堆牌的顶上两张牌中选取较小的一张，将该牌从其堆中移开(该堆的顶上将显示一张新牌)并牌面朝下地将该牌放置到输出堆。重复这个步骤直到两堆牌都没有牌。
    下面我们来实现上面所提的思想
    为了避免在某个基本步骤必须检查是否有堆为空。在每个堆的底部放置一张哨兵牌，它包含一个特殊的值(很大的值，使它不可能是较小的牌，除非两个堆都已显露出其哨兵牌。一旦发生这种情况，说明非哨兵牌都已被放置到输出堆)，用于简化代码。

伪代码：

MERGE(A,p,q,r)
n1 = q - p + 1
n2 = r - q
//L[1..n1+1] and R[1..n2+1]是新的数组
for i = 1 to n1
	L[i] = A[p + i -1]
for j = 1 to n2
	R[j] = A[q + j]
L[n1 + 1] = ∞
R[n2 + 1] = ∞
i = 1
j = 1
for k = p to r
	if L[i] <= R[j]
		A[k] = L[i]
		i = i + 1
	else 
		A[k] = R[j]
		j = j + 1

Java实现：

public void Merge(int[] A,int p,int q,int r){
        int n1 = q - p + 1;
        int n2 = r - q;

        //L[1..n1+1] and R[1..n2+1]是新的数组
        int[] L = new int[n1 + 1];
        int[] R = new int[n2 + 1];

        for (int i = 0;i < n1;i++){
            L[i] = A[p + i];
        }
        for (int j = 0;j < n2;j++){
            R[j] = A[q + j + 1];
        }

        L[n1] = Integer.MAX_VALUE;
        R[n2] = Integer.MAX_VALUE;

        int i = 0,j = 0;
        for (int k = p;k <= r;k++){
            if (L[i] <= R[j]){
                A[k] = L[i];
                i = i + 1;
            }else{
                A[k] = R[j];
                j = j + 1;
            }
        }
    }

    下面我们来看一下分治法的步骤
    对数组A[2,4,7,1,3,6]调用Merge(A,0,2,5)

初始状态↓

    初始完L和R数组之后，现在进入for循环阶段。让L中i所指的值和R数组中j所指的值进行比较，把较小的值放入数组A中k所指的位置。并且让较小的值的索引i或j前进一格(+1)。因为L和R数组已经从小到大排好序了，所以找出来的最小值一定是当前L和R数组的最小值，放入了数组A中也是排好序的，所以让k前进一步，k=k+1,然后执行下一次循环。
第一此循环：i和j初始为0，k=p=0，让L[0]与R[0]进行比较 L[0]>R[0]所以R[0]是较小值，把A[0]替换为R[0]。让j=j+1，i保持不变。k=k+1=1，开启下一次循环。本次循环结果如下图所示：
    A中的灰色位置包含将被覆盖的值，L和R中的灰色位置包含有待于被复制回A的值，A中的黄色位置包含它们的最终值，L和R中的黄色位置包含已被复制回A的值。

    第二次循环：此时i=0，j=1，k=1，让L[i]和R[j]进行比较，L[0]<R[1]，所以L[0]是较小值，把A[k]即A[1]替换为L[0]。让i=i+1，j保存不变。k=k+1=2，开启下一次循环。本次循环结果如下图所示：

    第三次循环：此时i=1，j=1，k=2，让L[i]和R[j]进行比较，L[1]>R[1]，所以R[1]是较小值，把A[2]即A[2]替换为R[1]。让j=j+1，i保存不变。k=k+1=3，开启下一次循环。本次循环结果如下图所示：

    第四次循环：此时i=1，j=2，k=3，让L[i]和R[j]进行比较，L[1]<R[2]，所以L[1]是较小值，把A[k]即A[3]替换为L[1]。让i=i+1，j保存不变。k=k+1=4，开启下一次循环。本次循环结果如下图所示：

    第五次循环：此时i=2，j=2，k=4，让L[i]和R[j]进行比较，L[2]>R[2]，所以R[2]是较小值，把A[k]即A[4]替换为R[2]。让j=j+1，j保存不变。k=k+1=4，开启下一次循环。本次循环结果如下图所示：
    注意：此时j已经到达了R数组的最后一个数∞，L数组中的每个数都比∞小，即不等式L[i]>R[j]恒成立。所以不管L剩下多少个数，都会按照顺序放置A中，直到i也达到了最后一个数∞，此时k>r，循环已经全部结束。
    第六次循环：此时i=2，j=3，k=5，让L[i]和R[j]进行比较，L[2]<R[3]，所以L[2]是较小值，把A[k]即A[5]替换为L[2]。让i=i+1，j保存不变。k=k+1=6，开启下一次循环。本次循环结果如下图所示：
    第七次循环，此时i=2，j=3，k=6，我们的r=5，判断条件k<=r为false，循环结束。

分治法的应用——归并排序

    上面讲到了分治法，分治法有个很大的限制就是L和R是排好序的才可以。但是许多数组都是很乱的顺序。那么怎么解决这个问题呢？试想一下如果L和R数组的大小为1，那么L和R数组肯定是排好序的。对的！我们可以把一个大的数组递归拆分成小的子数组，子数组在递归拆分成更小的子数组。直到递归到的L和R数组的大小为1时，调用MERGE分治法。随着算法自底向上地推进：合并只含1项的序列对形成长度为2的排好序的序列，合并长度为2的序列对形成长度为4的排好序的序列，依次下去，直到长度为n/2的两个序列被合并最终形成长度为n的排好序的序列，数组最终会排序完成。

如下图所示

    我们可以把上面提到的MERGE作为归并排序算法中的一个子程序来用。
    下面的过程MERGE-SORT(A,p,r)排序子数组A[p…r]中的元素。若p>=r,则该子数组最多有一个元素，所以已经排好序。否则，分解步骤简单地计算一个下标q，将A[p…r]分成两个子数组A[p…q]和A[q+1…r]，前者包含⌈n/2⌉个元素，后者包含⌊n/2⌋个元素。
伪代码：

MERGE-SORT(A,p,r)
if p < r
	q = ⌊(p+r)/2⌋
	MERGE-SORT(A,p,q)
	MERGE-SORT(A,q+1,r)
	MERGE(A,p,q,r)

java实现：

public void MergeSort(int[] A,int p,int r) {
        if (p < r){
            int q =(int)Math.floor((p+r)/2);	
            MergeSort(A,p,q);			//将左半边排序
            MergeSort(A,q+1,r);			//将右半边排序
            Merge(A,p,q,r);				//归并结果
        }
}

    下面我们来看一下归并排序在数组A=[5,2,4,7,1,3,2,6]上的操作，随着算法自底向上地推进，待合并的已排好序的各序列的长度不断增加。

‘-----------------------------------------------------------------’
    分治法的讲解到这里已经结束
    其他算法：算法导论——各章节算法伪代码和java实现