c++编写的汉诺塔算法程序
汉诺塔c源程序实现及讲解
• 3操作指南：在挂有圆盘的柱子上方点击 向上按钮‘ W ’ 或者‘ UPDOWN’按键 选中圆盘，按左右移动键移动到相对应 的柱子上方，按向下键放下圆盘，至此 完成一次圆盘移动。
二、设计思路及程序设计流程
• 1 设计思路：本设计中将盘子的数目设 定为3~9个。设三个柱子A、B、C 移动的过程可分解为三个步骤： 第一步 把A上的n-1个圆盘移到B上； 第二步 把A上的一个圆盘移到C上； 第三步 把B上的n-1个圆盘移到C上； 其中第一步和第三步是类同的。 其实际思想是利用一个递归原理。
• • • • • • • • • • • • • • • • • • •
• • • • • • • • • • • • • • • • • • • • • • •
void Start_Logo()/*启动标志*/ { F(3,8); B(200,150,439,259); S(7); R(201,151,442,262); S(WHITE); R(199,149,440,260); settextstyle(DEFAULT_FONT,HORIZ_DI R,2); O(233,180,"HANOI TOWER"); S(1); O(232,179,"HANOI TOWER");
• • • • • • • • • • • • • • • • • • • • • • • • • • • • •
void ShowInfo(int nRn,int nWhetherGetDisk) { F(1,8); B(230,418,620,428); settextstyle(DEFAULT_FONT,HORIZ_DIR,1); S(CYAN); if(nRn==0&&nWhetherGetDisk==0) O(235,419,"YOU NOW AT THE FIRST ROD"); else if(nRn==1&&nWhetherGetDisk==0) O(235,419,"YOU NOW AT THE SECOND ROD"); else if(nRn==2&&nWhetherGetDisk==0) O(235,419,"YOU NOW AT THE THIRD ROD"); else if(nWhetherGetDisk==1) {S(YELLOW); switch(nRn) {case 0 :O(235,419,"YOU GET THE TOP DISK AT THE FIRST ROD");break; case 1 :O(235,419,"YOU GET THE TOP DISK AT THE SECOND ROD");break; case 2 :O(235,419,"YOU GET THE TOP DISK AT THE THIRD ROD");break; default:break; } } else if(nRn==3&&nWhetherGetDisk==nBaseNum) {S(WHITE);O(235,419,"YOU SHOULD DO YOUR BEST");} else if(nRn==3&&nWhetherGetDisk==nBaseNum*2) O(235,419,"YOU SEEMS PLAY NOT VERY GOOD...^_^"); else if(nRn==4&&nWhetherGetDisk==0) {S(13);O(235,419,"O.K YOU HAVE FINISHED YOURWORK");sleep(1);} else O(235,419,"YOU HAVE GET DOWN THE DISK"); }
汉诺塔递归c语言
汉诺塔递归c语言
汉诺塔是一个经典的递归问题。
在汉诺塔问题中，有3个柱子，一个可以移动的盘子，开始时所有盘子按大小顺序叠放在第一个柱子上，目标是将这些盘子移动到第三个柱子上，同时每次只能移动一个盘子，并且不能将一个较大的盘子放在较小的盘子上面。
以下是一个使用C语言实现的汉诺塔递归算法：
c复制代码
#include<stdio.h>
void hanoi(int n, char from, char to, char via) {
if (n == 1) {
printf("Move disk 1 from %c to %c\n", from, to);
return;
}
hanoi(n - 1, from, via, to);
printf("Move disk %d from %c to %c\n", n, from, to);
hanoi(n - 1, via, to, from);
}
int main() {
int n = 3; // 盘子的数量
hanoi(n, 'A', 'C', 'B'); // 从柱子A移动到柱子C，经过柱子B
return0;
}
这个程序使用递归函数hanoi来解决汉诺塔问题。
当只有一个盘子时，直接将其从起始柱子移动到目标柱子。
当有多于一个盘子时，先将上面的n-1个盘子从起始柱子通过目标柱子移动到辅助柱子，然后将最大的盘子从起始柱子移动到目标柱子，最后将n-1个盘子从辅助柱子通过起始柱子移动到目标柱子。
c语言递归函数实现汉诺塔
c语言递归函数实现汉诺塔汉诺塔问题是一个经典的递归问题，它可以用来展示递归的思想和实现。
在这个问题中，我们有三根柱子和一些圆盘，圆盘在柱子上，每个圆盘的大小不同，较小的在较大的上面。
目标是将所有的圆盘从一个柱子移动到另一个柱子上，同时遵守以下几个规则：1.每次只能移动一个圆盘；2.每次移动时，圆盘都必须放置在更大的圆盘上；3.圆盘只能从最上面移动；4.可以利用剩余的柱子作为辅助。
这个问题可以使用递归算法来解决，下面我们来看一下如何在C语言中实现。
首先，我们需要定义一个递归函数来解决汉诺塔问题。
这个函数将接受四个参数：圆盘数量n，起始柱子源(source)，辅助柱子auxiliary和目标柱子destination。
函数的目标是将n个圆盘从源柱子移动到目标柱子上。
```cvoid hanoi(int n, char source, char auxiliary, char destination) {//终止条件：当只有一个圆盘时，直接将它从源柱子移到目标柱子上if (n == 1) {printf("将圆盘从%c移动到%c\n", source, destination);return;}//递归步骤：将n-1个圆盘从源柱子移动到辅助柱子上hanoi(n-1, source, destination, auxiliary);//将第n个圆盘从源柱子移动到目标柱子上printf("将圆盘从%c移动到%c\n", source, destination);//将n-1个圆盘从辅助柱子移动到目标柱子上hanoi(n-1, auxiliary, source, destination);```在这个递归函数中，当n等于1时，表示只剩下一个圆盘，此时直接将其从源柱子移动到目标柱子上。
否则，我们首先递归地将n-1个圆盘从源柱子移动到辅助柱子上，然后将第n个圆盘从源柱子移动到目标柱子上，最后再将n-1个圆盘从辅助柱子移动到目标柱子上。
汉诺塔C递归算法详细解答
汉诺塔C递归算法详细解答程序如下：void move(char x,char y){printf("%c-->%c\n",x,y);}void hanoi(int n,char one,char two,char three){/*将n个盘从one座借助two座，移到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 n;printf("input the number of diskes:");scanf("%d",&n);printf("The step to moving %3d diskes:\n",n);hanoi(n,'A','B','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上；其中第一步和第三步是类同的。
数据结构C语言实现之hanoi塔问题
y
move(Sx, n, Sz);
//将编号为 n 的圆盘从 x 移到 z
Hanoi(n-1, Sy, Sx, Sz); //将 y 上编号为 1 至 n-1 的圆盘利用 x 移到z} Nhomakorabea}
void main() {
SNode *Sx, *Sy, *Sz; int i = 0, n = 0; char ck = 0;
//将 x 上的圆盘编号
i++;
}
Hanoi(n, &Sx, &Sy, &Sz);
printf("\n 从 X 移到 Z 的结果是：\n");
Print(&Sz);
}
m = Pop(S1); Push(S2, m); }
void Hanoi(int n, SNode **Sx, SNode **Sy, SNode **Sz)
{
if (n == 1)
move(Sx, 1 , Sz);
//将编号为 1 的圆盘由 x 移到 z
else
{
Hanoi(n-1, Sx, Sz, Sy); //将 x 上编号为 1 到 n-1 的圆盘利用 z 移到
int data; struct Stack *next; }SNode;
void InitStack(SNode **S) {
*S = (SNode *) malloc (sizeof(SNode)); (*S)->next = NULL; //先建立一个带头结点 }
void Push(SNode **S, int ck)
void Print(SNode **S) {
SNode *p; p = (*S)->next; while(p) {
汉诺塔问题非递归算法c语言
汉诺塔问题非递归算法c语言汉诺塔问题是一个经典的数学问题，也是一个常见的编程练习题。
在这个问题中，有三根柱子和一些圆盘，圆盘的大小不一，从小到大依次叠放在一根柱子上。
目标是将所有的圆盘从一根柱子移动到另一根柱子，移动过程中要保证大的圆盘在小的圆盘上面。
同时，每次只能移动一个圆盘，且不能把一个大的圆盘放在一个小的圆盘上面。
在解决汉诺塔问题时，通常采用递归算法。
但是递归算法的效率并不高，因为每次递归都会产生额外的函数调用，增加了系统的开销。
因此，我们可以通过非递归的方式来解决汉诺塔问题，提高算法的效率。
以下是一个用C语言实现的汉诺塔问题的非递归算法：```c#include <stdio.h>#include <stdlib.h>typedef struct {int n;char start, end, temp;} StackNode;typedef struct {StackNode data[100];int top;} Stack;void push(Stack *s, StackNode node) {s->data[s->top++] = node;}StackNode pop(Stack *s) {return s->data[--s->top];}void hanoi(int n, char start, char end, char temp) {Stack s;s.top = 0;StackNode node;node.n = n;node.start = start;node.end = end;node.temp = temp;push(&s, node);while (s.top > 0) {node = pop(&s);if (node.n == 1) {printf("Move disk 1 from %c to %c\n", node.start, node.end); } else {StackNode node1, node2, node3;node1.n = node.n - 1;node1.start = node.temp;node1.end = node.end;node1.temp = node.start;push(&s, node1);node2.n = 1;node2.start = node.start;node2.end = node.end;node2.temp = node.temp;push(&s, node2);node3.n = node.n - 1;node3.start = node.start;node3.end = node.end;node3.temp = node.temp;push(&s, node3);}}}int main() {int n;printf("Enter the number of disks: "); scanf("%d", &n);hanoi(n, 'A', 'C', 'B');return 0;}```在这个非递归算法中，我们使用了一个栈来模拟递归的过程。
汉诺塔(C语言)
bar(160, 540, 240, 580);
setfont(30, 0, "黑体");
++s[0].top;//进栈
for (int i1 = 0; i1 < 4; i1++)
{
p[i]->a[i1] = ta[i1];
s[0].stack[s[0].top] = p[i];//记录每个矩形的位置，top为圆盘的个数
}
}
Hannoi(n, 'a', 'b', 'c');//汉诺塔递归函数
//绘制运动画面的的环境
setcolor(RED);
//三根红色线段作为钢针
line(400, 110, 400, 500);
line(600, 110, 600, 500);
line(200, 110, 200, 500);
//长方体形的底座
setfillstyle(LIGHTGRAY);
bar3d(80, 500, 720, 510, 10, true);
#include <graphics.h>
#include <conio.h>
#include <stdio.h>
#define MAX 64//圆盘的最大数目
#define NULL 0
//定义栈
struct STKNODE
{
int a[4];
};
struct STK
{
STKNODE*stack[MAX];
inttop;
};
//定义全局变量
STK s[3];//声明三个栈，分别代表一号二号三号钢针上圆盘的状态
c语言递归汉诺塔每一步详解
递归汉诺塔是一个经典的递归问题，它要求将一堆圆盘从一根柱子移动到另一根柱子上，且规定不能通过其他圆盘。
这个问题可以通过递归算法来解决。
在每一步中，我们可以选择将当前最大的圆盘从起始柱子移动到目标柱子，或者将两个较小的圆盘移动到另一个柱子上。
递归函数需要考虑三个柱子的状态:起始柱子、目标柱子和柱子。
在函数中，我们需要判断当前情况是否可以进行移动，如果可以，则执行相应的移动操作，否则返回上一个递归函数继续执行。
最终，当所有圆盘都移到目标柱子上时，问题得到解决。