汉诺塔c语言代码

⑴ c语言汉诺塔问题非递归解法代码求大神讲解

int game2()要改为int main()后才可编译运行：

#include<stdio.h>

#include<stdlib.h>

#define CSZL 10

#define FPZL 10

typedef struct hanoi

{

int n;

char x,y,z;

}hanoi;

typedef struct Stack //定义栈结点

{

hanoi *base,*top;

int stacksize;

}Stack;

int InitStack(Stack *S)

{

S->base=(hanoi *)malloc(CSZL*sizeof(hanoi)); //申请栈空间

if(!S->base) //若申请不成功返回失败信息

return 0;

S->top=S->base; //置为空栈

S->stacksize=CSZL; //栈结点数

return 1;

}

int PushStack(Stack *S,int n,char x,char y,char z) //入栈

{

if(S->top-S->base==S->stacksize) //若栈已满

{

S->base=(hanoi *)realloc(S->base,(S->stacksize+FPZL)*sizeof(hanoi)); //补充申请，扩充栈空间

if(!S->base) //若申请不成功返回失败信息

return 0;

S->top=S->base+S->stacksize; //重置栈顶指针

S->stacksize+=FPZL; //重置栈空间尺寸

}

S->top->n=n; //新结点信息存入栈顶结点

S->top->x=x;

S->top->y=y;

S->top->z=z;

S->top++; //栈中元素加1

return 1;

}

int PopStack(Stack *S,int *n,char *x,char *y,char *z) //出栈

{

if(S->top==S->base) //若栈已空

return 0; //返回出错信息

else

{

S->top--; //栈顶指针减1

*n=S->top->n; //返回出栈元素信息

*x=S->top->x;

*y=S->top->y;

*z=S->top->z;

return 1;

}

}

int EmptyStack(Stack *S) //判定是否空栈

{

if(S->base==S->top)

return 1;

else

return 0;

}

int i=1;

void Move(char x,char z) //打印移动盘子的信息

{

printf(" 第%d步，%c-->%c",i++,x,z);

}

int main() /* 非递归法 */

{

int n;

char x,y,z;

Stack *S;

system("cls"); /*清屏指令*/

S=(Stack *)malloc(sizeof(Stack)); //申请栈空间

if(!S)

return 0;

if(!InitStack(S)) //初始化栈

return 0;

printf("请输入汉诺塔的初始盘子数量以及轴的名称：");

scanf("%d %c%c%c",&n,&x,&y,&z);

if(!PushStack(S,n,x,y,z)) //要移动的盘子数及各轴名称入栈

return 0;

while(!EmptyStack(S)) //当栈非空时循环

{

if(!PopStack(S,&n,&x,&y,&z)) //若空栈则退出循环，否则出栈一个任务

break;

if(n==1) //若只有一个盘子，直接移动

{

Move(x,z);

}

else //有1个以上的盘子时入栈（注意栈的工作特点，是后进先出，所以最先做的事要最后入栈）

{

if(!PushStack(S,n-1,y,x,z)) //将上层的n-1个盘子从y移向z

break;

if(!PushStack(S,1,x,y,z)) //将底层的盘子从x移向z

break;

if(!PushStack(S,n-1,x,z,y)) //将上层的n-1个盘子从x移向y

break;

}

}

free(S->base);

S->base=NULL;

S->top=NULL;

S->stacksize=0;

return 0;

}

⑵ C语言汉诺塔

根据汉诺塔的游戏规则可知，若只有一个盘子，则只要直接搬运就可以了，其它的不需要再做。return语句的作用，就是遇到它时，程序直接返回到调用它的地方，不再执行此函数中return语句以后的代码。

不过这里这个return语句也可以不写，只是代码要稍作更改（代码的执行还是不变的，即与更改前完全等价）：

voidhanNuoTa(intn,charfrom,charto,charhelper)
{
if(n==1)
{
printf("%c--->%c
",from,to);
}
else
{
hanNuoTa(n-1,from,helper,to);
printf("%c--->%c
",from,to);
hanNuoTa(n-1,helper,to,from);
}
}

⑶ 汉诺塔的C语言代码怎么写

#include<stdio.h>
void
solve(int
num,int
z1,int
z2,int
z3);
void
main()
{
int
n;
printf("请输入盘子数量:");
scanf("%d",&n);
solve(n,1,2,3);
}
void
solve(int
num,int
z1,int
z2,int
z3)
{
if(num>0){
solve(num-1,z1,z3,z2);
printf("把%d上的盘子移到%d上\n",z1,z2);
solve(num-1,z3,z2,z1);
}
}

⑷ 用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语言代码怎么写啊

/*5. 源程序*/
/********hanoi.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,"c:\\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();
}

⑹ 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语言算法程序

hanoi(int
n,char
a,char
b,char
c)
//将n个盘子从a通过b移动到c
{
if(n==1)
move(a,1,c);
//将编号为1的盘子从a移动到c
else
{
hanoi(n-1,a,c,b);
move(a,n,c);//将编号为n的盘子从a移动到c
hanoi(n-1,b,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 move(char x,char y)
{
printf("%c-->%c\n",x,y);
}
void hanoi(int n,char one ,char two,char three)
{
if(n==1) move(one,three);
else
{
hanoi(n-1,one,three,two);
move(one,three);
hanoi(n-1,two,one,three);
}
}
main()
{
int m;
printf("input the number of disks:");
scanf("%d",&m);
printf("the step to moving %3d diskes:\n",m);
hanoi(m,'A','B','C');
}
算法介绍：
其实算法非常简单，当盘子的个数为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）操作，最后就能按规定完成汉诺塔的移动。
所以结果非常简单，就是按照移动规则向一个方向移动金片：
如3阶汉诺塔的移动：A→C,A→B,C→B,A→C,B→A,B→C,A→C
汉诺塔问题也是程序设计中的经典递归问题，下面我们将给出递归和非递归的不同实现源代码。