⑴ c语言：求解汉诺塔问题
汉诺塔问题用递归解决比较容易，下面代码是我用C++写的，你可以参考
#include <iostream>
using namespace std;
void Move(char ch1,char ch2)
{
cout<<ch1<<"------->"<<ch2<<endl;
}
void Hannuo(int n,char PA,char PB,char PC)
{
if (n==1)
{
Move(PA,PC);
return;
}
else {
Hannuo(n-1,PA,PC,PB);
Move(PA,PC);
Hannuo(n-1,PB,PA,PC);
}
}
void main()
{ int N;
cout<<"请输入你要移动的盘子数:";
cin>>N;
Hannuo(N,'A','B','C');
}
⑵ C语言--汉诺塔程序执行步骤
这个问题你要先把递归搞懂才能理解的, 最好是单跟踪执行一下, 我这里就简单说一下吧!
hanoi(5, 'a', 'b', 'c');把5个从'a'移到'c'
这时n=5, noe='a', two='b', three='c'
因为n!=1, 执行else里的
hanoi( 4, 'a', 'c', 'b'); //把上面4个从a移到b
move( 'a', 'c'); //把第5个从a移到c
hanoi( 4, 'b', 'a', 'c'); //再把那4个从b移到c
上面的很好明白的, 再分析hanoi( 4, 'a', 'c', 'b'); //把上面4个从a移到b,也是执行else
hanoi( 3, 'a', 'b', 'c'); //把上面3个从a移到c
move( 'a', 'b'); //把第4个从a移到b
hanoi( 4, 'c', 'a', 'b'); //再把那3个从c移到b
一直到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语言汉诺塔.
# include <stdio.h>
void hannuota(int n,char A,char B, char C);
int main(void)
{
char ch1 = 'A';
char ch2 = 'B';
char ch3 = 'C';
int n;
printf("请输入要移动的盘子的个数：");
scanf("%d",&n);
hannuota(n,'A','B','C');
return 0;
}
//将A柱子上的n个盘子借助于B移动到C柱子上，
//每次移动时，必须保证大盘子在小盘子下面
//最大值不能是64
void hannuota(int n,char A,char B,char C)
{
/*
如果是1个盘子
直接将A柱子上的盘子从A移动到C
否则
先将A柱子上的n-1个盘子借助于C从A移动到B
直接将A柱子上的盘子从A移动到C
最后将B柱子上的n-1个盘子借助于A从B移动到C
*/
if (1 == n)
{
printf("将编号为%d的盘子从%c柱子移动到%c柱子\n",n,A,C);
}
else
{
hannuota(n-1,A,C,B);
printf("将编号为%d的盘子从%c柱子移动到%c柱子\n",n,A,C);
hannuota(n-1,B,A,C);
}
}
/*
在vc++6.0中的输出结果：
------------------
请输入要移动的盘子的个数：3
将编号为1的盘子从A柱子移动到C柱子
将编号为2的盘子从A柱子移动到B柱子
将编号为1的盘子从C柱子移动到B柱子
将编号为3的盘子从A柱子移动到C柱子
将编号为1的盘子从B柱子移动到A柱子
将编号为2的盘子从B柱子移动到C柱子
将编号为1的盘子从A柱子移动到C柱子
-------------------
*/
/*
供参考！ 呵呵
*/
⑸ C语言中的汉诺塔问题，谁能分析给我。
反复的递归的调用move函数，程序很好理解，就是一个递归的反复执行先将n-1个盘子从x借z移到y上，然后将第n个移到z，最后将y上的n-1个盘子通过x移到z上。实际上就是汉诺塔中嵌套汉诺塔#include<stdio.h>move(int n,char x,char y,char z){ if(n==1) printf("%c-->%c\n",x,z); else { move(n-1,x,z,y); printf("%c-->%c\n",x,z); move(n-1,y,x,z); }}int main(){ int n; printf("input diskes number:\n"); scanf("%d",&n); printf("The step moving %d diskes:\n",n); move(n,'A','B','C'); getchar(); return 0;｝
⑹ 用C语言编程序解决汉诺塔问题
#include "stdafx.h"
#include <stdio.h>
#include <stdlib.h>
int count;
void movedisk(int,char,char,char);
int _tmain(int argc, _TCHAR* argv[])
{
int n;
printf("输入盘子的数量：");
scanf("%d",&n) ;
movedisk(n,'A','C','B');
printf("盘子数量%d的时候移动了%d次\n",n,count);
scanf("%d",&n) ;
}
void movedisk(int n,char from,char to,char tmp)
{
if(n>1)
movedisk(n-1,from,tmp,to);
printf("盘子 %d 号从柱子 %c 移动到了柱子 %c 上\n",n,from,to);
count++;
if(n>1)
movedisk(n-1,tmp,to,from);
}
⑺ 求汉诺塔c语言动画演示程序
#include <graphics.h>
struct H
{
int data[15];/*存放每个盘的代号*/
int top;/*每个塔的具体高度*/
}num[3];/*三个塔*/
void move(char x,char y,struct H num[3]);/*移动的具体过程*/
void hanoi(char x,char y,char z,int n,struct H num[3]);/*递归*/
void Init(void);/*初始化*/
void Close(void);/*图形关闭*/
int computer=1;/*自动控制与手动控制的标志*/
int speed=0;/*全局变量speed主要是演示过程的速度*/
void main(void)
{
Init();/*初始状态*/
Close();/*图形关闭*/
exit(0);
}
void Init(void)/*初始化*/
{
int gd=DETECT,gm;
int i,n,color;
clrscr();
printf("please input n(n<=10): ");/*输入要演示的盘子数*/
scanf("%d",&n);
printf("Please input 1 or 2:\n1.computer 2.people\n");
scanf("%d",&i);
if(i==2)/*选择手动控制标志为0*/
computer=0;
if(n<1||n>10)
n=10;/*越界的话n当10处理*/
if(computer)/*如果是自动控制的话输入速度*/
{
printf("please input speed: ");/*输入速度*/
scanf("%d",&speed);
}
initgraph(&gd,&gm,"D:\\tc");
cleardevice();
for(i=0;i<3;i++)
num[i].top=-1;/*三个地方的高度开始都为-1*/
for(i=0;i<n;i++)/*画一开始的塔座A上的盘子*/
{
num[0].top++;/*栈的高度加1*/
num[0].data[num[0].top]=i; /*最大的盘子代号为0，依次为1，2，…n-1*/
color=num[0].data[num[0].top]+1;/*盘子的颜色代码为栈顶盘子代号加1*/
setfillstyle(SOLID_FILL,color);
bar(100-(33-3*num[0].data[num[0].top]),400-20*i-8,100+
(33-3*num[0].data[num[0].top]),400-20*i+8); /*画矩形*/
}
setcolor(YELLOW);
outtextxy(180,450,"any key to continue");
settextstyle(0,0,2);
outtextxy(90,420,"A"); /*塔座标志*/
outtextxy(240,420,"B");
outtextxy(390,420,"C");
getch();/*接收字符后就执行递归操作*/
hanoi('a','b','c',n,num);
}
void move(char x,char y,struct H num[3])/*移动的具体过程*/
{
int i;
char num1[3],num2[3];
sprintf(num1,"%c",x-32);/*将小写变成大写，并转换成字符串输出*/
sprintf(num2,"%c",y-32);
setfillstyle(SOLID_FILL,BLACK);/*把原来的地方移去涂黑*/
bar(0,0,640,60);
setcolor(RED);
outtextxy(150,30,num1);/*输出移动过程*/
outtextxy(200,30,"--->");
outtextxy(310,30,num2);
settextstyle(0,0,2);
setfillstyle(SOLID_FILL,BLACK);/*把原来的地方移去涂黑*/
bar(100+150*(x-97)-(33-3*num[x-97].data[num[x-97].top]),
400-20*num[x-97].top-8,100+150*(x-97)+(33-3*
num[x-97].data[num[x-97].top]),400-20*num[x-97].top+8);
num[y-97].top++;/*入栈，目标点的top加1*/
num[y-97].data[num[y-97].top]=num[x-97].data[num[x-97].top];/*在目标点盘子的代号与源点盘子的代号相同*/
num[x-97].top--;/*出栈，原来地方的top减1*/
setfillstyle(SOLID_FILL,num[y-97].data[num[y-97].top]+1);/*盘子颜色代码是栈顶盘子代号加1*/
bar(100+150*(y-97)-(33-3*num[y-97].data[num[y-97].top]),
400-20*num[y-97].top-8,100+150*(y-97)+
(33-3*num[y-97].data[num[y-97].top]),400-20*num[y-97].top+8);
if(computer)/*自动控制就用delay*/
delay(speed);/*延时函数*/
else
getch();/*手动控制的话就自己按键盘来控制*/
}
void hanoi(char one,char two,char three,int n,struct H num[3])/*递归n为盘子数，num为堆栈*/
{
if(n==1)
move(one,three,num);/*如果盘子为1，将这个盘子从塔座A移动到塔座C*/
else
{
hanoi(one,three,two,n-1,num);/*将塔座A的前n-1个盘子移到塔座B*/
move(one,three,num);/*将塔座A的第n个盘子移到塔座C*/
hanoi(two,one,three,n-1,num); /*将塔座B的n-1个盘子移到塔座C*/
}
}
void Close(void)/*图形关闭*/
{
getch();
closegraph();
}
演示过程在TC 下进行。。嘻嘻
⑻ 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语言汉诺塔（高分提问）
其实汉诺塔就是递归问题,你理解了递归思想,自然就很容易懂,这种问题一般都作为编程语言教程的递归例子讲解的,你其实可以仔细看看课本的.
hanio(n-1,a,c,b);// 这语句的意思是:首先将a 上面的n-1个盘通过c 移动到b ,这样的结果是,a 只剩下最大一块盘,然后直接移动到c就行了,所以也就有move(a,c); 之后a 为空,b 有刚才移动的n-1个盘,c 上面已经有个最大的了,如果把剩下的n-1移动到c ,就完成了,所以接着有下面的语句:
hanio(n-1,b,a,c); //这意思说,把b 上的n-1个盘通过a 移动到c,
就这样完成递归,一次次执行下去,就行了.
⑽ C语言汉诺塔的问题
要看懂递归程序，往往应先从最简单情况看起。
先看hanoi(1, one, two, three)的情况。这时直接将one柱上的一个盘子搬到three柱上。注意，这里one柱或three柱到底是A、B还是C并不重要，要记住的是函数第二个参数代表的柱上的一个盘被搬到第四个参数代表的柱上。为方便，将这个动作记为：
one =》three
再看hanoi(2, one, two, three)的情况。考虑到hanoi(1)的情况已经分析过了，可知这时实际上将产生三个动作，分别是：
one =》two
one =》three
two =》three
很显然，这实际上相当于将one柱上的两个盘直接搬到three柱上。
再看hanoi(3, one, two, three)的情况。分析
hanoi(2, one , three, two)
one =》three
hanoi(2, two, one, three)
即：先将one柱上的两个盘搬到two柱上，再将one柱上的一个盘搬到three柱上，最后再将two柱上的两个盘搬到three柱上。这不就等于将one柱上的三个盘直接搬到three柱上吗？
运用归纳法可知，对任意n，
hanoi(n-1, one , three, two)
one =》three
hanoi(n-1, two, one, three)
就是先将one柱上的n-1个盘搬到two柱上，再将one柱上的一个盘搬到three柱上，最后再将two柱上的n-1个盘搬到three柱上。这就是我们所需要的结果！