汉诺塔递归算法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语言用递归实现汉诺塔

见代码注释，还有不懂可以问。

#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塔问题, 算法分析如下，设A上有n个盘子。
如果n=1，则将圆盘从A直接移动到C。
如果n=2，则：
（1）将A上的n-1（等于1）个圆盘移到B上；
（2）再将A上的一个圆盘移到C上；
（3）最后将B上的n-1（等于1）个圆盘移到C上。
如果n=3，则：
A）将A上的n-1（等于2，令其为n`）个圆盘移到B（借助于C），步骤如下：
（1）将A上的n`-1（等于1）个圆盘移到C上。
（2）将A上的一个圆盘移到B。
（3）将C上的n`-1（等于1）个圆盘移到B。
B）将A上的一个圆盘移到C。
C）将B上的n-1（等于2，令其为n`）个圆盘移到C（借助A），步骤如下：
（1）将B上的n`-1（等于1）个圆盘移到A。
（2）将B上的一个盘子移到C。
（3）将A上的n`-1（等于1）个圆盘移到C。到此，完成了三个圆盘的移动过程。

从上面分析可以看出，当n大于等于2时， 移动的过程可分解为三个步骤：第一步 把A上的n-1个圆盘移到B上；第二步 把A上的一个圆盘移到C上；第三步 把B上的n-1个圆盘移到C上；其中第一步和第三步是类同的。 当n=3时，第一步和第三步又分解为类同的三步，即把n`-1个圆盘从一个针移到另一个针上，这里的n`=n-1。

Hanoi塔问题中函数调用时系统所做工作

一个函数在运行期调用另一个函数时，在运行被调用函数之前，系统先完成3件事：

①将所有的实参、返回地址等信息传递给被调用函数保存。

②为被调用函数的局部变量分配存储区；

③将控制转移到被调用函数的入口。

从被调用函数返回调用函数前，系统也应完成3件事：

①保存被调用函数的结果；

②释放被调用函数的数据区；

③依照被调用函数保存的返回地址将控制转移到调用函数。

当有多个函数构成嵌套调用时，按照“后调用先返回”的原则（LIFO），上述函数之间的信息传递和控制转移必须通过“栈”来实现，即系统将整个程序运行时所需的数据空间安排在一个栈中，每当调用一个函数时，就为其在栈顶分配一个存储区，每当从一个函数退出时，就释放其存储区，因此当前运行函数的数据区必在栈顶。堆栈特点：LIFO，除非转移或中断，堆栈内容的存或取表现出线性表列的性质。正是如此，程序不要求跟踪当前进入堆栈的真实单元，而只要用一个具有自动递增或自动递减功能的堆栈计数器，便可正确指出最后一次信息在堆栈中存放的地址。

一个递归函数的运行过程类型于多个函数的嵌套调用，只是调用函数和被调用函数是同一个函数。因此，和每次调用相关的一个重要的概念是递归函数运行的“层次”。假设调用该递归函数的主函数为第0层，则从主函数调用递归函数为进入第1层；从第i层递归调用本函数为进入下一层，即i＋1层。反之，退出第i层递归应返回至上一层，即i－1层。为了保证递归函数正确执行，系统需设立一个“递归工作栈”，作为整个递归函数运行期间使用的数据存储区。每一层递归所需信息构成一个“工作记录”，其中包括所有实参、所有局部变量以及上一层的返回地址。每进入一层递归，就产生一个新的工作记录压入栈顶。每退出一层递归，就从栈顶弹出一个工作记录，则当前执行层的工作记录必是递归工作栈栈顶的工作记录，称这个记录为“活动记录”，并称指示活动记录的栈顶指针为“当前环境指针”。
P.S.代码如您写的。

㈣ 求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}

㈤ 用C语言代码来编写含汉诺塔问题,利用堆栈来实现.求代码

算法思想
对于汉诺塔问题，当只移动一个圆盘时，直接将圆盘从 A 针移动到 C 针。若移动的圆盘为 n(n>1)，则分成几步走：把 (n-1) 个圆盘从 A 针移动到 B 针（借助 C 针）；A 针上的最后一个圆盘移动到 C 针；B 针上的 (n-1) 个圆盘移动到 C 针（借助 A 针）。每做一遍，移动的圆盘少一个，逐次递减，最后当 n 为 1 时，完成整个移动过程。
因此，解决汉诺塔问题可设计一个递归函数，利用递归实现圆盘的整个移动过程，问题的解决过程是对实际操作的模拟。
程序代码
#include <stdio.h>
int main()
{
int hanoi(int,char,char,char);
int n,counter;
printf("Input the number of diskes：");
scanf("%d",&n);
printf("\n");
counter=hanoi(n,'A','B','C');
return 0;
}
int hanoi(int n,char x,char y,char z)
{
int move(char,int,char);
if(n==1)
move(x,1,z);
else
{
hanoi(n-1,x,z,y);
move(x,n,z);
hanoi(n-1,y,x,z);
}
return 0;
}
int move(char getone,int n,char putone)
{
static int k=1;
printf("%2d:%3d # %c---%c\n",k,n,getone,putone);
if(k++%3==0)
printf("\n");
return 0;
}

㈥ 汉诺塔c语言怎么解释 不懂每步具体说明

汉诺塔的一个经典案例就是用递归法解决问题
A、B、C三根柱子上放盘子
开始盘子都在A上
盘子必须按照小上打下的顺序放置
要求每次只能移动一个盘子
要将A上的盘子都移到B上。
分析：
设有n个盘子在A上，当n=1时
只要将盘子从A->B
即可
当n>1时此问题可分解为以下步骤
1>
把n-1个盘子从柱子A移到C
2>
把第n个盘子从A移到B
3>
把n-1个盘子从C移到B
这是具体的算法
如果你不懂递归的话
这个程序就不好懂。
我给出一个递归的算法实现，你看看
#include
"stdio.h"
int
Hanoi(char
x,char
y,char
z,int
n)
{
if(n==1)
//对应第一种可能
{
printf("1:
%c
->%c\n",x,y);
}
else
//对应第二种可能
{
Hanoi(x,z,y,n-1);
//第二种可能的第一中移动方法
printf("%d:
%c
->%c\n",n,x,y);
Hanoi(z,y,x,n-1);
//第二种可能的第二种移动方法
}
return
0;
}
int
main()
{
int
n;
printf("请输入汉诺塔的高度：");
scanf("%d",&n);
printf("移动方案是：(系数代表第几个盘子
从上往下计数)\n");
Hanoi('A','B','C',n);
return
0;
}
VC
6．0下编译成功！
这是典型的递归用法。
你看这个程序应该跟明确些。

㈦ 如何做一个C语言编程的汉诺塔游戏

#includex0dx0a void move(char x,char y)x0dx0a {x0dx0a printf("%c-->%c\n",x,y);x0dx0a }x0dx0a void hanoi(int n,char one ,char two,char three)x0dx0a {x0dx0a if(n==1) move(one,three);x0dx0a elsex0dx0a {x0dx0a hanoi(n-1,one,three,two);x0dx0a move(one,three);x0dx0a hanoi(n-1,two,one,three);x0dx0a }x0dx0a }x0dx0a main()x0dx0a {x0dx0a int m;x0dx0a printf("input the number of disks:");x0dx0a scanf("%d",&m);x0dx0a printf("the step to moving %3d diskes:\n",m);x0dx0a hanoi(m,'A','B','C');x0dx0a }x0dx0a算法介绍：x0dx0a 其实算法非常简单，当盘子的个数为n时，移动的次数应等于2^n _ 1（有兴趣的可以自己证明试试看）。后来一位美国学者发现一种出人意料的简单方法，只要轮流进行两步操作就可以了。首先把三根柱子按顺序排成品字型，把所有的圆盘按从大到小的顺序放在柱子A上，根据圆盘的数量确定柱子的排放顺序：若n为偶数，按顺时针方向依次摆放 A B C；x0dx0a 若n为奇数，按顺时针方向依次摆放 A C B。x0dx0a （1）按顺时针方向把圆盘1从现在的柱子移动到下一根柱子，即当n为偶数时，若圆盘1在柱子A，则把它移动到B；若圆盘1在柱子B，则把它移动到C；若圆盘1在柱子C，则把它移动到A。x0dx0a （2）接着，把另外两根柱子上可以移动的圆盘移动到新的柱子上。即把非空柱子上的圆盘移动到空柱子上，当两根柱子都非空时，移动较小的圆盘。这一步没有明确规定移动哪个圆盘，你可能以为会有多种可能性，其实不然，可实施的行动是唯一的。x0dx0a （3）反复进行（1）（2）操作，最后就能按规定完成汉诺塔的移动。x0dx0a 所以结果非常简单，就是按照移动规则向一个方向移动金片：x0dx0a 如3阶汉诺塔的移动：A→C,A→B,C→B,A→C,B→A,B→C,A→Cx0dx0a 汉诺塔问题也是程序设计中的经典递归问题，下面我们将给出递归和非递归的不同实现源代码。