汉诺塔java递归_汉诺塔递归算法是什么

A. 汉诺塔递归算法是什么

汉诺塔（又称河内塔）问题是源于印度一个古老传说的益智玩具。大梵天创造世界的时候做了三根金刚石柱子，在一根柱子上从下往上按照大小顺序摞着64片黄金圆盘。大梵天命令婆罗门把圆盘从下面开始按大小顺序重新摆放在另一根柱子上。并且规定，在小圆盘上不能放大圆盘，在三根柱子之间一次只能移动一个圆盘。

注意：

我们在利用计算机求汉诺塔问题时，必不可少的一步是对整个实现求解进行算法分析。到目前为止，求解汉诺塔问题最简单的算法还是同过递归来求。

这里还必须有一个结束点，或者具体的说是在调用到某一次后函数能返回一个确定的值，接着倒数第二个就能返回一个确定的值，一直到第一次调用的这个函数能返回一个确定的值。

现这个算法可以简单分为三个步骤：

（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上。

B. 汉诺塔递归算法是什么

汉诺塔是经典递归问题：

相传在古印度圣庙中，有一种被称为汉诺塔(Hanoi)的游戏。该游戏是在一块铜板装置上，有三根杆(编号A、B、C)，在A杆自下而上、由大到小按顺序放置64个金盘。

游戏的目标：把A杆上的金盘全部移到C杆上，并仍保持原有顺序叠好。操作规则：每次只能移动一个盘子，并且在移动过程中三根杆上都始终保持大盘在下，小盘在上，操作过程中盘子可以置于A、B、C任一杆上。

如果A只有一个（A->C）。

如果A有两个（A->B）,(A->C),(B->C)。

如果A有三个（A->C）,(A->B),(C->B),(A->C),(B->A),(B->C),(A->C)。

如果更多，那么将会爆炸式增长。

递归：就是函数自己调用自己。子问题须与原始问题为同样的事，或者更为简单；递归通常可以简单的处理子问题，但是不一定是最好的。

其实递归在某些场景的效率是很低下的。尤其是斐波那契.从图你就可以发现一个简单的操作有多次重复。因为它的递归调用俩个自己。那么它的递归的膨胀率是指数级别的，重复了大量相同计算。

起源：

汉诺塔（又称河内塔）问题是源于印度一个古老传说的益智玩具。大梵天创造世界的时候做了三根金刚石柱子，在一根柱子上从下往上按照大小顺序摞着64片黄金圆盘。

大梵天命令婆罗门把圆盘从下面开始按大小顺序重新摆放在另一根柱子上。并且规定，在小圆盘上不能放大圆盘，在三根柱子之间一次只能移动一个圆盘。

C. 汉诺塔递归算法是什么

hanot (n-1,b,a,c);（解释：在把B塔上的(n-1))个借助A塔移动到C塔）

为了实现 n个盘从借助c 从a 移动到 b

思路如下：

首先考虑极限当只有一个盘的时候，盘直接从 a -> b即可。

当有2个盘的时候，把1号盘从a -> c 然后把2号盘 a->b 再把 2好盘从 c - > b。

当有n个盘的时候，把 n-1个盘借助 b 移动到 c 然后将 n号盘从 a -> b。

这时候只要将 n-1想办法从c移动到 b 借助 a 那么就可以先把 n-2个盘借助b移动到a。

递归，就是在运行的过程中调用自己。

构成递归需具备的条件：

1，子问题须与原始问题为同样的事，且更为简单；

2，不能无限制地调用本身，须有个出口，化简为非递归状况处理。

在数学和计算机科学中，递归指由一种（或多种）简单的基本情况定义的一类对象或方法，并规定其他所有情况都能被还原为其基本情况。

以上内容参考：网络-递归公式

D. java递归算法的例子。

阶乘：

要求：给定一个数值，计算出它的阶乘值，例如5的阶乘为5*4*3*2*1

实现：

[html] view plain

// 利用递归实现一个数的阶乘值 private static BigDecimal getNum(BigDecimal inNum) { if (inNum.compareTo(BigDecimal.ONE) == 0) { return inNum; } return inNum.multiply(getNum(inNum.subtract(BigDecimal.ONE))); }

（2）Fibonacci数列：1，1，2，3，5，8，13……

要求：找出数列中指定index位置的数值

实现：

[html] view plain

// 利用递归实现了Fibonacci数列 private static int fab(int index) { if (index == 1 || index == 2) { return 1; } else { return fab(index - 1) + fab(index - 2); } }

（3）汉诺塔

要求：汉诺塔挪动

实现：

[html] view plain

private static final String DISK_B = "diskB"; private static final String DISK_C = "diskC"; private static final String DISK_A = "diskA"; static String from=DISK_A; static String to=DISK_C; static String mid=DISK_B; public static void main(String[] args) { String input=JOptionPane.showInputDialog("please input the number of the disks you want me move."); int num=Integer.parseInt(input); move(num,from,mid,to); }

[html] view plain

// 利用递归实现汉诺塔 private static void move(int num, String from2, String mid2, String to2) { if (num == 1) { System.out.println("move disk 1 from " + from2 + " to " + to2); } else { move(num - 1, from2, to2, mid2); System.out.println("move disk " + num + " from " + from2 + " to " + to2); move(num - 1, mid2, from2, to2); } }

（4）排列组合

要求：将输入的一个字符串中的所有元素进行排序并输出，例如：你给出的参数是"abc"，

则程序会输出

abc

acb

bac

bca

cab

cba

实现：

[html] view plain

public static void permute(String str) { char[] strArray = str.toCharArray(); permute(strArray, 0, strArray.length - 1); }

[html] view plain

// 利用递归实现，将输入的一个字符串中的所有元素进行排序并输出 public static void permute(char[] list, int low, int high) { int i; if (low == high) { String cout = ""; for (i = 0; i <= high; i++) { cout += list[i]; } System.out.println(cout); } else { for (i = low; i <= high; i++) { char temp = list[low]; list[low] = list[i]; list[i] = temp; permute(list, low + 1, high); temp = list[low];

E. 如何用java实现汉诺塔中的递归

public class Hannuota {
private int n;//储存盘子个数
public Hannuota(int n){
this.n = n;
}
public void function(){
//初始化三个柱子，A是开始堆满盘子的柱子，C是目标柱子
Pillar a = new Pillar(n,n,"A");
Pillar b = new Pillar(n,"B");
Pillar c = new Pillar(n,"C");
//把三个柱子按顺序排好，详见后面的算法那里的解释
Pillar[] pillars = new Pillar[3];
pillars[0] = a;
if(n%2==0){
pillars[1] = b;
pillars[2] = c;
}else{
pillars[1] = c;
pillars[2] = b;
}
//开始移动，k用来计数，移动次数为2^n-1,至于为什么，我不太清楚，
//反正有人证明过。i是用来保存最小那个盘子正在哪跟柱子上的。
int i=0;
for(int k=0;k<(int)Math.pow(2, n)-1;){
int min;
//将最小的盘子顺时针移动一个柱子
min = pillars[i%3].Pop();
pillars[(i+1)%3].Push(min);
System.out.println(pillars[i%3]+"->"+pillars[(i+1)%3]);
k++;
i++;
//这个IF好像可以不要，当时写的，后面忘了删除。
if(k<(int)Math.pow(2, n)-1){
//如果，剩下两根柱子中，某一根为空，则一定是非空那根中最上面个盘子
//移动到空的那个柱子上。若两根都不为空，则把编号小的一个盘子
//移动到另外跟柱子上
if(!pillars[(i-1)%3].isEmpty()&&(pillars[(i+1)%3].isEmpty()||pillars[(i+1)%3].Top()>pillars[(i-1)%3].Top())){
min=pillars[(i-1)%3].Pop();
pillars[(i+1)%3].Push(min);
System.out.println(pillars[(i-1)%3]+"->"+pillars[(i+1)%3]);
}else{
min=pillars[(i+1)%3].Pop();
pillars[(i-1)%3].Push(min);
System.out.println(pillars[(i+1)%3]+"->"+pillars[(i-1)%3]);
}
k++;
}
}
}
//主函数，用来测试的。3表示3个盘子。
public static void main(String args[]){
new Hannuota(3).function();
}
}

class Pillar{//构造一个新类，表示柱子，实际是当一个栈在用
private int[] s;
private int top;
private String name;
public String toString(){
return name;
}
//这个构造函数用来构造BC两个柱子，下面那个用来构造柱子A。其实也可以写成一个构造函数。
public Pillar(int max,String name){
s = new int[max];
top = -1;
this.name = name;
for(int i=0;i<max;i++){
s[i] = max+1;
}
}
public Pillar(int n,int max,String name){
s = new int[max];
top = n-1;
this.name = name;
for(int i=0;i<max;i++){
s[i] = max - i;
}
}
//这后面这些就是栈的基本方法了，不用介绍了吧
public boolean isEmpty(){
return top==-1?true:false;
}
public int Top (){
return s[top];
}
public int Pop(){
return s[top--];
}
public void Push(int x){
s[++top] = x;
}
}
算法是这个
首先容易证明，当盘子的个数为n时，移动的次数应等于2^n - 1。
首先把三根柱子按顺序排成品字型，把所有的圆盘按从大到小的顺序放在柱子A上。
根据圆盘的数量确定柱子的排放顺序：若n为偶数，按顺时针方向依次摆放 A B C；
若n为奇数，按顺时针方向依次摆放 A C B。
（1）按顺时针方向把圆盘1从现在的柱子移动到下一根柱子，即当n为偶数时，若圆盘1在柱子A，则把它移动到B；
若圆盘1在柱子B，则把它移动到C；若圆盘1在柱子C，则把它移动到A。
（2）接着，把另外两根柱子上可以移动的圆盘移动到新的柱子上。
即把非空柱子上的圆盘移动到空柱子上，当两根柱子都非空时，移动较小的圆盘
这一步没有明确规定移动哪个圆盘，你可能以为会有多种可能性，其实不然，可实施的行动是唯一的。
（3）反复进行（1）（2）操作，最后就能按规定完成汉诺塔的移动。

这玩意要非递归真麻烦。需不需要加点注释？
其实我不明白干嘛非要非递归。。。

F. 汉诺塔递归算法是什么

汉诺塔递归算法是：f（n）=2^n-1。

汉诺塔，又称河内塔，是一个源于印度古老传说的益智玩具。大梵天创造世界的时候做了三根金刚石柱子，在一根柱子上从下往上按照大小顺序摞着64片黄金圆盘。

法国数学家爱德华·卢卡斯曾编写过一个印度的古老传说：在世界中心贝拿勒斯（在印度北部）的圣庙里，一块黄铜板上插着三根宝石针。印度教的主神梵天在创造世界的时候，在其中一根针上从下到上地穿好了由大到小的64片金片，这就是所谓的汉诺塔。

不论白天黑夜，总有一个僧侣在按照下面的法则移动这些金片：一次只移动一片，不管在哪根针上，小片必须在大片上面。僧侣们预言，当所有的金片都从梵天穿好的那根针上移到另外一根针上时，世界就将在一声霹雳中消灭，而梵塔、庙宇和众生也都将同归于尽。

不管这个传说的可信度有多大，如果考虑一下把64片金片，由一根针上移到另一根针上，并且始终保持上小下大的顺序。

这需要多少次移动呢？这里需要递归的方法。假设有n片，移动次数是f（n）显然f（1）等于1，f（2）等于3，f（3）=7，且f（k+1）=2*f（k）+1。此后不难证明f（n）=2^n-1。n=64时。

假如每秒钟一次，共需多长时间呢：一个平年365天有31536000 秒，闰年366天有31622400秒，平均每年31556952秒，计算一下：18446744073709551615秒。

这表明移完这些金片需要5845.54亿年以上，而地球存在至今不过45亿年，太阳系的预期寿命据说也就是数百亿年。真的过了5845.54亿年，不说太阳系和银河系，至少地球上的一切生命，连同梵塔、庙宇等，都早已经灰飞烟灭。

G. 汉诺塔递归算法是什么

如下：

1、汉诺塔（又称河内塔）问题是源于印度一个古老传说的益智玩具。大梵天创造世界的时候做了三根金刚石柱子，在一根柱子上从下往上按照大小顺序摞着64片黄金圆盘。

2、抽象为数学问题：从左到右有A、B、C三根柱子，其中A柱子上面有从小叠到大的n个圆盘，现要求将A柱子上的圆盘移到C柱子上去，期间只有一个原则：一次只能移到一个盘子且大盘子不能在小盘子上面，求移动的步骤和移动的次数。

算法分析（递归算法）：

实现这个算法可以简单分为三个步骤：把n-1个盘子由A 移到 B；把第n个盘子由 A移到 C；把n-1个盘子由B 移到 C。从这里入手，在加上上面数学问题解法的分析，我们不难发现，移到的步数必定为奇数步。

1、中间的一步是把最大的一个盘子由A移到C上去。

2、中间一步之上可以看成把A上n-1个盘子通过借助辅助塔（C塔）移到了B上。

3、中间一步之下可以看成把B上n-1个盘子通过借助辅助塔（A塔）移到了C上。

H. 汉诺塔递归算法是什么

汉诺塔问题实际上就是要将柱子A上由小到大排列的圆环按照相同的大小顺序移动到柱子C，之间的过程可以使用柱子B。

其递归的归纳思想是这样的：

（1）首先，当只有一个盘子的时候只需要将A上的1号盘子移动到C上就行了

（2）当有2个盘子在A上的时候，需要将A上的1号盘子（由上往下数）移动到B上，再将A上的2号盘子移动到C上，之后将B上的1号盘子移动到C上

（3）当有3个盘子在A上的时候，需要将A上的1号和2号盘子移动到B上（需要借助C），之后将A上的3号盘子移动到C上，再将B上的盘子移动到C上（需要借助A）

（...）以此类推

（N）当有N个盘子在A上的时候，需要将A上的N-1个盘子移动到B上（需要借助C），之后将A上的第N个盘子移动到C上，再将B上的盘子移动到C上（需要借助A）

起源

I. java递归解决汉诺塔时报错：类型 PrintStream 中的方法 println（boolean）对于参数（void）不适用。

System.out.println(f8(3, "A", "B", "C"));改为f8(3, "A", "B", "C");

J. 汉诺塔递归算法是什么

汉诺塔递归算法是算法分析。实现这个算法可以简单分为三个步骤:把n-1个盘子由A 移到 B;把第n个盘子由 A移到 C，把n-1个盘子由B 移到 C。

汉诺塔的来源及应用

汉诺塔问题是用递归方法求解的一个典型问题，在实际教学中，可以在传统教学方式的基础上，利用计算机辅助教学进行算法的模拟演示教学，使学生更容易接受和理解递归算法的思想，不但能提高学生的学习兴趣，而且还能取得较好的教学效果。

导航:首页 > 编程语言 > 汉诺塔java递归

汉诺塔java递归

注意：

与汉诺塔java递归相关的资料