Java汉诺塔课程设计程序

Java实现⼀个汉诺塔实战练习汉诺塔简介：我们想要实现的是让 A柱上的盘⼦，移动到C柱上1层汉诺塔2层汉诺塔3层汉诺塔详解图第⼀步第⼆步第三步第四步第五步第六步第七步经过上⾯的图解，相⽐⼤家⼀定在⼀定程度了解到汉诺塔的游戏规则，以及怎么去玩。

总之 最终C 柱上第⼀个盘⼦，是最⼤，最顶的是最⼩的，⽽且在操作过程中，前⼏步就是为了让三个柱⼦中最⼤的盘⼦移动到C 柱上，然后不断，将它两个柱⼦中最⼤盘⼦往上累加，（盘⼦从⼤到⼩，从下往上摆放）⽽且盘⼦⼀多，你就会发现过程中间，除了最⼤的盘⼦，其余的盘⼦都会集中在 B 柱上，这样才能把 A 柱上最底下也是最⼤的盘⼦，移动到C 上。

这是规律⼀还有⼀个规律，在最⼤的盘⼦移动C 柱上之后，第⼆个⼤的盘⼦要放在A 柱上，其余盘⼦按照规则全部放在B 柱上，这样第⼆⼤的盘⼦才能移动到最⼤的盘⼦上说⽩了，盘⼦再多，也要按照上⾯两个规律，才能完成整个游戏那我把最⼤盘⼦上⾯的所有盘⼦看成⼀个整体，放在B 柱上，最⼤盘⼦移动到C 柱上，把B柱上盘⼦直接盖上去，不就⾏了，反正也就是重复那两个规律⽽已程序如下123456import java.util.Scanner;public class Manuscript {static int times;// 移动次数public static void main(String[] args) {789101112131415161718192021222324252627282930Scanner scanner = newScanner(System.in);char A = 'A';char B = 'B';char C = 'C';int n = scanner.nextInt();game(n,A,B,C);scanner.close();} public static void move(int disk,char M,char N){ System.out.println("第"+(++times)+"次移动，盘⼦"+disk+" "+M +"---->"+N); }public static void game(int n,char A,char B,char C){if(n==1){move(n,A,C);// 把A 柱⽬前最⼤盘⼦放在C 柱上，第⼀次肯定最⼤的那个}else{ // 将 n-1 个 盘⼦ 放到B 柱⼦，注意ABC 位置，再看看下⾯ move(n,A,C);，细细琢磨 game(n-1,A,C,B);// A B(C) C(B) move(n,A,C);// 把n-1 个盘⼦ 放在C 上，注意ACB 位置game(n-1,B,A,C);// A(B) B(A) C } }}3层汉诺塔的输出结果附图（可以返回去看看，对⼀对）有什么疑问，可以在下⽅讨论，切记 不要⾃⼰带⼊⼀个特别⼤数字去展开，带⼊⼀个 1 ~3 ，了解规律就⾏。

汉诺塔递归算法java汉诺塔递归算法Java汉诺塔问题是计算机科学中经典的问题之一，它是一个递归问题，可以用递归算法来解决。

在这篇文章中，我们将介绍如何使用Java编写汉诺塔递归算法。

一、问题描述汉诺塔问题是一个经典的数学问题，它由三个塔和一些圆盘组成，这些圆盘按照从大到小的顺序放置在一个塔上。

问题的目标是将所有的圆盘从一个塔移动到另一个塔上，同时遵守以下规则：1. 每次只能移动一个圆盘；2. 圆盘只能放在比它大的圆盘上面。

二、递归算法递归算法是一种解决问题的方法，它通过将问题分解成更小的子问题来解决。

在汉诺塔问题中，我们可以使用递归算法来解决问题。

我们可以将汉诺塔问题分解成三个子问题：1. 将n-1个圆盘从A塔移动到B塔；2. 将第n个圆盘从A塔移动到C塔；3. 将n-1个圆盘从B塔移动到C塔。

这三个子问题可以使用递归算法来解决。

当n=1时，我们可以直接将圆盘从A塔移动到C塔。

三、Java代码实现下面是使用Java编写的汉诺塔递归算法代码：```public class HanoiTower {public static void main(String[] args) {int n = 3; // 圆盘的数量hanoi(n, 'A', 'B', 'C'); // 将n个圆盘从A塔移动到C塔}public static void hanoi(int n, char A, char B, char C) {if (n == 1) {System.out.println("将第" + n + "个圆盘从" + A + "塔移动到" + C + "塔");} else {hanoi(n - 1, A, C, B); // 将n-1个圆盘从A塔移动到B塔System.out.println("将第" + n + "个圆盘从" + A + "塔移动到" + C + "塔");hanoi(n - 1, B, A, C); // 将n-1个圆盘从B塔移动到C塔}}}```在这个代码中，我们定义了一个hanoi方法，它接受四个参数：n表示圆盘的数量，A、B、C表示三个塔的名称。

java汉诺塔详解及实现代码java 汉诺塔详解及实现代码实现效果图打印的⽅法在 moveTheTopOne() ⽅法中被调⽤，调⽤该⽅法前打印出移动的⽅向--从X号塔往Y号塔汉诺塔要求：将第⼀座塔上的所有盘⼦，借助第⼆座塔，全部搬运到第三座塔上。

规则：⼀次只能搬运⼀个盘⼦，不准将⼤盘⼦落在⼩盘⼦上。

汉诺塔实现代码：public class NewHanoi {public static int tiers = 4; // tiers 层数private static List<String> pagoda1 = new ArrayList<String>(); // 静态指针private static List<String> pagoda2 = new ArrayList<String>();private static List<String> pagoda3 = new ArrayList<String>();// 映射,⽤来确定并打印塔的序号(使⽤⾓标),也可以使⽤ Mapprivate static List[] mapping = {pagoda1, pagoda2, pagoda3};public static void main(String[] args) {preparePagoda(pagoda1, tiers);System.out.println("初始状态：");printPagodas();hanoi(tiers, pagoda1, pagoda2, pagoda3);System.out.println("最后结果：");printPagodas();}// --准备盘⼦(添加-字符串) (源塔)上private static void preparePagoda(List<String> srcPagoda, int tiers) {// ⽤于拼装塔层的容器StringBuilder builder = new StringBuilder();// 源塔的每⼀层加盘⼦，从底层开始, i ‘代表'盘⼦的直径⼤⼩，等于组成盘⼦的"^"个数for(int i = tiers; i > 0; i--){// 每⼀层由 2*tiers-1 个格⼦组成，代表盘⼦⼤⼩的"^"格⼦由空格隔开for(int k = 0; k < tiers - i; k++) builder.append(" "); // 盘⼦左边的空格，数量为 [2*tiers-1-(2*i-1)]/2 = tiers-i, 右边相同 for(int j = 1; j <= 2*i-1; j++){ // 盘⼦所占格数if(j % 2 == 1) builder.append("^"); // 间隔摆放else builder.append(" ");}for(int k = 0; k < tiers - i; k++) builder.append(" "); // 盘⼦右边的空格srcPagoda.add(builder.toString()); // 添加到塔上builder.delete(0, builder.length()); // 下⼀循环前清空容器}}// --打印塔的现状private static void printPagodas(){// 打印层数为三座塔-现状的最⼤⾼度int len = Math.max(pagoda1.size(), Math.max(pagoda2.size(), pagoda3.size()));// ⽤于-塔的空层显⽰StringBuilder spaces = new StringBuilder();spaces.append("-"); // --添加塔的左外框for(int i = 0; i < 2*tiers-1; i++) spaces.append(" "); // 空层显⽰⽤空格spaces.append("-\t"); // --添加塔的右外框和塔间间隔for(int i = len - 1; i >= 0; i--){ // 从顶层开始// 三座塔同⼀⽔平⾯的塔层放在同⼀⾏显⽰// 当某个塔不存在此层时，List.get(index)会抛⾓标越界异常，使⽤try-catch处理：此层显⽰⼀层空格try { System.out.print("-" + pagoda1.get(i) + "-\t");} catch (Exception e1) { System.out.print(spaces);}try { System.out.print("-" + pagoda2.get(i) + "-\t");} catch (Exception e) { System.out.print(spaces);}try { System.out.print("-" + pagoda3.get(i) + "-\t");} catch (Exception e) { System.out.print(spaces);}System.out.print("\r\n");}}// 这个⽅法(递归的核⼼⽅法)从指定的源塔上移动-指定数量的盘⼦-到指定的⽬标塔上public static void hanoi(int moveNum, List<String> from, List<String> middle, List<String> to) {if(moveNum == 1){ // 递归到移动⼀个盘⼦时，使⽤ move ⽅法moveTheTopOne(from, to);return;}// 将实现分为三步，⼀，将源塔底盘上⽅的所有盘⼦移⾄中间塔(递归)；⼆，将底盘移到⽬标塔；三，将中间塔上的所有盘⼦移到⽬标塔上(递归)。

攀枝花学院课程设计题目：汉诺塔演示程序设计院（系）：年级专业：姓名：学号：指导教师：二〇〇九年十二月十四日攀枝花学院教务处制攀枝花学院本科学生课程设计任务书注：任务书由指导教师填写。

课程设计（论文）指导教师成绩评定表摘要汉诺塔（又称河内塔）问题是一个古典的数学问题，是一个用递归方法解题的典型例子。

问题是这样的：开天辟地的神勃拉玛在一个庙里留下了三根金刚石的棒，第一根上面套着64个圆的金片，最大的一个在底下，其余一个比一个小，依次叠上去，庙里的众僧不倦地把它们一个个地从这根棒搬到另一根棒上，规定可利用中间的一根棒作为帮助，但每次只能搬一个，而且大的不能放在小的上面。

利用计算机图形学进行汉诺塔演示程序设计,是利用C语言绘图函数实现汉诺塔的递归算法图形界面演示过程。

通过C语言实现图形学的绘图，程序控制，以及区域填充，并根据汉诺塔的算法原理实现大小不同的盘子移动的全过程演示。

关键词汉诺塔，变换矩阵，种子填充算法，递归调用目录摘要 (I)1 需求分析 (1)1.1 需求概述 (1)1.2 需求环境 (1)1.3 功能描述 (2)2 概要设计 (3)2.1 程序功能模块 (3)2.2 程序流程图 (3)2.3 数据结构的设计 (4)3 详细设计 (5)3.1 程序初始化 (5)3.1.1 代码功能 (5)3.1.2 功能实现代码 (5)3.2 盘块的移动过程 (5)3.2.1代码功能 (5)3.2.2 功能实现代码 (5)3.3 递归函数 (6)3.3.1 流程图 (6)3.3.2 功能实现代码 (7)4 测试与运行 (8)结束语 (9)参考文献 (10)1 需求分析1.1 需求概述汉诺塔演示程序设计是计算机图形学中图形变换的内容之一。

而图形学中的图形变换的概念是由简单图形生成复杂图形，可用二维图形表示三维形体，甚至可以对静态图形经过快速变换而获得图形的动态显示效果。

其任务是研究各点坐标之间的变化规律。

而本次课程设计就是利用C语言以及图形函数实现汉诺塔的递归算法来进行其盘块移动的全过程显示。

数据结构学院：信息学院班级：计科高职13-2姓名：曲承玉学号：4044汉诺塔程序设计报告一、题目汉诺塔（Towers of Hanoi）问题二、设计要求1、在窗口中画出初始时塔和碟子的状态。

2、可以以自动或手动两种方式搬移碟子。

3、自动搬移可以通过定时器或多线程的方法，每一次移动的时间间隔可以自定，以人眼观察比较舒服为宜，每一次的移动过程如能实现动画最好。

4、定义塔的描述类和碟子的描述类。

5、在程序中，碟子的数目及每次移动的时间间隔可以通过对话框设置（也应该有默认值）。

6、支持暂停功和继续的功能（在自动搬移过程中可以暂停，并继续）。

7、暂停后，可以将当前的状态保存（碟子和塔的组合关系）。

8、可以从7中保存的文件中读出某个状态，并继续移动。

三、问题分析1、已知有三个塔（1、2、3）和n个从大到小的金碟子，初始状态时n个碟子按从大到小的次序从塔1的底部堆放至顶部。

2、要求把碟子都移动到塔2（按从大到小的次序从塔2的底部堆放至顶部）。

3、每次移动一个碟子。

4、任何时候、任何一个塔上都不能把大碟子放到小碟子的上面。

5、可以借助塔3。

（图1-1）图1-1首先考虑a杆下面的盘子而非杆上最上面的盘子，于是任务变成了：1、将上面的63个盘子移到b杆上；2、将a杆上剩下的盘子移到c杆上；3、将b杆上的全部盘子移到c杆上。

将这个过程继续下去，就是要先完成移动63个盘子、62个盘子、61个盘子....1个盘的工作。

四、算法选择汉诺塔程序设计算法的实质就是递归递归思想的运用。

现将其算法简述如下：为了更清楚地描述算法，可以定义一个函数hanoi(n,a,b,c)。

该函数的功能是：将n个盘子从塔a上借助塔b移动到塔c上。

这样移动n个盘子的工作就可以按照以下过程进行：1) hanoi(n-1,a,c,b);1n将速度调的很慢,当自动运行时,鼠标的一些2快速移动也会使画面的演示出问题。

2.自动搬移时若暂停后再保存退出则重新打开后可继续运行；但是在没有暂停的情况下保存退出，在打开后就不正常。

java递归实现汉诺塔步骤介绍汉诺塔的规则是:⼀共三根柱⼦,⼀根柱⼦从上到下套着有⼩到⼤的若⼲个圆盘,要将所有圆盘按照这个排放顺序移动到第三根柱⼦上,并且每次只能移动⼀个圆盘.可以将整个过程分为三个步骤来看:第⼀步:将除最⼤圆盘外的n-1个圆盘移动辅助柱⼦上第⼆步:将最⼤的圆盘移动到⽬标柱⼦第三步:将n-1个圆盘从辅助柱⼦移动到⽬标柱⼦其中第⼀步⼜可以拆成⼀模⼀样的三步,可以看成⼀个n-1层的塔要移动到⽬标柱⼦,只不过⽬标柱⼦换了⼀个:第三步也可以拆分成⼀模⼀样的三步:多拆⼏次就会发现规律:第⼀步和第三步⽆论如何拆成更⼩的汉诺塔,都只是⽬标柱和辅助柱发⽣调换,其他部分都是⼀模⼀样.所以我们将第⼀步和第三步进⾏递归运算就可以解决汉诺塔问题.static void hanNuo(int n,String A,String B,String C){if (n==1){System.out.println("把第"+n+"个从"+A+"移动到"+C);}else {hanNuo(n-1,A,C,B);System.out.println("把第"+n+"个从"+A+"移动到"+C);hanNuo(n-1,B,A,C);}}每进⼊⼀次递归塔的层数减⼀ ,由于第⼀步和第三步每拆分⼀次⽬标塔和辅助塔就会互换,同理,每进⼊⼀次递归也会将两个塔互换,因为第⼀步拆分⽬标塔是在塔⼆和塔三之间循环,所以我们在进⼊递归时也将传⼊代表"塔⼆"和"塔三"的参数互换,同理第三步也将互换代表"塔⼀"和"塔⼆"的参数.⽅法中的第⼆步由于第⼀步已经递归完成,所以可以直接使⽤打印语句进⾏输出.到此这篇关于java递归实现汉诺塔步骤介绍的⽂章就介绍到这了,更多相关java汉诺塔内容请搜索以前的⽂章或继续浏览下⾯的相关⽂章希望⼤家以后多多⽀持！。

汉诺塔—经典递归算法（java描述）汉诺塔：（又称河内塔）问题是源于印度一个古老传说的益智玩具。

大梵天创造世界的时候做了三根金刚石柱子，在一根柱子上从下往上按照大小顺序摞着64片黄金圆盘。

大梵天命令婆罗门把圆盘从下面开始按大小顺序重新摆放在另一根柱子上。

并且规定，在小圆盘上不能放大圆盘，在三根柱子之间一次只能移动一个圆盘。

整个算法要解决的是：将第一根柱子上的64个圆盘，借助第二根柱子，移到第三根柱子上，并确保小盘在大盘之上。

解决思路：（三根柱子设为X，Y，Z）1、先将前63个圆盘（看成一个圆盘）从X柱移到Y柱，确保大盘在小盘之下；（问题一）2、将第64个圆盘从X柱移到Z柱；3、再将前63个圆盘（看成一个圆盘）从Y柱移到Z柱，确保大盘在小盘之下。

（问题二）现在要解决：问题一：将X柱上的前63个圆盘，借助Z柱，移到Y柱上；问题二：将Y柱上的前63个圆盘，借助X柱，移到Z柱上；问题一的圆盘移动步骤：1、先将前62个圆盘，从X柱移到Z柱上；2、将第63个圆盘，从X柱移到Y柱上；3、在将前62个圆盘，从Z柱上移动到Y柱上。

问题二的圆盘移动步骤：1、先将前62个圆盘，从Y柱移到X柱；2、将第63个圆盘，从Y柱移到Z柱；3、再将前62个圆盘，从X柱移到Z柱。

从以上推导出推递归方法；问题一：1、先将前n-1个圆盘，从X柱移到Z柱；2、将第n个圆盘，从X柱移到Y柱；3、再将前n-1个圆盘，从Z柱移到Y柱。

问题二：1、先将前n-1个圆盘，从Y柱移到X柱；2、将第n个圆盘，从Y柱移到Z柱；3、再将前n-1个圆盘，从X柱移到Z柱。

主要代码思路(不能执行的)：hanoi(n-1,’X’,’Z’,’Y’);//将X柱上的前n-1个圆盘，借助Z柱，移到Y柱上（问题一）move(n,’X’,’Z’);//将第n个圆盘，从X柱移到Z柱hanoi(n-1,’Y’,’X’,’Z’);//将Y柱上的前n-1个圆盘，借助X柱，移到Z柱上（问题二）递归的持续机制：当n>1时退出机制：当n=1时具体实现代码(java)：import java.io.*;public class HanoiTowerDemo{public static void main(String[] args){try{BufferedReader br=new BufferedReader(new InputStreamReader(System.in));System.out.print("请输入汉诺塔总层数：");int n=Integer.parseInt(br.readLine());System.out.println("开始游戏，移动步骤是：");hanoi(n,'X','Y','Z');//将X柱上的n个圆盘，借助Y柱，移到Z柱}catch (Exception ex){}}/*功能：将X柱上的n个圆盘，借助Y柱，移到Z柱*/public static void hanoi(int n,char x,char y,char z){if(n==1)move(x,z); //将X柱上的圆盘移到Z柱上elseif(n>1){hanoi(n-1,x,z,y);//将X柱上的前n-1个圆盘，借助Z盘移到Y盘move(x,z);//将X柱上的圆盘移到Z柱上hanoi(n-1,y,x,z);//将Y柱上的前n-1个圆盘，借助X柱移到Z盘}}/*功能：将X柱上的圆盘移到Z柱上*/private static void move(char x,char z){System.out.println(x+" -> "+z);}}。

汉诺塔Java最重要两点：1.⼩盘⼦只能放在⼤盘⼦上2.第n项能⽤n-i项完整表达且第⼀步存在只有⼀个盘⼦的时候，只需要从将A塔上的⼀个盘⼦移到C塔上。

当A塔上有两个盘⼦是，先将A塔上的1号盘⼦（编号从上到下）移动到B塔上，再将A塔上的2号盘⼦移动的C塔上，最后将B塔上的⼩盘⼦移动到C塔上。

当A塔上有3个盘⼦时，先将A塔上编号1⾄2的盘⼦（共2个）移动到B塔上（需借助C塔），然后将A塔上的3号最⼤的盘⼦移动到C塔，最后将B塔上的两个盘⼦借助A塔移动到C塔上。

当A塔上有n个盘⼦是，先将A塔上编号1⾄n-1的盘⼦（共n-1个）移动到B塔上（借助C塔），然后将A塔上最⼤的n号盘⼦移动到C塔上，最后将B塔上的n-1个盘⼦借助A塔移动到C塔上。

综上所述，除了只有⼀个盘⼦时不需要借助其他塔外，其余情况均⼀样（只是事件的复杂程度不⼀样）。

编程思想分析：n是盘⼦的数量（1）n == 1第1次 1号盘 A---->C sum = 1 次(2) n == 2第1次 1号盘 A---->B第2次 2号盘 A---->C第3次 1号盘 B---->C sum = 3 次(3) n == 3 第1次 1号盘 A—->C 第2次 2号盘 A—->B 第3次 1号盘 C—->B 第4次 3号盘 A—->C 第5次 1号盘 B—->A 第6次 2号盘 B—->C 第7次 1号盘 A—->C sum = 7 次不难发现规律：1个圆盘的次数 2的1次⽅减12个圆盘的次数 2的2次⽅减13个圆盘的次数 2的3次⽅减1…..n个圆盘的次数 2的n次⽅减1故：移动次数为：2^n - 1算法分析 （1）把n-1个盘⼦由A 移到 B； （2）把第n个盘⼦由 A移到 C； （3）把n-1个盘⼦由B 移到 C；从这⾥⼊⼿，在加上上⾯数学问题解法的分析，我们不难发现，移到的步数必定为奇数步： （1）中间的⼀步是把最⼤的⼀个盘⼦由A移到C上去； （2）中间⼀步之上可以看成把A上n-1个盘⼦通过借助辅助塔（C塔）移到了B上， （3）中间⼀步之下可以看成把B上n-1个盘⼦通过借助辅助塔（A塔）移到了C上；代码：public class TxGame1 {/*** ⼀共⾛了多少步*/static int times;public static void main(String[] args) { char A = 'A'; char B = 'B'; char C = 'C'; System.out.println("汉诺塔游戏开始啦"); System.out.println("请输⼊盘⼦数："); Scanner s = new Scanner(System.in); int n = s.nextInt();//调⽤汉诺塔 hannoi(n, A, B, C); s.close();}/*** 盘移动*/public static void move(int disk, char M, char N ){ System.out.println("第"+(++times)+"次移动, 盘⼦"+disk+ " "+M+"------->"+N);}public static void hannoi(int n, char A, char B, char C){ if(n == 1){ move(n, A, C); }else{//移动上⼀关的步骤移动到B hannoi(n - 1, A, C, B);//把最⼤的盘⼦移动C塔 move(n, A, C);//再把B上的上⼀关的盘⼦移动到C上就可以了 hannoi(n - 1, B, A, C); }}}运⾏效果汉诺塔游戏开始啦请输⼊盘⼦数：3第1次移动, 盘⼦1 A------->C 第2次移动, 盘⼦2 A------->B 第3次移动, 盘⼦1 C------->B 第4次移动, 盘⼦3 A------->C 第5次移动, 盘⼦1 B------->A 第6次移动, 盘⼦2 B------->C 第7次移动, 盘⼦1 A------->C。

07141326汉诺塔-课程设计汉诺塔课程设计报告⽬录⼀、需求分析 (3)⼆、概要设计 (4)三、详细设计 (6)四、测试与分析 (7)五、总结 (7)六、附录：源程序清单 (8)⼀、需求分析1．1问题描述汉诺塔（⼜称河内塔）问题是印度的⼀个古⽼的传说。

开天辟地的神勃拉玛在⼀个庙⾥留下了三根⾦刚⽯的棒，第⼀根上⾯套着64个圆的⾦⽚，最⼤的⼀个在底下，其余⼀个⽐⼀个⼩，依次叠上去，庙⾥的众僧不倦地把它们⼀个个地从这根棒搬到另⼀根棒上，规定可利⽤中间的⼀根棒作为帮助，但每次只能搬⼀个，⽽且⼤的不能放在⼩的上⾯。

这是⼀个著名的问题，⼏乎所有的教材上都有这个问题。

由于条件是⼀次只能移动⼀个盘，且不允许⼤盘放在⼩盘上⾯，所以64个盘的移动次数是：18，446，744，073，709，551，615这是⼀个天⽂数字，若每⼀微秒可能计算(并不输出)⼀次移动，那么也需要⼏乎⼀百万年。

我们仅能找出问题的解决⽅法并解决较⼩N值时的汉诺塔，但很难⽤计算机解决64层的汉诺塔。

后来，这个传说就演变为汉诺塔游戏:1.有三根杆⼦A，B，C。

A杆上有若⼲圆盘2.每次移动⼀块圆盘，⼩的只能叠在⼤的上⾯3.把所有圆盘从A杆全部移到C杆上经过研究发现，汉诺塔的破解很简单，就是按照移动规则向⼀个⽅向移动圆盘：如3阶汉诺塔的移动：A→C，A→B，C→B，A→C，B→A，B→C，A→C此外，汉诺塔问题也是程序设计中的经典递归问题。

将n个盘⼦从a座移动到c座可以分解为以下3个步骤：（1）将a上n-1个盘借助c座先移到b座上。

（2）把a座剩下的⼀个盘移到c座上。

（3）将n-1个盘从c座借助于a座移到c座上。

1．2基本要求（1）输⼊的形式和输⼊值的范围：输⼊圆盘的数量，类型为整型，⼤于零。

（2）输出的形式：运⾏结果为⽤字母表⽰移动盘⼦的⽅案，⽽并⾮是真正移动盘⼦。

(3) 程序所能达到的功能；输⼊圆盘数量为定值时的移盘⽅案。

帮助我们更清晰的理解汉诺塔问题，及递归调⽤的应⽤。