c语言递归汉诺塔
㈠ c语言汉诺塔程序
将以下内容全部复制到新建的源文件中：（本人自己写的，因为你那课本上的代码，没解释，书写不规范，很难理解清楚，所以我直接新写了一个完整的代码，附带详细说明）
#include <stdio.h>
//汉诺塔x层塔从A塔整体搬到C塔，中间临时B塔。
//x层塔是从大到小往上叠放。每次移动只能移动一层塔。并且在移动过程中必须保证小层在上边
//借助B塔可以将x层塔全部从A搬到C上，并且符合要求（在移动过程中大的那块在下边，小的那块在上边）
int main()
{
void tower(int x,char a,char b,char c); //声明函数
int x=5,a='A',b='B',c='C'; //x表示有5层塔，具体要多少层自己修改这个值。abc分别表示ABC塔。
tower(x,a,b,c); //x层塔从a移动到c的全过程，主程序只有这条有效语句
return 0;
}
//以下是tower函数的定义
//参数解析：x层塔放在a上，b是中间塔，c是目标塔。即x层塔要从a搬到c上。
//此函数实现x层塔从a整体转移到c上。以及这个过程是怎么搬的全部过程。
void tower(int x,char a,char b,char c)
{
if(x==1)printf("将%d从%c放到%c\n",x,a,c); //只有1层塔时，直接从a搬到c上。
else //不止1层塔，则先将x-1层塔从a按照规律搬到b上，再将最后一块从a搬到c上，最后再将b上的x-1层塔按照规律搬到c上。
{
tower(x-1,a,c,b); //先将x-1层塔从a按照规律搬到b上，注意参数b放在最后，因为放在最后的参数是准备搬过去的目标塔。
printf("将%d从%c放到%c\n",x,a,c); //将最后一块从a搬到c上
tower(x-1,b,a,c); //最后再将b上的x-1层塔按照规律搬到c上，注意参数b放在开头，因为x-1层是要从b上搬过去的。
}
}
㈡ 求C汉诺塔递归过程详解
解决汉诺塔的基本思想是先把n个盘子除了最下面的盘子以外的所有盘子从第一根柱子（初始柱子）移动到中间那个柱子上（辅助柱子），然后把最下面的盘子移动到最后一根柱子上（目标柱子）。最后把剩下的盘子移动到目标柱子上。这样，然而，完成第一步和第三步也同样是一个移动n-1个盘子的汉诺塔问题。于是，递归调用在这里不可避免。程序你已经写的很清楚，给你解释一下。现把你的程序画上行以便说明。
1 #include "stdio.h"
2 main()
3 {void hanoi(int,char,char,char); <br/>4 int m; <br/>5 printf("input the number of disks:"); <br/>6 scanf("%d",&m); <br/>7 printf("The step to moving %d disks:\n",m); <br/>8 hanoi(m,'A','B','C'); <br/>9 }
10 void hanoi(int n,char a,char b,char c)
11 {//void move(char,char);
12 if(n==1) move(a,c);
13 else
14 {hanoi(n-1,a,c,b); <br/>15 move(a,c); <br/>16 hanoi(n-1,b,a,c); <br/>17 }
18 }
19 void move(char x,char y)
20 {printf("%c-->%c\n",x,y); <br/>21 }
当m=4时，程序走到第8行，调用函数hanoi(int n,char a,char b,char c)。此时，实参把值传递给了形参，于是此时，n=4,a=A,b=B,c=C。我把第11行的void move(char,char); 注释掉了，应该知道这一句的意思。因为这一行虽然可以让程序更加完整，但是解释的时候加上它会很麻烦。程序走到第12行，因为此时n=4,而不等于1，程序直接走第13行。于是调用第14行的hanoi(n-1,a,c,b)。这是一个递归调用。此时，n=3,a=A,c=B,b=C。要清楚，A，B，C代表的意义。A代表初始柱子，B代表辅助柱子，C代表目标柱子。而a代表第一根柱子,b代表第二根柱子,c代表第三根柱子。这是不一样的。程序继续走，到12行时n依然不等于1。走到14行调用hanoi(n-1,a,c,b)。此时，n=2,a=A,c=C,b=B。程序再走，到12行时n依然不等于1，走到14行调用hanoi(n-1,a,c,b)。此时，n=1,a=A,c=B,b=C。程序走到12行时发现n=1,程序开始走15行。调用move(char x,char y)到20行时输出A-->B。调用结束，回到上一个调用即n=2,a=A,c=C,b=B。程序回到第15行，输出 A-->B。再走第16行，调用hanoi(n-1,b,a,c)。此时n=1,b=A,a=B,c=C。程序回到12行再调用19行输出B-->C。调用结束，回到上一个调用n=3,a=A,c=B,b=C。程序走到15行，输出A-->C，这时，第一根柱子上有一个盘子，第二根柱子上有一个盘子，第三根柱子上有两个盘子。再调用16行就可以完成把第三根柱子里的所有盘子都移动到第二根柱子上。这样。我们就完成了整体目标的第一步。把n个盘子除了最下面的盘子以外的所有盘子从第一根柱子（初始柱子）移动到中间那个柱子上（辅助柱子），调用完成后程序回到15行，此时n=3,a=A,c=B,b=C。15行时输出A-->C，这时便完成了整体目标的第二步，最下面的盘子移动到最后一根柱子上（目标柱子）。再根据程序走到16行，经过跟14行类似的一系列的递归调用，我们就可以完成最终目标了。
㈢ c语言递归调用汉诺塔
首先调用 hanoi（3，a，b，c）
判断 “3”是否为“1”
不为“1”
{
{ 调用 hanoi(n-1, one, three, two)，即hanoi（2，a，c，b）
执行hanoi（2，a，c，b），此时 one = a，two = c，thtee = b;
判断 “2”是否为“1”，不为1
调用 hanoi(n-1, one, three, two)，即hanoi（1，a，b，c）
执行hanoi（1，a，b，c），此时 one = a，two = b，thtee = c;
判断 “1”是否为“1”，为1,执行move(one, three)即move(a, c)
以上为循环执行hanoi(n-1, one, three, two)函数，直到“n==1”
}
执行move(one, three);
执行hanoi(n-1, two, one, three)
{
循环执行hanoi(n-1, two, one, three)，直到“n==1”
}
}
主要是递归的用法
好像解释的不太清楚，但希望能帮到你。
㈣ 求大神讲解一下C语言汉诺塔递归算法的简易理解
一开始我接触汉诺塔也是很不解，随着代码量的积累，现在很容易就看懂了，因此楼主主要还是对递归函数的理解不够深刻，建议你多写一些递归程序，熟练了自己就能理解。
圆盘逻辑移动过程+程序递归过程分析
hanoi塔问题, 算法分析如下，设a上有n个盘子，为了便于理解我将n个盘子从上到下编号1-n，标记为盘子1，盘子2......盘子n。
如果n=1，则将“ 圆盘1 ” 从 a 直接移动到 c。
如果n=2，则：
（1）将a上的n-1（等于1）个圆盘移到b上，也就是把盘1移动到b上；
（2）再将a上 “盘2” 移到c上；
（3）最后将b上的n-1（等于1）个圆盘移到c上，也就是第（1）步中放在b上的盘1移动到c上。
注意：在这里由于超过了1个盘子，因此不能直接把盘子从a移动到c上，要借助b，那
么 hanoi（n，one，two，three）的含义就是由n个盘子，从one移动到three，如果n>2
那么就进行递归，如果n=1，那么就直接移动。
具体流程：
hanoi（2，a，b，c）；由于2>1因此进入了递归的环节中。
<1>执行hanoi（1，a，c，b）：这里就是刚才的步骤（1），代表借助c柱子，将a柱子上的 1个圆盘（盘1）移动到b柱子，其实由于是n=1，此时c柱子并没被用到，而是直接移动了。
<2>执行hanoi（1，a，b，c）：这是步骤（2），借助b柱子，将a柱子上的一个圆盘（盘2）移动到c柱子上。这里由于也是n=1，也并没有真正借助b柱子，直接移动的。
<3>执行hanoi（1，b，a，c）：这是步骤（3），将b上的一个盘子（盘1）移动到c
函数中由于每次调用hanoi的n值都是1，那么都不会进入递归中，都是直接执行了mov移动函数。
如果n=3，则：（倒着想会想明白）移动的倒数第二部，必然是下面的情况
（1）将a上的n`-1（等于2）个圆盘移到c上，也就是将盘1、盘2 此时都在b柱子上，只有这样才能移动最下面的盘子（盘3）。那么由于现在我们先忽略的最大的盘子（盘3），那么我们现在的目标就是，将两个盘子（盘1、盘2）从a柱子上，借助c柱 子，移动到b柱子上来，这个过程是上面n=2的时候的移动过程，n=2的移动过程是“2 个盘子，从柱子a，借助柱子b，移动到柱子c”。现在是“2个盘子，从柱子a，借助柱子 c，移动到柱子b上”。因此移动过程直接调用n=2的移动过程就能实现。
（2）将a上的一个圆盘（盘3）移到c。
（3）到这一步，由于已经将最大的盘子（盘3）移动到了目的地，此时无论后面怎么移动都不需要在用到最大的那个盘子（盘3），我们就先忽略他，剩下的目标就是将b上面的n-1个盘子（盘1、盘2）移动到c上，由于a上没有盘子了，此时要完成上面的目标，就要借助a盘子。最终达到的目标就是将b上的2个盘子，借助a移动到c上，这个过程就是当n=2时分析的过程了，仅仅是最开始的柱子（b柱子）和被借助的柱子（a柱子）不同了。所以直接调用n=2时候的过程就能股实现了。
具体执行过程：
hanoi（3，a，b，c）；由于3>1因此进入了递归的环节中。
<1>执行hanoi(2,a,c,b):这里代表刚才的步骤（1），将两个盘子（盘1、盘2）从a移动到b，中间借助c。根据n=2的分析过程，必然是能够达到我们的目的。
<2>执行hanoi（1，a，b，c）：现在a上只有一个盘子（盘3），直接移动到c上面即可。
<3>执行hanoi（2，b，a，c）：此时对应步骤（3），剩下的目标就是将b上的两个盘子，借助a移动到c上。那么同样根据n=2的移动过程，必然能达到目的。
最终实现了3个盘子从a，借助b移动到了c。
㈤ C语言函数递归调用汉诺塔问题
我一步步的给你讲，就会懂啦：
首先hanoi函数如果把当中的move函数给去掉，就变成了：
voidhanoi(intn,charone,chartwo,charthree)
{
if(n==1)
printf("%c->%c ",one,three);
else
{
hanoi(n-1,one,three,two);
printf("%c->%c ",one,three);
hanoi(n-1,two,one,three);
}
}
也就是把move(one,three)，变成了printf("%c->%c ", one, three);。少了一个函数，更加清晰
所以这里的hanoi函数就有了执行的内容：printf
下面以3个盘子为例进行模拟计算机的执行过程：
1、hanoi(3,A,B,C)，开始了这步，进入第一层函数，计算机在函数中会进行自我的再次调用（第7行代码）
2、（第7行）：hanoi(2,A,C,B)，于是这又是一个新的hanoi函数，这里我把它成为第二层函数
同样执行到第7行，卡住了，再次一次自我的调用
3、（进入第三层函数）：hanoi(1,A,B,C)，这里的第三层n=1，所以在第四行就显示出了"A->C"，至此，第三层函数结束，回到调用他的第二层函数
4、在第二层当中，继续第8行的内容，所以显示出"A->B"，继续运行，到第9行，开始了有一次自我调用
5、把她称为贰号第三层函数吧。。。hanoi(1,B,A,C)，和第3步类似，这一层函数显示出了"B->C"，然后结束函数，返回调用它的第二层函数
6、第二层函数执行完毕，返回调用它的第一层函数
7、第一层函数中执行到第8行，显示出"A->C",然后执行第9行：hanoi(2,B,A,C)
............
如果看到了这里理清楚了关系就会懂啦，接下来还有一半，如果都写下来就太复杂了-。-
你所说的空函数是指没有返回值，但是这里利用的是电脑调用函数的那种关系来解决的问题，比如上面的3步，会自动返回到第二层函数并继续
还可以这样理解汉诺塔，汉诺塔其实是将复杂的问题简单化，
先不管他有多少个盘子从A到C，我只把它视作3步
就像上面那样找个例子，反复的按照代码模拟计算机运行，过个五次六次，就会懂啦
㈥ c语言用递归实现汉诺塔
见代码注释，还有不懂可以问。
#include<stdio.h>
voidmove(charx,chary)
{
printf("%c-->%c ",x,y);
}
//hannuota函数的作用：把n个圆盘从one柱子借助two柱子放到three柱子
voidhannuota(intn,charone,chartwo,charthree)
{
if(n==1)//如果只有一个柱子
move(one,three);//直接移动即可
else
{
hannuota(n-1,one,three,two);//先把one柱子上的n-1个圆盘借助three柱子移动到柱子two
move(one,three);//把第一个柱子的剩下那一个(第n个)移动到第三个柱子
//由于原来one柱子上的n-1个圆盘已经移动到了two柱子上，因此不会有圆盘挡住n圆盘出来
hannuota(n-1,two,one,three);
//最后再把那n-1个圆盘从two柱子借助one柱子移动到three柱子
//(上面第一句话hannuota(n-1,one,three,two)已经移动到了two柱子，因此这里是从two柱子移动到three柱子)
}
}
intmain()
{
intm;
printf("inputthenumberofdiskes:");
scanf("%d",&m);
printf("Thesteptomove%ddiskes: ",m);
hannuota(m,'A','B','C');
return0;
}
㈦ 汉诺塔n=4(4个盘)c语言递归编程代码
/****************************
汉诺塔的算法就3个步骤：
第一，把a上的n-1个盘通过c移动到b。
第二，把a上的最下面的盘移到c。a成了空的。
第三，因为n-1个盘全在b上了，所以把b当做a.
重复以上步骤就好了。所以算法看起来就简单多了。
******************************/
#include<stdio.h>
staticintm=0;
voidmove(intn,chara,charb,charc)
{
if(n==1)
{
m++;
printf("第%d次移动: ",m);
printf(" %c->%c ",a,c);//当n只有1个的时候直接从a移动到c
}
else
{
move(n-1,a,c,b);//第n-1个要从a通过c移动到b
m++;
printf("第%d次移动: ",m);
printf(" %c->%c ",a,c);
move(n-1,b,a,c);//n-1个移动过来之后b变开始盘，b通过a移动到c，这边很难理解
}
}
intmain()
{
intn=4;
//printf("请输入要移动的块数：");
//scanf("%d",&n);
move(n,'a','b','c');
return0;
}
㈧ 求C语言汉诺塔源码（递归和非递归都要）
递归算法是我前些天写的，非递归是刚才找的，里面含递归和非递归。\x0d\x0a递归算法：\x0d\x0a#include \x0d\x0a//递归求汉诺塔问题\x0d\x0avoid hanoi(int n, char A, char B, char C, int *time)\x0d\x0a{\x0d\x0aif (n>=1)\x0d\x0a{\x0d\x0a hanoi(n-1, A, C, B, time);\x0d\x0a move(A, C);\x0d\x0a (*time)++;\x0d\x0a hanoi(n-1, B, A, C, time);\x0d\x0a }\x0d\x0a}\x0d\x0a//打印出每一步的路径\x0d\x0avoid move(char a, char c)\x0d\x0a{\x0d\x0aprintf(" %c-->%c\n", a, c);\x0d\x0a}\x0d\x0a\x0d\x0aint main(void)\x0d\x0a{\x0d\x0aint n, time = 0;;\x0d\x0aprintf("请输入汉诺塔的盘数:");\x0d\x0ascanf("%d", &n);\x0d\x0aprintf("%d个盘的汉诺塔移动方法是：", n);\x0d\x0aprintf("\n");\x0d\x0ahanoi(n, 'A', 'B', 'C', &time);\x0d\x0aprintf("移动了%d次\n", time);\x0d\x0asystem("pause");\x0d\x0areturn 0;\x0d\x0a}\x0d\x0a\x0d\x0a非递归算法：\x0d\x0a#include \x0d\x0a\x0d\x0a#define MAXSTACK 10 /* 栈的最大深度 */\x0d\x0a\x0d\x0aint c = 1; /* 一个全局变量，表示目前移动的步数 */\x0d\x0a\x0d\x0astruct hanoi { /* 存储汉诺塔的结构，包括盘的数目和三个盘的名称 */\x0d\x0aint n;\x0d\x0achar x, y, z;\x0d\x0a};\x0d\x0a\x0d\x0avoid move(char x, int n, char y) /* 移动函数，表示把某个盘从某根针移动到另一根针 */\x0d\x0a{\x0d\x0aprintf("%d-> %d from %c -> %c\n", c++, n, x, y);\x0d\x0a}\x0d\x0a\x0d\x0avoid hanoi(int n, char x, char y, char z) /* 汉诺塔的递归算法 */\x0d\x0a{\x0d\x0aif (1 == n)\x0d\x0amove(x, 1, z);\x0d\x0aelse {\x0d\x0ahanoi(n - 1, x, z, y);\x0d\x0amove(x, n, z);\x0d\x0ahanoi(n - 1, y, x, z);\x0d\x0a}\x0d\x0a}\x0d\x0a\x0d\x0avoid push(struct hanoi *p, int top, char x, char y, char z,int n)\x0d\x0a{\x0d\x0ap[top+1].n = n - 1;\x0d\x0ap[top+1].x = x;\x0d\x0ap[top+1].y = y;\x0d\x0ap[top+1].z = z;\x0d\x0a}\x0d\x0a\x0d\x0avoid unreverse_hanoi(struct hanoi *p) /* 汉诺塔的非递归算法 */\x0d\x0a{\x0d\x0aint top = 0;\x0d\x0a\x0d\x0awhile (top >= 0) {\x0d\x0awhile (p[top].n > 1) { /* 向左走到尽头 */\x0d\x0a push(p, top, p[top].x, p[top].z, p[top].y, p[top].n);\x0d\x0a top++;\x0d\x0a}\x0d\x0aif (p[top].n == 1) { /* 叶子结点 */\x0d\x0a move(p[top].x, 1, p[top].z);\x0d\x0a top--;\x0d\x0a}\x0d\x0aif (top >= 0) { /* 向右走一步 */\x0d\x0a move(p[top].x, p[top].n, p[top].z);\x0d\x0a top--;\x0d\x0a push(p, top, p[top+1].y, p[top+1].x, p[top+1].z, p[top+1].n);\x0d\x0a top++;\x0d\x0a}\x0d\x0a}\x0d\x0a}\x0d\x0a\x0d\x0aint main(void)\x0d\x0a{\x0d\x0aint i;\x0d\x0aprintf("递归:\n");\x0d\x0ahanoi(3, 'x', 'y', 'z');\x0d\x0aprintf("非递归:\n");\x0d\x0astruct hanoi p[MAXSTACK];\x0d\x0ac = 1;\x0d\x0ap[0].n = 3;\x0d\x0ap[0].x = 'x', p[0].y = 'y', p[0].z = 'z';\x0d\x0aunreverse_hanoi(p);\x0d\x0a\x0d\x0areturn 0;\x0d\x0a}