对于由n层以及ABC三个柱子的汉诺塔,要求得最少移动步数,过程往往有三步:
(1) 将前n-1层从A借由C移动到B
(2) 将第n层从A移动到C
(3) 将前n-1层从B借由A移动到C
递归方法:显然递归的过程如下:
Hanoi(n- 1, A, C, B);
Move(n,A, C);
Hanoi(n- 1, B, A, C);
迭代方法:同样,这里可以使用堆栈来替代递归方法,将迭代过程中的子状态使用数据结构如类或是数组来存储,然后使用堆栈来存储这些子状态,并在迭代变量变化以及迭代到n=1的移动状态时,再取出这些子状态的数据,就能够得到该移动操作的具体信息。而且堆栈的出入有迭代的变量所控制,也就能够像递归一样对各个子状态进行求解,只不过换成了循环迭代而已。
递归实现
package Hanoi;
public class HanoiRecursive {
public HanoiRecursive() {
// TODO Auto-generated constructor stub
}
public void Move(int n, char A, char C) {
System.out.println(n + ":" + A + "->" + C);
}
public void Hanoi(int n, char A, char B, char C) {
if (n == 1)
Move(n, A, C);
else {
Hanoi(n - 1, A, C, B);
Move(n, A, C);
Hanoi(n - 1, B, A, C);
}
}
}
迭代实现
package Hanoi;
import java.util.LinkedList;
import java.util.Scanner;
public class HanoiIterative {
public HanoiIterative() {
// TODO Auto-generated constructor stub
}
public void Move(int n, char A, char C) {
System.out.println(n + ":" + A + "->" + C);
}
public void Hanoi(int m, int n, char A, char B, char C) {
LinkedList<Object> linkedList = new LinkedList<Object>();
linkedList.push(new Object[] { m, n, A, B, C });
while (!linkedList.isEmpty()) {
Object[] data = (Object[]) linkedList.getFirst();
linkedList.pop();
if ((int) data[0] == 1) {
Move((int) data[1], (char) data[2], (char) data[4]);
} else {
linkedList.push(new Object[] { (int) data[0] - 1, (int) data[1] - 1, (char) data[3], (char) data[2],
(char) data[4] });
linkedList.push(new Object[] { 1, (int) data[1], (char) data[2], (char) data[3], (char) data[4] });
linkedList.push(new Object[] { (int) data[0] - 1, (int) data[1] - 1, (char) data[2], (char) data[4],
(char) data[3] });
}
}
}
public static void main(String[] args) {
int n;
Scanner scanner = new Scanner(System.in);
n = scanner.nextInt();
scanner.close();
HanoiIterative hanoiIterative = new HanoiIterative();
hanoiIterative.Hanoi(n, n, 'A', 'B', 'C');
System.out.println("===============");
HanoiRecursive hanoiRecursive = new HanoiRecursive();
hanoiRecursive.Hanoi(n, 'A', 'B', 'C');
}
}