《数据结构与算法》之递归（3）

4、汉诺塔问题

汉诺塔问题是由很多放置在三个塔座上的盘子组成的一个古老的难题。如下图所示，所有盘子的直径是不同的，并且盘子中央都有一个洞使得它们刚好可以放在塔座上。所有的盘子刚开始都放置在A 塔座上。这个难题的目标是将所有的盘子都从塔座A移动到塔座C上，每次只可以移动一个盘子，并且任何一个盘子都不可以放置在比自己小的盘子之上。

递归算法为：

　　①、从初始塔座A上移动包含n-1个盘子到中介塔座B上。

　　②、将初始塔座A上剩余的一个盘子（最大的一个盘子）放到目标塔座C上。

　　③、将中介塔座B上n-1个盘子移动到目标塔座C上。

public class HanNuoTa {

	public static void main(String[] args) {
		move(3,"A","B","C");

	}
	/**
	 * 汉诺塔问题
	 * @param dish 盘子个数(也表示名称)
	 * @param from 初始塔座
	 * @param temp 中介塔座
	 * @param to   目标塔座
	 */
	public static void move(int dish,String from,String temp,String to){
	    if(dish == 1){
	        System.out.println("将盘子"+dish+"从塔座"+from+"移动到目标塔座"+to);
	    }else{
	        move(dish-1,from,to,temp);//A为初始塔座，B为目标塔座，C为中介塔座
	        System.out.println("将盘子"+dish+"从塔座"+from+"移动到目标塔座"+to);
	        move(dish-1,temp,from,to);//B为初始塔座，C为目标塔座，A为中介塔座
	    }
	}

}

 5、归并排序

归并算法的核心是归并两个已经有序的数组。归并两个有序数组A和B，就生成了第三个有序数组C。数组C包含数组A和B的所有数据项。

（1）非递归方法

public class GuiBingPaiXu {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int[] a = { 1, 3, 5, 7, 9 };
		int[] b = { 2, 4, 6, 8 };
		int[] c = sort(a, b);
		for (int i = 0; i < c.length; i++) {
			System.out.print(c[i]);
		}
		System.out.println();

	}

	/**
	 * 传入两个有序数组a和b，返回一个排好序的合并数组
	 * 
	 * @param a
	 * @param b
	 * @return
	 */
	public static int[] sort(int[] a, int[] b) {
		int[] c = new int[a.length + b.length];
		int aNum = 0, bNum = 0, cNum = 0;
		while (aNum < a.length && bNum < b.length) {
			if (a[aNum] >= b[bNum]) {// 比较a数组和b数组的元素，谁更小将谁赋值到c数组
				c[cNum++] = b[bNum++];
			} else {
				c[cNum++] = a[aNum++];
			}
		}
		// 如果a数组全部赋值到c数组了，但是b数组还有元素，则将b数组剩余元素按顺序全部复制到c数组
		while (aNum == a.length && bNum < b.length) {
			c[cNum++] = b[bNum++];
		}
		// 如果b数组全部赋值到c数组了，但是a数组还有元素，则将a数组剩余元素按顺序全部复制到c数组
		while (bNum == b.length && aNum < a.length) {
			c[cNum++] = a[aNum++];
		}
		return c;
	}

}

 该方法有三个while循环，第一个while比较数组a和数组b的元素，并将较小的赋值到数组c；第二个while循环当a数组所有元素都已经赋值到c数组之后，而b数组还有元素，那么直接把b数组剩余的元素赋值到c数组；第三个while循环则是b数组所有元素都已经赋值到c数组了，而a数组还有剩余元素，那么直接把a数组剩余的元素全部赋值到c数组。

 　　归并排序的思想是把一个数组分成两半，排序每一半，然后用上面的sort()方法将数组的两半归并成为一个有序的数组。如何来为每一部分排序呢？这里我们利用递归的思想：

　　把每一半都分为四分之一，对每个四分之一进行排序，然后把它们归并成一个有序的一半。类似的，如何给每个四分之一数组排序呢？把每个四分之一分成八分之一，对每个八分之一进行排序，以此类推，反复的分割数组，直到得到的子数组是一个数据项，那这就是这个递归算法的边界值，也就是假定一个数据项的元素是有序的。

（2）递归方法

public class GuiBing_DiGui {

	public static void main(String[] args) {
		int[] c = { 2, 7, 8, 3, 1, 6, 9, 0, 5, 4 };
		c = mergeSort(c, 0, c.length - 1);
		System.out.println(Arrays.toString(c));
	}

	public static int[] mergeSort(int[] c, int start, int last) {
		if (last > start) {
			int mid = start + (last - start) / 2;
			mergeSort(c, start, mid);// 左边数组排序
			mergeSort(c, mid + 1, last);// 右边数组排序
			merge(c, start, mid, last);// 合并左右数组
		}
		return c;
	}

	public static void merge(int[] c, int start, int mid, int last) {
		int[] temp = new int[last - start + 1];// 定义临时数组
		int i = start;// 定义左边数组的下标
		int j = mid + 1;// 定义右边数组的下标
		int k = 0;
		while (i <= mid && j <= last) {
			if (c[i] < c[j]) {
				temp[k++] = c[i++];
			} else {
				temp[k++] = c[j++];
			}
		}
		// 把左边剩余数组元素移入新数组中
		while (i <= mid) {
			temp[k++] = c[i++];
		}
		// 把右边剩余数组元素移入到新数组中
		while (j <= last) {
			temp[k++] = c[j++];
		}

		// 把新数组中的数覆盖到c数组中
		for (int k2 = 0; k2 < temp.length; k2++) {
			c[k2 + start] = temp[k2];
		}
	}

}