① 求C汉诺塔递归详细过程
首先main函数调用hanoi(int n,char a,char b,char c)
此时，n=4,a=A,b=B,c=C。
然后hanoi(n-1,a,c,b)又开始调用函数hanoi(int n,char a,char b,char c)
此时，hanoi(n-1,a,c,b)中实参的值是这样的hanoi(4-1,A,C,B)
根据实参与形参对应关系， n=3,a=A,c=B,b=C。
剩下的类似这样。
② c语言算汉诺塔，递归时的输出是怎么一步一步来的如图，求大神帮忙
例如，n=3，三个柱子是ABC
那么是这样：
调用的层次已经用制表符分开
hanoi(3,A,B,C)=>
hanoi(2,A,C,B)=>
hanoi(1,A,B,C)
=>move(1,A,C)
move(A,B)
hanoi(1,C,A,B)
=>move(C,B)
move(A,C)
hanoi(2,B,A,C)=>
hanoi(1,B,C,A)=>
move(1,B,A)
move(B,C)
hanoi(1,A,B,C)=>
move(1,A,C)
③ c语言递归调用汉诺塔
//代码如下:
//说明:A,B,C为三个载体,起始,中间,目的载体为相对的,
//1.将n-1个盘子从起始载体通过目的载体,移动到中间载体
//2.只有最后一个盘子了.你需要将最后一个盘子从起始载体移到目的载体即可
//3.再将n-1个盘子从刚才的中间载体通过起始载体移动到目的载体.完成
//4.在递归时遇到只有1个盘子那直接从起始介质移到目的介质就OK了.
//自己用纸画画吧,不太好理解.明白了就不难了.
#include
#define
DISKA
"A"
#define
DISKB
"B"
#define
DISKC
"C"
void
move(int
num,char
*fromp,char
*mediump,char
*top);
void
mv(char
*fp,char
*tp);
int
main()
{
printf("please
input
the
num
of
disk:");
int
num;
scanf("%d",&num);
move(num,DISKA,DISKB,DISKC);
return
0;
}
void
move(int
num,char
*fromp,char
*mediump,char
*top)
{
if(num
==
1)
{
mv(fromp,top);//4
}
else
{
move(num-1,
fromp,
top,
mediump);//1
mv(fromp,top);//2
move(num-1,
mediump,
fromp,
top);//3
}
}
void
mv(char
*fp,char
*tp)
{
printf("%s--->%s\n",fp,tp);
}
④ 求C语言汉诺塔源码（递归和非递归都要）
递归算法是我前些天写的，非递归是刚才找的，里面含递归和非递归。
递归算法：
#include <stdio.h>
//递归求汉诺塔问题
void hanoi(int n, char A, char B, char C, int *time)
{
if (n>=1)
{
hanoi(n-1, A, C, B, time);
move(A, C);
(*time)++;
hanoi(n-1, B, A, C, time);
}
}
//打印出每一步的路径
void move(char a, char c)
{
printf(" %c-->%c\n", a, c);
}
int main(void)
{
int n, time = 0;;
printf("请输入汉诺塔的盘数:");
scanf("%d", &n);
printf("%d个盘的汉诺塔移动方法是：", n);
printf("\n");
hanoi(n, 'A', 'B', 'C', &time);
printf("移动了%d次\n", time);
system("pause");
return 0;
}
非递归算法：
#include <stdio.h>
#define MAXSTACK 10 /* 栈的最大深度 */
int c = 1; /* 一个全局变量，表示目前移动的步数 */
struct hanoi { /* 存储汉诺塔的结构，包括盘的数目和三个盘的名称 */
int n;
char x, y, z;
};
void move(char x, int n, char y) /* 移动函数，表示把某个盘从某根针移动到另一根针 */
{
printf("%d-> %d from %c -> %c\n", c++, n, x, y);
}
void hanoi(int n, char x, char y, char z) /* 汉诺塔的递归算法 */
{
if (1 == n)
move(x, 1, z);
else {
hanoi(n - 1, x, z, y);
move(x, n, z);
hanoi(n - 1, y, x, z);
}
}
void push(struct hanoi *p, int top, char x, char y, char z,int n)
{
p[top+1].n = n - 1;
p[top+1].x = x;
p[top+1].y = y;
p[top+1].z = z;
}
void unreverse_hanoi(struct hanoi *p) /* 汉诺塔的非递归算法 */
{
int top = 0;
while (top >= 0) {
while (p[top].n > 1) { /* 向左走到尽头 */
push(p, top, p[top].x, p[top].z, p[top].y, p[top].n);
top++;
}
if (p[top].n == 1) { /* 叶子结点 */
move(p[top].x, 1, p[top].z);
top--;
}
if (top >= 0) { /* 向右走一步 */
move(p[top].x, p[top].n, p[top].z);
top--;
push(p, top, p[top+1].y, p[top+1].x, p[top+1].z, p[top+1].n);
top++;
}
}
}
int main(void)
{
int i;
printf("递归:\n");
hanoi(3, 'x', 'y', 'z');
printf("非递归:\n");
struct hanoi p[MAXSTACK];
c = 1;
p[0].n = 3;
p[0].x = 'x', p[0].y = 'y', p[0].z = 'z';
unreverse_hanoi(p);
return 0;
}
⑤ 汉诺塔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语言编写的汉诺塔程序，是怎么实现递归的啊
我看你是不了解递归函数的具体是怎么实现的，我给你举一个简单的例子：就拿阶乘来说吧，
我给你把具体实现的过程画出来
当n=0时，就一步一步返回。这一点很重要。希望对你有帮助。
⑦ 谁给个C语言汉诺塔递归算法及其详细注释
源代码：
#include<stdio.h>
void movedisc(unsigned n,char fromneedle,char toneedle,char usingneedle);
int i=0;
int main()
{
unsigned n;
printf("please enter the number of locomotive:");
scanf("%d",&n); //输入N值
printf("\tneedle:\t a\t b\t c\n");
movedisc(n,'a','c','b'); //从A上借助B将N个盘子移动到C上
//*********************************************************************
//在此处加入如下代码将C上的N个盘子再移回A 去掉此处代码即汉诺塔问题源代码
for(int j=1;j<=(int)n;j++)
{
i++;
printf("\t[%d]:\t%2d<-------------%2d\n",i,j,j);
}
//*********************************************************************
printf("\tTotal:\t%d\n",i);
scanf("%d",&n);
return 0;
}
void movedisc(unsigned n,char fromneedle,char toneedle,char usingneedle)
{
if(n>0)
{
//从fromneedle上借助toneedle将N-1个盘子移动到usingneedle上
movedisc(n-1,fromneedle,usingneedle,toneedle);
++i;
//将fromneedle 上的一个盘子移到toneedle上
switch(fromneedle)
{
case 'a':
switch(toneedle)
{
case 'b':
printf("\t[%d]:\t%2d----->%2d\n",i,n,n);
break;
case 'c':
printf("\t[%d]:\t%2d------------->%2d\n",i,n,n);
break;
}
break;
case 'b':
switch(toneedle)
{
case 'a':
printf("\t[%d]:\t%2d<-----%2d\n",i,n,n);
break;
case 'c':
printf("\t[%d]:\t\t%2d----->%2d\n",i,n,n);
break;
}
break;
case 'c':
switch(toneedle)
{
case 'a':
printf("\t[%d]:\t%2d<-------------%2d\n",i,n,n);
break;
case 'b':
printf("\t[%d]:\t\t%2d<-----%2d\n",i,n,n);
break;
}
break;
}
//从usingneedle上借助fromneedle将N-1个盘子移动到toneedle上
movedisc(n-1,usingneedle,toneedle,fromneedle);
}
}
⑧ 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;
}
⑨ 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步
就像上面那样找个例子，反复的按照代码模拟计算机运行，过个五次六次，就会懂啦