下载文档原格式
#ifndef HANIO_H_#define HANIO_Hclass Stack{private:enum{ MAX=50 };int m_node[MAX];int m_top;int m_size;int m_index;public:Stack();~Stack() { };bool Isfull() { return m_top==MAX-1 ;}; //堆栈满则返回TRUE bool Isempty() { return m_top==-1;}; //堆栈空则返回TRUE int Top() { return m_top; };int TopValue() { return m_node[m_top];};int GetDataFromIndex(int i) { return m_node[i]; };int GetIndex() { return m_index; } ;void SetIndex(int index) { m_index = index; };int Size() { return m_top+1; };bool Push(int data);bool Pop(int * pData);int MoveToNext();void OutPrint();};class Hanio{Stack m_stack[3];int m_num; //盘数int m_steps; //移动次数int m_times; //完成所用时间void print(char ch,int n);public:Hanio(int num=3);~Hanio() {};void GameStart();bool MoveFromTo(int x,int y); //从x号盘移动到y号盘void DrawPaletes(char ch='*'); //打印3个堆的盘子bool IsFinished() ; //结束返回TURE;int Solve(char from,char to,char auxiliary,int n); //求解其解法路径};#endif//hanio.cpp#include "hanio.h"#include <iostream>#include<cstdlib>#include<cstring>#include<cctype>#include<windows.h>Stack::Stack(){m_top=-1;m_index=m_top;for(int i=0;i<MAX;i++)m_node[i]=0;}bool Stack::Push(int data){if(Isfull())return false;m_top++;m_node[m_top]=data;m_index=m_top;return true;}bool Stack::Pop(int *pData){if(Isempty())return false;*pData=m_node[m_top];m_node[m_top]=0;m_top--;m_index=m_top;return true;}int Stack::MoveToNext(){int temp=m_index;m_index--;return m_node[temp];}void Stack::OutPrint(){if(m_top!=-1){for(int i=0;i<=m_top;i++)std::cout<<"["<<m_node[i]<<"]";}}///////////////////////////////////////Hanio::Hanio(int num){m_num=num;m_steps=0;m_times=0;for(int i=num;i>=1;i--)m_stack[0].Push(i);//m_stack[0].OutPrint();}void Hanio::print(char ch,int n){for(int i=1;i<=n;i++)std::cout<<ch;}void Hanio::DrawPaletes(char ch){int max;max=m_stack[0].Size()>m_stack[1].Size() ? m_stack[0].Size() : m_stack[1].Size();max=m_stack[2].Size()>max ? m_stack[2].Size() : max;//std::cout<<"Max:"<<max<<std::endl;m_stack[0].SetIndex(max-1);m_stack[1].SetIndex(max-1);m_stack[2].SetIndex(max-1);for(int i=1;i<=max;i++){int data1=m_stack[0].MoveToNext();int data2=m_stack[1].MoveToNext();int data3=m_stack[2].MoveToNext();if(data1==0)print(' ',20);else{print(' ',10-data1);print(ch,2*data1);print(' ',10-data1);}if(data2==0)print(' ',20);else{print(' ',10-data2);print(ch,2*data2);print(' ',10-data2);}if(data3==0)print(' ',20);else{print(' ',10-data3);print(ch,2*data3);print(' ',10-data1);}std::cout<<std::endl;}}bool Hanio::MoveFromTo(int x,int y){m_steps++; //计算所走的步数if(m_stack[x].Isempty()){std::cout<<x<<" pallete is empty ! continue !"<<std::endl; std::cin.get();return false;}if(m_stack[y].Isempty()){int data;m_stack[x].Pop(&data);m_stack[y].Push(data);return true;}else{if(m_stack[x].TopValue()>m_stack[y].TopValue()){std::cout<<"The board can't move from "<<x<<" plate to " <<y<<" plate!"<<std::endl;std::cin.get();return false;}else{int data;m_stack[x].Pop(&data);m_stack[y].Push(data);return true;}}}bool Hanio::IsFinished(){return m_stack[2].Top()==m_num-1;}void Hanio::GameStart(){using namespace std;UINT StartTime=::GetTickCount();UINT EndTime;while(1){system("cls");print('-',80);cout<<"steps: "<<m_steps; print(' ',20);cout<<"Used time: "<<m_times<<endl;print('-',80);cout<<endl; cout<<endl; print(' ',10); cout<<"A";print(' ',19); cout<<"B"; print(' ',19);cout<<"C"<<endl<<endl;Hanio::DrawPaletes();cout<<endl; cout<<endl;print('-',80);//测试游戏是否结束if(Hanio::IsFinished()){cout<<"你好强呀!从今天开始,维护世界和平的任务就交给你那!"<<endl;cin.get();break;}//输入命令并左相应的处理char szCommand[50];cout<<">>";cin.getline(szCommand,50);if(stricmp(szCommand,"QUIT")==0 || stricmp(szCommand,"Q")==0)break;if(stricmp(szCommand,"HELP")==0 || stricmp(szCommand,"H")==0){cout<<" 本游戏说明:"<<endl;cout<<" 该游戏由DAVID用C++编程,花费了一个多下午的时间呢!!!,由命令行来控制铁饼的移动:"<<endl;cout<<" QUIT / Q : 退出程序"<<endl;cout<<" HELP / H : 查看该说明"<<endl;cout<<" XY : X,Y的取值为A,B,C,意思时把X木桩最上面的铁饼移到Y 木桩"<<endl;cout<<" SOLVE / S : 显示求解该问题(移动铁饼)的最优路径..."<<endl; cin.get();}char ch1=toupper(szCommand[0]);char ch2=toupper(szCommand[1]);if( ch1=='A' && ch2=='B')Hanio::MoveFromTo(0,1);else if ( ch1=='A' && ch2=='C')MoveFromTo(0,2);else if ( ch1=='B' && ch2=='A')MoveFromTo(1,0);else if ( ch1=='B' && ch2=='C')MoveFromTo(1,2);else if ( ch1=='C' && ch2=='A')MoveFromTo(2,0);else if ( ch1=='C' && ch2=='B')MoveFromTo(2,1);else{cout<<"Bad command !"<<endl;cin.get();}//统计游戏所用时间EndTime=GetTickCount();m_times=(EndTime-StartTime)/1000;}}int Hanio::Solve(char from,char to,char auxiliary,int n) {if(n==1)return 0;}//main.cpp#include<iostream>#include"hanio.h"#include<cstdlib>using namespace std;int StartPicture();//返回选择的盘数int main(){int number;number=StartPicture();Hanio hanio(number);hanio.GameStart();return 0;}void print(char ch,int n){for(int i=1;i<=n;i++)std::cout<<ch;}int StartPicture(){using namespace std;int number;system("cls");system("color fc");print(' ',20);print('-',25);cout<<endl;print(' ',20);cout<<" Hanio(汉诺塔)"<<endl;print(' ',20);print('-',25);cout<<endl;print(' ',40);print('-',5);cout<<"By David"<<endl;print('=',80);cout<<" 相传在某一座古庙中有3根木桩,有24个铁盘由小到大放置在一根木柱上,庙中流传者一个传说:\"如果能把24个铁盘, 从一根木桩移动到另一个木桩,且必须遵守如下规则:"<<endl;cout<<endl;print(' ',5);cout<<"1. 每天只能动一个盘,而且只能从最上面的铁盘开始搬动."<<endl; print(' ',5);cout<<"2. 必须维持较小的铁盘在上方的原则"<<endl;cout<<endl;cout<<"这两个原则,则当24个铁盘完全般到另一个木桩时,世界就回永久和平!!"<<endl;cout<<"游戏的玩法可以在命令行中输入HELP查看"<<endl;cout<<endl;cout<<endl;cout<<endl;cout<<endl;cout<<endl;cout<<"再此输入你要搬的铁盘数(建议在1--10值间,太多回花费很长时间的)"<<endl;print('=',80);cout<<">>";cin>>number;cin.get();system("cls");return number;}。
XXXX大学计算机科学与技术学院课程设计报告2012 — 2013学年第一学期课程名称C/C++高级语言程序设计课程设计设计题目小游戏和图形处理汉诺塔问题学生姓名XXX学号XXXXXXX专业班级XXXXXXXXXXX指导教师XX2012 年X 月XX 日目录一、课程设计问题描述 (1)1、课程设计题目 (1)2、设计任务要求 (1)二、总体设计 (1)1、设计思路 (1)2、汉诺塔求解流程图 (2)三、详细设计 (2)1、汉诺塔问题描述 (2)2、算法分析 (3)3、实现递归的条件 (4)4、用C语言实现 (4)四、程序运行结果测试与分析 (4)1、打开Microsoft Visual C++ 6.0操作平台输入以下的源代码 (4)2、编译源代码 (5)3、组建 (5)4、执行 (5)5、运行结果 (6)6、按任意键结束程序 (7)五、结论与心得 (7)六、参考文献 (8)七、附录：程序源代码 (8)一、课程设计问题描述1、课程设计题目汉诺塔问题2、设计任务要求输入盘子数（2个以上有效），移动速度，开始演示汉诺塔移动的步骤，要求：盘子A，B，C柱需要自己绘制，初始时盘子在A柱上通过B柱最终移动到C 柱上，显示出盘子在几个柱之间的移动过程。
二、总体设计1、设计思路对于一个类似的这样的问题，任何一个人都不可能直接写出移动盘子的每一个具体步骤。
可以利用这样的统筹管理的办法求解：我们假设把该任务交给一个僧人，为了方便叙述，将他编号为64。
僧人自然会这样想：假如有另外一个僧人能有办法将63个盘子从一个座移到另一个座，那么问题就解决了，此时僧人A B C64只需这样做：(1).命令僧人63将63个盘子从A座移到C座(2).自己将最底下的最大的一个盘子从A座移到C座(3).再命令僧人63将63个盘子从B座移到C座为了解决将63个盘子从A座移到B座的问题，僧人63又想：如果能再有一个僧人62能将62个盘子移动到另一座，我就能将63个盘子从A座移动到B座。
动态汉诺塔c 课程设计一、课程目标知识目标：1. 理解动态汉诺塔问题的基本原理，掌握汉诺塔问题的递归算法；2. 学会运用程序设计思想解决实际问题，能够编写出动态汉诺塔的解决方案；3. 了解计算机科学中递归算法的应用场景，理解递归算法的优势和局限。
技能目标：1. 能够运用所学知识，独立设计并实现动态汉诺塔的程序；2. 培养逻辑思维能力，提高分析问题和解决问题的能力；3. 提升团队协作能力，通过小组讨论和分享，共同优化解决方案。
情感态度价值观目标：1. 培养对计算机科学的兴趣和热情，激发学习编程的积极性；2. 培养勇于尝试、不断探索的精神，面对困难时保持积极态度；3. 树立正确的价值观，认识到团队合作的重要性，尊重他人意见，共同为解决问题贡献力量。
课程性质：本课程为信息技术学科的教学内容，以实践为主，结合理论讲解，培养学生的编程能力和逻辑思维能力。
学生特点：学生具备一定的编程基础，对汉诺塔问题有一定了解，但可能对动态汉诺塔问题尚陌生，需要通过实践和讨论来提高。
教学要求：教师需注重理论与实践相结合，关注学生的个体差异，引导学生主动探究，提高学生的编程能力和团队合作能力。
通过课程目标的实现，使学生在知识、技能和情感态度价值观方面取得具体的学习成果。
二、教学内容本课程依据课程目标，结合教材内容，组织以下教学大纲：1. 汉诺塔问题引入：回顾汉诺塔的基本原理，引导学生思考如何用程序解决汉诺塔问题。
- 教材章节：第二章 递归算法2. 动态汉诺塔问题分析：讲解动态汉诺塔问题的特点，分析递归算法在动态汉诺塔问题中的应用。
- 教材章节：第二章 递归算法3. 编程实践：指导学生编写动态汉诺塔的程序，实现递归算法。
- 教材章节：第三章 程序设计4. 小组讨论与优化：分组讨论，分享编程心得，优化动态汉诺塔解决方案。
- 教材章节：第四章 算法优化5. 算法分析与拓展：分析动态汉诺塔算法的时间复杂度和空间复杂度，探讨算法的优化方向。
c语言课程设计汉诺塔一、教学目标本节课的教学目标是让学生掌握汉诺塔问题的解法，理解其背后的算法思想，培养逻辑思维能力和编程能力。
具体分为以下三个部分：1.知识目标：使学生了解汉诺塔问题的定义、解法和算法思想，理解递归算法的原理及其在解决汉诺塔问题中的应用。
2.技能目标：培养学生运用C语言实现汉诺塔问题的解决方案，提高编程实践能力。
3.情感态度价值观目标：培养学生独立思考、合作交流的学习习惯，增强对计算机科学的兴趣和热情。
二、教学内容本节课的教学内容主要包括以下几个部分：1.汉诺塔问题的定义和解法：介绍汉诺塔问题的背景，讲解其解法及步骤。
2.递归算法的原理：讲解递归算法的基本概念、特点及其在解决汉诺塔问题中的应用。
3.C语言实现汉诺塔问题：引导学生运用C语言编写汉诺塔问题的解决方案，并进行调试和优化。
4.算法分析和改进：分析汉诺塔问题的算法复杂度，探讨如何优化算法性能。
三、教学方法为了达到本节课的教学目标，采用以下几种教学方法：1.讲授法：讲解汉诺塔问题的定义、解法和递归算法的原理。
2.案例分析法：分析实际案例，让学生了解递归算法在解决汉诺塔问题中的应用。
3.实验法：引导学生动手实践，用C语言实现汉诺塔问题的解决方案。
4.讨论法：学生进行小组讨论，分享算法优化思路，培养合作交流能力。
四、教学资源本节课的教学资源包括以下几个方面：1.教材：选用《C程序设计》等相关教材，为学生提供理论知识的学习参考。
2.参考书：推荐《算法导论》等参考书籍，帮助学生深入了解算法原理。
3.多媒体资料：制作PPT、教学视频等多媒体资料，辅助学生理解和记忆知识点。
4.实验设备：为学生提供计算机、编程环境等实验设备，方便学生动手实践。
五、教学评估本节课的教学评估主要包括以下几个方面：1.平时表现：评估学生在课堂上的参与度、提问回答等情况，占比20%。
2.作业：评估学生完成的汉诺塔问题相关练习，包括C语言代码编写和调试，占比30%。
汉诺塔c 课程设计一、教学目标本课程的学习目标包括：知识目标：学生能理解汉诺塔问题的定义、解法及其应用；掌握汉诺塔问题的算法思想和编程方法。
技能目标：学生能够运用汉诺塔问题的解法解决实际问题，提高逻辑思维和问题解决能力；学会使用编程语言实现汉诺塔问题的算法。
情感态度价值观目标：学生培养对计算机科学的兴趣，增强创新意识和团队协作精神，认识汉诺塔问题在现实生活中的重要性。
二、教学内容教学内容主要包括：1.汉诺塔问题的定义和背景；2.汉诺塔问题的解法及其证明；3.汉诺塔问题的算法分析；4.汉诺塔问题的编程实现；5.汉诺塔问题在现实生活中的应用。
三、教学方法本课程采用多种教学方法，包括：1.讲授法：讲解汉诺塔问题的定义、解法、算法和应用；2.讨论法：引导学生探讨汉诺塔问题的解决策略，培养团队协作能力；3.案例分析法：分析现实生活中的汉诺塔问题实例，提高学生的问题解决能力；4.实验法：让学生动手编程实现汉诺塔问题，培养实践操作能力。
四、教学资源教学资源包括：1.教材：选用权威、实用的汉诺塔问题教材，为学生提供理论基础；2.参考书：提供相关领域的参考书籍，丰富学生的知识体系；3.多媒体资料：制作课件、视频等多媒体资料，增强课堂教学的趣味性；4.实验设备：配置合适的计算机设备，确保学生能够顺利进行编程实践。
五、教学评估教学评估主要包括：1.平时表现：评估学生在课堂上的参与度、提问回答等情况，占比20%；2.作业：评估学生完成作业的质量和效率，占比30%；3.考试：定期进行汉诺塔问题相关知识的考试，占比50%。
评估方式应客观、公正，能够全面反映学生的学习成果。
六、教学安排教学安排如下：1.教学进度：按照教材和教学大纲进行教学，确保完成所有教学内容；2.教学时间：每周安排2课时，共10周；3.教学地点：教室。
教学安排应合理、紧凑，确保在有限的时间内完成教学任务，同时考虑学生的实际情况和需要。
七、差异化教学根据学生的不同学习风格、兴趣和能力水平，设计差异化的教学活动和评估方式，以满足不同学生的学习需求。
汉诺塔问题的程序实现汉诺塔问题的程序实现实验⽬的：运⽤程序解决汉诺塔（hanoi）问题。
汉诺塔问题：假设有3个分别命名为A，B，C的塔座，在塔座A上插有n个直径⼤⼩各不相同，依⼩到⼤编号为1,2....,n的圆盘。
现要求将A轴上的n个圆盘移到C并仍按同样顺序叠排，圆盘按以下规则（1）每次只能⼀动⼀个盘⼦（2）圆盘可以插在A，B，C中任⼀个塔座上（3）任何时刻都不能将⼀个较⼤的圆盘压在较⼩的圆盘之上。
A B C实验分析：汉诺塔问题可以规划为⼀个递归的问题予以分析，将n个盘⼦从A针移动到C 针可进⾏3个步骤:(1)将A上n-1的个盘⼦移到B针上；(2)把A针最后1个盘⼦移到C针上；(3)再把B盘⼦上的n-1个移到C针上。
实验过程：#includeusing namespace std;void main(){void hanoi(int m,char A,char B,char C); //A代表初始柱⼦，B代表辅助柱⼦，C代表⽬标柱⼦int m;printf("请输⼊盘⼦的个数:");scanf("%d", &m);printf("当盘⼦的个数为%d时移动的步骤是:\n",m);hanoi(m,'A','B','C');}void hanoi(int n,char X,char Y,char Z){void move(char X,char Z );if(n==1)move(X,Z);else{hanoi(n-1,X,Z,Y);move(X,Z);hanoi(n-1,Y,X,Z);}}void move(char x,char y){printf("%c-->%c\n",x,y);}过程：A代表初始柱⼦，B代表辅助柱⼦，C代表⽬标柱⼦。
⽽a代表第⼀根柱⼦,b代表第⼆根柱⼦,c代表第三根柱⼦。
C语⾔实现汉诺塔游戏操作就是：A B 号码A的塔顶⼀层放在号码B的塔顶。
如1（空格） 3 回车。
话说有⼈能把我这C的代码添加到QT界⾯框架上去么？代码写的不好，维护性不够，只能玩8层的，写完以后发现很难拓展，软件⼯程，设计模式有待提⾼....⾥⾯提⽰输⼊等级的装B⽤了，没有实现，⼤家随便输⼊个个位数就可以玩了。
stackfunc.c#include"STACK.h"#include<stdio.h>extern ceng CENG[SIZE];//数据⼊栈void push_stack(stack*p,int number){p->arr[p->head]=number;p->head++;}//初始化栈1void init_stack1(stack*p){p->head=0;push_stack(p,1);push_stack(p,2);push_stack(p,3);push_stack(p,4);push_stack(p,5);push_stack(p,6);push_stack(p,7);push_stack(p,8);}//初始化栈2 3void init_stack2_3(stack* p1,stack* p2){p1->head=0;p1->arr[p1->head]=0;p2->head=0;p2->arr[p2->head]=0;}//弹出栈顶元素int pop_stack(stack* p){p->head--;return p->arr[p->head];}//访问栈顶元素int top_stack(stack* p){return p->arr[p->head-1];}//⽐较两个栈顶元素的⼤⼩int sizecmp_stack(stack* p1,stack* p2){if(p1->arr[p1->head-1]>p2->arr[p2->head-1])return 1;else if(p1->arr[p1->head-1]<p2->arr[p2->head-1])return -1;else return 0;}//测出栈的⾼度int high_stack(stack* p){return p->head;}//是否为空栈int empty_stack(stack* p){return p->head==0;}//是否栈满int full_stack(stack* p){return p->head==SIZE;}//初始化层1void init_ceng1(ceng* p){p->number=1;p->row=SIZE-1;p->col=0;}//初始化层2void init_ceng2(ceng* p){p->number=2;p->row=SIZE-2;p->col=0;}//初始化层3void init_ceng3(ceng* p){p->number=3;p->row=SIZE-3;p->col=0;}//初始化层4void init_ceng4(ceng* p){p->number=4;p->row=SIZE-4;p->col=0;}//初始化层5void init_ceng5(ceng*p){p->number=5;p->row=SIZE-5;p->col=0;}//初始化层6void init_ceng6(ceng*p){p->number=6;p->row=SIZE-6;p->col=0;}//初始化层7void init_ceng7(ceng*p){p->number=7;p->row=SIZE-7;p->col=0;}//初始化层8void init_ceng8(ceng*p){p->number=8;p->row=SIZE-8;p->col=0;}//移动层void move_ceng(int level,int *nrow,int *ncol,stack*p1,stack* p2,stack* p3,int stdec){stack* arr[3];arr[0]=p1;arr[1]=p2;arr[2]=p3;*nrow=level-1-high_stack(arr[stdec]);*ncol=stdec;}//显⽰图⽚void show_map(void){int i,j;for(i=0;i<SIZE;i++){for(j=0;j<3;j++){if(CENG[0].row==i&&CENG[0].col==j){printf(" | 1 | ");}else if(CENG[1].row==i&&CENG[1].col==j){printf(" | 2 | ");}else if(CENG[2].row==i&&CENG[2].col==j){printf(" | 3 | ");}else if(CENG[3].row==i&&CENG[3].col==j){printf(" | 4 | ");}else if(CENG[4].row==i&&CENG[4].col==j){printf(" | 5 | ");}else if(CENG[5].row==i&&CENG[5].col==j){printf(" | 6 | ");}else if(CENG[6].row==i&&CENG[6].col==j){printf(" | 7 | ");}else if(CENG[7].row==i&&CENG[7].col==j){printf(" |8| ");}else printf(" ");}printf("\n");}printf("=====================================================================\n"); }main.c#include"STACK.h"#include<stdio.h>ceng CENG[SIZE];int main(){int res=1,dec=1;char con;int newrow;int newcol;int step=0;int level=0;while(1){ if (level==0){do{printf("请输⼊游戏等级:\n");scanf("%d",&level);if(level<=0||level>8)printf("等级范围错误，重新输⼊\n");}while(level<=0||level>8);}level=8;newrow=0,newcol=0;stack STACK[3];//初始化3个栈init_stack1(&STACK[0]);init_stack2_3(&STACK[1],&STACK[2]);//初始化8个层init_ceng1(&CENG[0]);init_ceng2(&CENG[1]);init_ceng3(&CENG[2]);init_ceng4(&CENG[3]);init_ceng5(&CENG[4]);init_ceng6(&CENG[5]);init_ceng7(&CENG[6]);init_ceng8(&CENG[7]);while(1){//打印画⾯switch(level){case 1:show_map();break;case 2:show_map();break;case 3:show_map();break;case 4:show_map();break;case 5:show_map();break;case 6:show_map();break;case 7:show_map();break;case 8:show_map();break;}while(1){// printf("游戏等级为:%d\n",level);// printf("源栈最⾼层是%d ......\n",top_stack(&STACK[res]));printf(" ⼀号的⾼度%d ",STACK[0].head);printf(" ⼆号的⾼度%d ",STACK[1].head);printf(" 三号的⾼度%d\n",STACK[2].head);printf("\n已经⾛的步数为 %d \n",step);//选择源⽬标scanf("%d",&res);scanf("%d",&dec);res--;dec-- ;if(!(res>=0&&res<3&&dec>=0&&dec<3))/*||(empty_stack(&STACK[res]))*/{ printf("\n\n输⼊范围超出\n");}else if(empty_stack(&STACK[res])==1){printf("%d\n",STACK[0].head);printf("\n\n源栈空\n");}else if(sizecmp_stack(&STACK[res],&STACK[dec])<0){ printf("\n\n⼤块的不能放在⼩块的上⾯\n");}else{if(dec!=res){printf("\n\n\n正在移动层块....\n");step++;move_ceng(level,&newrow,&newcol,&STACK[0],&STACK[1],&STACK[2],dec); CENG[top_stack(&STACK[res])-1].row=newrow;CENG[top_stack(&STACK[res])-1].col=newcol;push_stack(&STACK[dec],pop_stack(&STACK[res]));break;}else{printf("\n\n\n放轻松\n");}break;}show_map();}if (full_stack(STACK+1)==1||full_stack(STACK+2)==1){printf("完成了汉诺塔!\n");level++;break;}}show_map();printf("是否继续游戏?继续请输⼊y,否则按其它键\n");scanf("%*[^\n]");scanf("%*c");scanf("%c",&con);if(con!='y')break;}return 0;}STACK.h#ifndef __STACK_H__#define __STACK_H__#define SIZE 8typedef struct STACK{int head;int arr[SIZE];}stack;typedef struct CENG{int number;int row;int col;}ceng;extern ceng CENG[SIZE];//⼊栈void push_stack(stack*,int);//初始化栈1void init_stack1(stack*);//初始化栈2和3void init_stack2_3(stack*,stack*);//出栈int pop_stack(stack*);//访问栈顶元素int top_stack(stack*);//⽐较栈顶元素⼤⼩ -1 1int sizecmp_stack(stack*,stack*);//判断栈的⾼度int high_stack(stack*);//判断栈是否为空1 0int empty_stack(stack*);//判断栈是否满1 0int full_stack(stack*);//初始化层1void init_ceng1(ceng*);//初始化层2void init_ceng2(ceng*);//初始化层3void init_ceng3(ceng*);//初始化层4void init_ceng4(ceng*);//初始化层5void init_ceng5(ceng*);//初始化层6void init_ceng6(ceng*);//初始化层7void init_ceng7(ceng*);//初始化层8void init_ceng8(ceng*);//移动层块void move_ceng(int ,int * a,int *b,stack*,stack*,stack*,int k );//打印画⾯void show_map();#endif演⽰图⽚以上所述就是本⽂的全部内容了，希望能够对⼤家学习C语⾔的递归算法有所帮助。
c++汉诺塔问题递归算法汉诺塔问题是经典的递归问题，它可以帮助我们理解和掌握递归算法的思想。
在C++中，我们可以通过递归来解决汉诺塔问题。
汉诺塔问题的描述如下：有三根柱子A、B、C，A柱子上有n 个盘子，盘子的大小不一，大的在下，小的在上。
现在要将A 柱子上的盘子移动到C柱子上，并且每次只能移动一个盘子，并且大的盘子不能放在小的盘子上面。
要求通过借助柱子B来实现移动。
下面我们先给出解决汉诺塔问题的递归代码：```cpp#include <iostream>void hanoi(int n, char A, char B, char C) {if (n == 1) {std::cout << "Move disk 1 from " << A << " to " << C << std::endl;return;}hanoi(n - 1, A, C, B);std::cout << "Move disk " << n << " from " << A << " to " << C << std::endl;hanoi(n - 1, B, A, C);}int main() {int n = 3; // 盘子的个数hanoi(n, 'A', 'B', 'C');return 0;}```上面的代码使用了递归的思想来解决汉诺塔问题。
函数`hanoi()`接受四个参数，n表示盘子的个数，A、B、C表示三根柱子的名称。
当n等于1时，表示只有一个盘子需要移动，直接将它从A柱子移动到C柱子即可。
当n大于1时，我们可以把问题简化为两个步骤：将n-1个盘子从A柱子通过借助C柱子移动到B柱子，然后将最后一个盘子从A柱子移动到C柱子，最后将n-1个盘子从B柱子通过借助A柱子移动到C 柱子。
c 课程设计汉诺塔一、教学目标本课程的教学目标是让学生掌握汉诺塔的基本概念、原理和解决方法，培养学生的逻辑思维能力和问题解决能力。
具体来说，知识目标包括了解汉诺塔的历史背景、基本规则和递归算法；技能目标包括能够运用递归算法解决汉诺塔问题，并进行简单的优化；情感态度价值观目标包括培养学生的团队合作意识、挑战自我和探索未知的勇气。
二、教学内容教学内容主要包括汉诺塔的基本概念、递归算法的原理和应用。
首先，介绍汉诺塔的历史背景和基本规则，让学生了解汉诺塔的起源和演变。
然后，讲解递归算法的原理，引导学生理解递归的思维方式和实现方法。
最后，通过实例分析，让学生学会如何运用递归算法解决汉诺塔问题，并进行简单的优化。
三、教学方法为了激发学生的学习兴趣和主动性，本课程将采用多种教学方法。
首先，运用讲授法，清晰地传达汉诺塔的基本概念和递归算法的原理。
其次，通过讨论法，让学生在课堂上相互交流、分享心得，培养学生的团队合作意识。
此外，结合案例分析法，让学生通过分析实际问题，提高问题解决能力。
最后，运用实验法，让学生动手实践，加深对汉诺塔解决方法的理解。
四、教学资源为了支持教学内容和教学方法的实施，我们将选择和准备适当的教学资源。
教材方面，将选用权威、实用的汉诺塔教材，确保学生掌握准确的知识。
参考书方面，将推荐一些经典的汉诺塔相关书籍，拓展学生的知识视野。
多媒体资料方面，将收集一些关于汉诺塔的动画、视频等资料，丰富学生的学习体验。
实验设备方面，将准备相应的设备，让学生进行实践活动，提高操作技能。
五、教学评估本课程的评估方式包括平时表现、作业和考试三个部分。
平时表现主要评估学生在课堂上的参与程度、提问回答和团队协作等情况，占总评的30%。
作业分为练习题和项目任务，主要评估学生对知识的理解和应用能力，占总评的40%。
考试为闭卷笔试，涵盖课程全部内容，主要评估学生的知识掌握和问题解决能力，占总评的30%。
评估方式客观、公正，全面反映学生的学习成果。
汉诺塔演示.txt你不能让所有人满意，因为不是所有的人都是人成功人士是—在牛B的路上，一路勃起你以为我会眼睁睁看着你去送死吗？我会闭上眼睛的摘要:该文对经典的“汉诺塔”问题进行了详细的分析,并用C语言实现。
通过问题的具体实现,使学习者了解问题的全过程,推广到一般。
关键词:汉诺塔;递归;C语言Algorithm Analysis and C Realization of Hanio IssueBAI Hui-bo1,GAO Rui-ping2(1.Qinhuangdao Branch of Daqing Petroleum Institute, Qinhuangdao 066004, China;2.Hebei Normal University of Science and Technology, Qinhuangdao 06600, China)Abstract: This text carries on detailed analysis about classical Hanio issue and provides realization of algorithm in C.Through concrete realization of the problem,can make learners observe the whole course which solves this issue and Extend to the general.Key words: hanio; recursive; the C programming language1 问题描述汉诺塔是一个经典的数学问题,其具体描述如下:有三根相邻的塔子,标号为A,B,C,A塔子上从下到上按金字塔状叠放着n个不同大小的圆盘,现在把所有盘子借助于A,B,C三个塔子一个一个移动到塔子C上,并且每次移动在同一根塔子上都不能出现大盘子在小盘子上方.根据问题描述得到以下规则:1)圆盘必须一个一个的移动;2)大的圆盘必须在小圆盘的下方或单一圆盘;3)满足规则2)的序列可以出现在A,B,C任意一根塔子上。
汉诺塔一、需求分析：1、输入时每次只需输入一个n值，无范围限制。
2、输出的形式，输出移动盘子的所有步骤，每一句为一个步骤。
3、功能，实现汉诺塔的移动步骤。
4、测试数据，n=-1,0,1,3,4。
二、概要设计：各函数的调用关系：三、详细设计：见源码：hannuota.cpp文件的实现#include<iostream>using namespace std;int num; //全局变量void move(char a,char c) //移动函数{cout<<"第"<<++num<<"步:"<<a<<"柱子上的盘子移动到"<<c<<"柱子上."<<endl;}void hanuota(int num,char a,char b,char c) //递归调用函数{if(num<1){cout<<"无可移动盘子."<<endl;return ;}if(num==1){move(a,c);}else{hanuota(num-1,a,c,b);move(a,c);hanuota(num-1,b,a,c);}}int main() //main函数{int i;while(cin>>i){num=0;hanuota(i,'A','B','C');}return 0;}四、调式分析：1、调式时递归函数不正确，因为参数顺序不正确，经改正后最终得到了正确的结果。
2、体会，学会了递归函数的使用。
五、用户使用说明：每次只需输入一个n值表示盘子数，即可得到结果。
六、测试结果:。
c语言十大算法案例C语言是一种广泛应用于编程的高级语言，具有简单、灵活、高效等特点。
在C语言中，有许多经典的算法案例，这些算法案例不仅有助于提高编程能力，还能帮助我们理解计算机科学的基本原理。
下面列举了十个C语言的经典算法案例。
1. 冒泡排序算法：冒泡排序是一种简单但效率较低的排序算法，它通过多次比较和交换相邻元素的方式将最大或最小的元素逐步移动到数组的一端。
2. 快速排序算法：快速排序是一种常用的排序算法，它通过选择一个基准元素，将数组分成两个子数组，然后对子数组进行递归排序。
3. 二分查找算法：二分查找是一种高效的查找算法，它通过将查找范围缩小一半来快速定位目标元素。
4. 链表反转算法：链表反转是一种常见的操作，它可以将链表中的节点顺序逆转。
5. 汉诺塔算法：汉诺塔是一种经典的递归问题，它通过将圆盘从一个柱子移动到另一个柱子来演示递归的思想。
6. 最大公约数算法：最大公约数是指能够同时被两个或多个整数整除的最大正整数，求最大公约数的算法有多种，如辗转相除法和欧几里德算法。
7. 斐波那契数列算法：斐波那契数列是一个数列，其中每个数字都是前两个数字之和，求斐波那契数列的算法有多种，如递归和循环。
8. 图的深度优先搜索算法：深度优先搜索是一种用于遍历图的算法，它通过递归的方式依次访问图中的每个节点。
9. 图的广度优先搜索算法：广度优先搜索也是一种用于遍历图的算法，它通过队列的方式依次访问图中的每个节点。
10. 最短路径算法：最短路径算法用于找到图中两个节点之间的最短路径，常用的最短路径算法有迪杰斯特拉算法和弗洛伊德算法。
这些算法案例涵盖了排序、查找、链表操作、递归、图算法等多个方面，是C语言学习中不可或缺的部分。
通过学习和理解这些经典算法案例，我们可以提高自己的编程能力，并在解决实际问题时能够选择合适的算法。
希望本文能够对读者有所帮助，激发他们对C 语言算法的兴趣，并在编程的道路上不断进步。
汉诺塔问题的程序实现（hanoi塔）问题重述：有三根柱A、B、C，在柱A上有N块盘⽚，所有盘⽚都是⼤的在下⾯，⼩⽚能放在⼤⽚上⾯。
现要将A上的N块盘⽚移到C柱上，每次只能移动⼀⽚，⽽且在同⼀根柱⼦上必须保持上⾯的盘⽚⽐下⾯的盘⽚⼩，输⼊任意的N，输出移动⽅法。
(注意：这是⼀个古⽼的传说，传说是如果把64个盘⼦由A柱移到了C柱的话，那么世界末⽇就到了，事实上如果要把64个盘⼦从A柱移到C柱的话，即使⽤计算机运算，也要计算数亿年，所以这个预⾔未必不是真实。
)【分析】我们可以这样考虑，当n=1时，我们只要直接将A柱的盘⼦移到C柱，当n>1时，我们可以先把n-1个盘⼦由A柱通过C柱移到B 柱，此时就可以把A柱剩下的最后⼀个盘⼦直接移到C柱，这样接下来只要把n-1个盘⼦通过A柱移到C 柱即可，如果就构成了递归的思路，我们可以定义个移动过程mov(n,a,b,c)表⽰将n个盘⼦从a通过b移到c1.只要求输出搬运的次数#includeusing namespace std;int m=0;void move(){m++;}void I(int n){if(n==1)move();else{I(n-1);move();I(n-1);}}int main(){I(3);cout<cout<<"输出完毕！"<return 0;}更加简单的⽅法！#includeusing namespace std;int fact(int n){if(n==1)return(1);elsereturn((2*fact(n-1)+1));}int main(){cout<}2.不仅要求输出搬运的次数，⽽且要输出每个步骤的详细搬运#includeusing namespace std;int m=0;void Move(int n,char x,char y){cout<<"把"<m++;}void Hannoi(int n,char a,char b,char c){if(n==1)Move(1,a,c);else{Hannoi(n-1,a,c,b);Move(n,a,c);Hannoi(n-1,b,a,c);}}int main(){int i;cout<<"请输⼊圆盘数"<cin>>i;Hannoi(3,'a','b','c');cout<<"总的搬运次数"<cout<<"输出完毕！"<return 0;}}另外⼀种不利⽤递归的解法（很抱歉，我⾃⼰也没调出来，实在太复杂了）#includeusing namespace std;//圆盘的个数最多为64const int MAX = 1;//⽤来表⽰每根柱⼦的信息struct st{int s[MAX]; //柱⼦上的圆盘存储情况int top; //栈顶，⽤来最上⾯的圆盘char name; //柱⼦的名字，可以是A，B，C 中的⼀个int Top()//取栈顶元素{return s[top];}int Pop()//出栈{return s[top--];}void Push(int x)//⼊栈{s[++top] = x;}} ;long Pow(int x, int y); //计算x^yvoid Creat(st ta[], int n); //给结构数组设置初值void Hannuota(st ta[], long max); //移动汉诺塔的主要函数int main(void){int n;cin >> n; //输⼊圆盘的个数st ta[3]; //三根柱⼦的信息⽤结构数组存储Creat(ta, n); //给结构数组设置初值long max = Pow(2, n) - 1;//动的次数应等于2^n - 1 Hannuota(ta, max);//移动汉诺塔的主要函数system("pause");return 0;}void Creat(st ta[], int n){ta[0].name = 'A';ta[0].top = n-1;//把所有的圆盘按从⼤到⼩的顺序放在柱⼦A 上for (int i=0; ita[0].s[i] = n - i;//柱⼦B，C 上开始没有没有圆盘ta[1].top = ta[2].top = 0;for (int j=0; jta[1].s[j] = ta[2].s[j] = 0;//若n 为偶数，按顺时针⽅向依次摆放A B Cif (n%2 == 0){ta[1].name = 'B';ta[2].name = 'C';}else //若n 为奇数，按顺时针⽅向依次摆放A C B {ta[1].name = 'C';ta[2].name = 'B';}}long Pow(int x, int y){long sum = 1;for (int i=0; isum *= x;return sum;}void Hannuota(st ta[], long max){int k = 0; //累计移动的次数int i = 0;int ch;while (k < max){//按顺时针⽅向把圆盘1 从现在的柱⼦移动到下⼀根柱⼦ch = ta[i%3].Pop();ta[(i+1)%3].Push(ch);cout << ++k << ": " <<"Move disk " << ch << " from " << ta[i%3].name <<" to " << ta[(i+1)%3].name << endl;i++;//把另外两根柱⼦上可以移动的圆盘移动到新的柱⼦上if (k < max){ //把⾮空柱⼦上的圆盘移动到空柱⼦上，当两根柱⼦都为空时，移动较⼩的圆if (ta[(i+1)%3].Top() == 0 ||ta[(i-1)%3].Top() > 0 &&ta[(i+1)%3].Top() > ta[(i-1)%3].Top()){ch = ta[(i-1)%3].Pop();ta[(i+1)%3].Push(ch);cout << ++k << ": " << "Move disk "<< ch << " from " << ta[(i-1)%3].name<< " to " << ta[(i+1)%3].name << endl;}else{ch = ta[(i+1)%3].Pop();ta[(i-1)%3].Push(ch);cout << ++k << ": " << "Move disk " << ch << " from " << ta[(i+1)%3].name << " to " << ta[(i-1)%3].name << endl; }}}}补充知识：【典型例题1】求阶乘n!#includeusing namespace std;int fact(int n){if(n==0)return(1);elsereturn(n*fact(n-1)); }int main(){cout<。
简单的汉诺塔问题解法代码以前学东西不扎实，现在捡捡也好，汉诺塔本是C语⾔开门就学的东西，不过上课那会⼉真⼼听不懂，直到⼤⼆了，才明⽩那是咋回事，我感觉的编程，真的是⼀张窗户纸，不过捅破要花时间理解吸收。
题⽬描述：有⼀个塔，塔内有A,B,C三个柱⼦。
起初，A柱上有n个盘⼦，依次由⼤到⼩、从下往上堆放，要求将它们全部移到C柱上；在移动过程中可以利⽤B柱，但每次只能移到⼀个盘⼦，且必须使三个柱⼦上始终保持⼤盘在下，⼩盘在上的状态。
要求编程输出移动的步骤。
代码如下：复制代码代码如下:#include<stdio.h>int move(char one,char two)//这个函数就是为了输出的结果直观显⽰出来，⽐如只有⼀个盘⼦时，输出a-->c. 就这样，把移动n个盘⼦每个步骤显⽰出来{printf("%c --> %c\n",one,two);}int hanoi(int n,char one,char two,char three)//是核⼼函数了{int move(char one,char two);if(n==1)//当只有⼀个盘⼦时，直接从a柱移到c柱就好，也是递归程序的⼀个出⼝move(one,three);else{ //盘⼦⼤于⼀时hanoi(n-1,one,three,two);//先借助c柱把上⾯的n-1个盘⼦从a柱全部移动到b柱move(one,three); //这时a柱只剩下⼀个盘⼦了，移动到c柱即可hanoi(n-1,two,one,three);//将b柱剩下的n-1个盘⼦借助a柱移动到c柱，任务也就完成了}}int main(){int n;char a,b,c;while(scanf("%d",&n)!=EOF)//可以输⼊多组数据检验结果hanoi(n,'a','b','c');}。
