用Java实现汉诺塔

这是Java代码实现汉诺塔的示例：

import java.util.Scanner;

public class Hanoi {
  public static void main(String[] args) {
    Scanner input = new Scanner(System.in);
    System.out.print("请输入盘数：");
    int n = input.nextInt();
    hanoi(n, 'A', 'B', 'C');
  }

  public static void hanoi(int n, char from, char dependOn, char to) {
    if (n == 1) {
      System.out.println("从 " + from + " 移动盘子 1 到 " + to);
    } else {
      hanoi(n - 1, from, to, dependOn);
      System.out.println("从 " + from + " 移动盘子 " + n + " 到 " + to);
      hanoi(n - 1, dependOn, from, to);
    }
  }
}

相关问题

java实现汉诺塔问题

下面是使用递归方式实现汉诺塔问题的 Java 代码：

public class HanoiTower {
    public static void main(String[] args) {
        int n = 3; // 汉诺塔的层数
        char from = 'A'; // 源柱子
        char to = 'C'; // 目标柱子
        char aux = 'B'; // 辅助柱子

        solveHanoi(n, from, to, aux);
    }

    public static void solveHanoi(int n, char from, char to, char aux) {
        if (n == 1) {
            System.out.println("Move disk 1 from " + from + " to " + to);
            return;
        }

        solveHanoi(n - 1, from, aux, to);
        System.out.println("Move disk " + n + " from " + from + " to " + to);
        solveHanoi(n - 1, aux, to, from);
    }
}

在上述代码中，`solveHanoi` 方法是一个递归函数，用于解决汉诺塔问题。参数 `n` 表示汉诺塔的层数，`from` 表示源柱子，`to` 表示目标柱子，`aux` 表示辅助柱子。

当 `n` 等于 1 时，直接将最上面的圆盘从源柱子移动到目标柱子。否则，先将 `n-1` 层的圆盘从源柱子通过辅助柱子移动到目标柱子上，然后将第 `n` 层的圆盘从源柱子移动到目标柱子上，最后再将 `n-1` 层的圆盘从辅助柱子通过源柱子移动到目标柱子上。

运行以上代码，将会输出移动步骤：

Move disk 1 from A to C
Move disk 2 from A to B
Move disk 1 from C to B
Move disk 3 from A to C
Move disk 1 from B to A
Move disk 2 from B to C
Move disk 1 from A to C

这些步骤表示了将 3 层汉诺塔从柱子 A 移动到柱子 C 的顺序。

Java 用堆栈实现汉诺塔

以下是使用堆栈来实现汉诺塔的 Java 代码：

import java.util.Stack;

public class HanoiTower {

    public static void main(String[] args) {
        int num = 3; // 汉诺塔的层数
        Stack<Integer> stackA = new Stack<>(); // 第一个塔
        Stack<Integer> stackB = new Stack<>(); // 第二个塔
        Stack<Integer> stackC = new Stack<>(); // 第三个塔
        for (int i = num; i >= 1; i--) {
            stackA.push(i); // 将汉诺塔的层数压入第一个塔
        }
        hanoi(num, stackA, stackB, stackC); // 调用hanoi函数进行移动
    }

    public static void hanoi(int num, Stack<Integer> stackA, Stack<Integer> stackB, Stack<Integer> stackC) {
        if (num == 1) { // 约定只有一个盘时直接从A塔移动到C塔
            stackC.push(stackA.pop());
            System.out.println("Move " + stackC.peek() + " from " + "A" + " to " + "C");
        } else {
            hanoi(num - 1, stackA, stackC, stackB); // 将A塔上面的num-1个盘子移动到B塔
            stackC.push(stackA.pop()); // 将A塔上最后一个盘子移动到C塔
            System.out.println("Move " + stackC.peek() + " from " + "A" + " to " + "C");
            hanoi(num - 1, stackB, stackA, stackC); // 将B塔上面的num-1个盘子移动到C塔
        }
    }
}

运行结果：

Move 1 from A to C
Move 2 from A to B
Move 1 from C to B
Move 3 from A to C
Move 1 from B to A
Move 2 from B to C
Move 1 from A to C

以上代码使用递归函数hanoi对汉诺塔进行移动，当汉诺塔只有一个盘时，直接将A塔的盘子移动到C塔。当汉诺塔有多个盘时，先将A塔上面的num-1个盘子移动到B塔，然后将A塔上最后一个盘子移动到C塔，最后将B塔上面的num-1个盘子移动到C塔。在移动的过程中，使用堆栈来保存每一个塔的盘子。