汉诺塔C语言

合集下载

汉诺塔游戏-----用C++编的

#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;}。

C语言实现汉诺塔（图文详解）

C语⾔实现汉诺塔（图⽂详解）⽬录思路：当n=1时：当n=2时：当n=3时：当n=4时：见代码运⾏截图总结汉诺塔的游戏规则：有三根⾦刚⽯柱⼦A、B、C，在A柱⼦上从下往上按照⼤⼩依次减⼩的顺序摞着64⽚黄⾦环。

⼤梵天命令婆罗门把环从下⾯开始按⼤⼩顺序重新摆放在另⼀根柱⼦上。

并且规定，在任何⼀个柱⼦上，⼩环上不能放⼤环，在三根柱⼦之间⼀次只能移动⼀个环。

即将A柱⼦上全部的环通过中间柱⼦B（B柱⼦作为中介）移动到C柱⼦上当A只有⼀个环的时候：A->C当A只有两个环的时候：A->B A->C B->C当A只有三个环的时候：A->C A->B C->B A->C B->A B->C A->C思路：1、将 n-1个环先放到B柱⼦上2、将A柱⼦上的最后⼀个环移动到C柱⼦上3、将n-1个环从B柱⼦移动到C柱⼦上当n=1时：1、将0个环先放到B柱⼦上2、将A柱⼦上的最后⼀个环移动到C柱⼦上：A->C3、将0个环从B柱⼦移动到C柱⼦上当n=2时：1、将1个环先放到B柱⼦上：A->B2、将A柱⼦上的最后⼀个环移动到C柱⼦上：A->C3、将1个环从B柱⼦移动到C柱⼦上:B->C当n=3时：1、将2个环先放到B柱⼦上：使⽤递归将2个环放到B上，因为A柱⼦的最后⼀个环是最⼤的因此可以先不理会，递归重复当n=2时的步骤，不过是从将2个环从A放到C上改为将2个环从A放到B上了2、将A柱⼦上的最后⼀个环移动到C柱⼦上：A->C3、将2个环从B柱⼦移动到C柱⼦上:使⽤递归将2个环从B柱⼦移动到C柱⼦上，此时C柱⼦上已经有了最⼤的⼀个环因此可以不⽤再理会了，递归重复当n=2的步骤，不过是从将2个环从A放到C上改为将2个环从B放到C上了当n=4时：1、将3个环先放到B柱⼦上：递归重复n=3的步骤，不过是从将3个环从A放到C上改为将3个环从A放到B上了2、将A柱⼦上的最后⼀个环移动到C柱⼦上：A->C3、将3个环从B柱⼦移动到C柱⼦上:递归重复当n=3的步骤，不过是从将3个环从A放到C上改为将3个环从B放到C上了见代码#define _CRT_SECURE_NO_WARNINGS 1#include<stdio.h>void move(char X, char Y){printf("%c->%c ", X, Y);}void HanoiTower(int n, char A, char B, char C){if (n == 1)//递归终⽌条件{move(A, C);return;}else{HanoiTower(n - 1, A, C, B);//将n-1个环从A柱⼦放到B柱⼦上，C柱⼦作为中介move(A, C);//将A柱⼦上的最后⼀个环移动到C柱⼦上HanoiTower(n - 1, B, A, C);//将n-1个环从B柱⼦放到C柱⼦上，A柱⼦作为中介}}int main(){printf("请确认A柱⼦上⼀共有多少个环:\n");int n = 0;scanf("%d", &n);HanoiTower(n, 'A','B','C');//将n个环从A柱⼦放到C柱⼦上，B柱⼦作为中介}运⾏截图总结本篇⽂章就到这⾥了，希望能给你带来帮助，也希望您能够多多关注的更多内容！。

c语言例题10-5 汉诺(hanoi)塔问题

汉诺塔问题是一个经典的递归问题。

在汉诺塔问题中，有三根柱子，第一根柱子上从下到上放着n 个盘子，目标是将这些盘子从第一根柱子移动到第三根柱子上，并且只能每次移动一个盘子，并且不能将一个较大的盘子放在较小的盘子上面。

以下是一个使用 C 语言实现的汉诺塔问题的示例代码：```c#include <stdio.h>void hanoi(int n, char A, char B, char C) {if (n == 1) {printf("Move disk 1 from %c to %c\n", A, C);return;}hanoi(n - 1, A, C, B);printf("Move disk %d from %c to %c\n", n, A, C);hanoi(n - 1, B, A, C);}int main() {int n = 3; // 盘子数量hanoi(n, 'A', 'B', 'C'); // 调用递归函数，将盘子从A 柱子移动到 C 柱子，B 柱子作为辅助柱子return 0;}```在这个代码中，我们定义了一个`hanoi` 函数来递归地解决汉诺塔问题。

在`hanoi` 函数中，我们首先检查盘子数量是否为1，如果是，则直接将盘子从起始柱子移动到目标柱子。

否则，我们使用两个辅助柱子来将n-1 个盘子从起始柱子移动到第二个辅助柱子上，然后将最后一个盘子从起始柱子移动到目标柱子上，最后再将n-1 个盘子从第二个辅助柱子移动到目标柱子上。

在`main` 函数中，我们定义了盘子数量n，并调用了`hanoi` 函数来解决问题。

C语言程序设计课程设计报告---汉诺塔问题

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语言课程设计汉诺塔

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%。

汉诺塔图形演示源代码

汉诺塔图形演示源代码#include#include#include#include#include#includevoid dizuo();void hanoi_draw();void move(int n,int one,int three);void hanoi(int n,int one,int two,int three); int N; //定义盘数int m; //定义变量移动速度RECT r = {240,0,460,240};TCHAR step[5];int stepn=0;int pan[3];void main(){printf("请输入盘子个数：");scanf("%d",&N); //从键盘输入盘子数printf("请输入移动速度：（≥500，≤2000）"); scanf("%d",&m); //从键盘输入移动速度initgraph(640,480); //初始化图形// 设置背景色为蓝色setbkcolor(BLUE);// 用背景色清空屏幕cleardevice();//制作标头settextstyle(30,0,_T("宋体"));//设置标头字体drawtext(_T("汉诺塔动画演示"), &r,DT_CENTER | DT_VCENTER | DT_SINGLELINE);//显示步骤数settextstyle(16,0,_T("宋体"));outtextxy(300,140,"step:");pan[0]=N; //第一个座初始有N个盘dizuo(); //画出底座hanoi_draw(); //初始化汉诺塔Sleep(1000);hanoi(N,1,2,3);Sleep(500);//演示完毕，输出字幕RECT r = {0, 0, 640, 480};drawtext(_T("结束"), &r, DT_CENTER | DT_VCENTER | DT_SINGLELINE);getch();closegraph;}//底座、支架void dizuo(){setlinecolor(LIGHTGRAY);//底座颜色为灰色setlinestyle(PS_SOLID | PS_JOIN_ROUND,12);//线条格式line(20,400,160,400);line(90,200,90,400);line(220,400,360,400);line(290,200,290,400);line(420,400,560,400);line(490,200,490,400);}//初始化汉诺塔void hanoi_draw(){int i;setlinestyle(PS_SOLID | PS_JOIN_ROUND,8);for(i=0;i<=(N-1)*7;i+=7){setlinecolor(RED);line(20+i,390-2*i,160-i,390-2*i);}}//移动void move(int n,int one,int three){sprintf(step,_T("%d"),++stepn);outtextxy(340,140,step);//输出步骤数pan[one-1]-=1;pan[three-1]+=1;//setlinecolor(BLACK);setlinestyle(PS_SOLID | PS_JOIN_BEVEL,10);line((one-1)*200+(N-n)*7+14,390-(pan[one-1]-0.45)*14-6,(one-1)*200+180-(N-n)*7-1.5-12,390-(pan[one-1]+0.4)*14+6);//标记将要移动的盘子为黑色Sleep(500);clearrectangle((one-1)*200+(N-n)*7,390-(pan[one-1])*14-6,(one-1)*200+180-(N-n)*7,390-(pan[one-1])*14+6);//删除将要移动的盘子dizuo();setlinecolor(BLACK);setlinestyle(PS_SOLID | PS_JOIN_BEVEL,10);line((three-1)*200+(N-n)*7+14,390-(pan[three-1]-1)*14,(three-1)*200+166-(N-n)*7,390-(pan[three-1]-1)*14);//在盘子要移到的位置画新的盘子，黑色Sleep(500);setlinecolor(RED);setlinestyle(PS_SOLID | PS_JOIN_BEVEL,10);line((three-1)*200+(N-n)*7+14,390-(pan[three-1]-1)*14,(three-1)*200+166-(N-n)*7,390-(pan[three-1]-1)*14);//将刚移动完的盘子改回红色}//汉诺塔算法怎样移动盘子void hanoi(int n,int one,int two,intthree){if (n==1){move(n-1,one,three);}else{hanoi(n-1,one,three,two);Sleep(m);move(n-1,one,three);Sleep(m);hanoi(n-1,two,one,three);}}。

用C语言解决汉诺塔问题的方法及过程分析

（）将原问题转化成新问题后，能使求解算法的规模减小．２
（）递归有一个明显的出口，或称为递归的边界，而边界问题的解是显而易见的或已知的．３
３用Ｃ语言编程
Ｃ语言是一种在国内外广泛流行的高级程序设计语言，它的语言功能丰富，表达力强，使用灵活，应
言中，用递归法编写条件
２１递归程序定义．
《Ｃ程序设计》数据结构》等教科书中，都对递归程序给出了基本相同的定义，归纳如下：在调用、《
一
个函数的过程中，又直接或间接地调用了该函数本身，称为函数的递归调用，使用了递归调用函数的程
第３期
｛ａ（一，ｏｅｔｒｅｔ）ｈｎｎ１ｎ，ｈｅ，ｗｏ；
ｍｏｅ（ｎｅ，ｔｅ）；ｖｏｈｒｅ
ｈｎ（一，ｔａｎ１ｗｏ，ｏｅｈｅ））ｎ，ｔｒｅ；）
ｍａｎ（ｉ）
｛ｎｉｔｎ；
ｐｒｎｆ（ “ ｅｓｎｔｒｔｍｂｅｉｋｅ ” ｉｔＰｌａｅｅｅｈｅｎｕｒｏｆｄｓｓ：）；
维普资讯
维普资讯
２０年６月０６
河北北方学院学报（自然科学版）
第３期
上操作的实质是把移动ｎ个盘子的问题转化为移动ｎ一１个盘．那一、三步如何解决？事实上，上述方法设盘子数为ｎ，ｎ可为任意数，该法同样适用于移动ｎ１盘．因此，依据上法，可解决ｎ一个一１个盘子从Ａ杆移到Ｂ杆（一步）或从Ｂ杆移到Ｃ杆（第第三步）问题．现在，问题由移动ｎ个盘子的操作转化为移动ｎ一２个盘子的操作．依据该原理，层层递推，即可将原问题转化为解决移动ｎ、ｎ … …３、一２一３、２直到移动１盘的操作，而移动一个盘的操作是可以直接完成的．至此，我们的任务算作是真正完成了．个而这种由繁化简，用简单的问题和已知的操作运算来解决复杂问题的方法，就是递归法．在计算机设计语

汉诺塔问题（Hanoi）的C++代码实现

汉诺塔问题（Hanoi）的C++代码实现1 #include <iostream>2using namespace std;3//第⼀个塔为初始塔，第⼆个塔为中转塔，第三个塔为⽬标塔45int i = 1; //记录步数6void move(int n,char from,char to) //将编号为N的盘⼦由from塔转移到to塔7{8 cout<<"第"<<i++<<"步:将"<<n<<"号盘⼦"<<from<<"---->"<<to<<endl; //输出实例：第1步：将1号盘⼦A---->C9}1011void hanoi(int n,char from,char denpend_on,char to) //汉诺塔递归函数，参数依次为盘⼦数，起始塔，中转塔，⽬标塔12{13if(n==1)14 {15 move(1,from,to); //当需要移动的盘⼦数为1的时候，将此盘⼦从起始塔直接移动到⽬标塔16 }17else18 {19 hanoi(n-1,from,to,denpend_on); //当需要移动的盘⼦数不为1的时候，20//先将除最下⾯的盘⼦外的盘⼦从起始塔借助⽬标塔移动到中转塔21 move(n,from,to); //将剩下的最后的塔直接从起始塔移动到⽬标塔22 hanoi(n-1,denpend_on,from,to); //将之前移⾛的n-1个盘⼦从中转塔借助起始塔移动⾄⽬标塔23 }24}2526int main()27{28int n = 0;//n为盘⼦数29 cout<<"请输⼊盘⼦的个数：";30 cin>>n;31while(n<=0)//⾮法盘⼦数判断32 {33 cout<<"盘⼦的个数不应⼩于1，请重新输⼊：";34 cin>>n;35 }36if(n>0)37 {38char x='A',y='B',z='C';39 cout<<"盘⼦移动情况如下:"<<endl;40 hanoi(n,x,y,z); //调⽤hanoi函数41return0;42 }43 }运⾏结果：递归实现，未对过程进⾏存储。

C语言常用简单算法

C语言常用简单算法C语言是一种广泛应用的编程语言，支持各种算法的实现。

以下是一些常用的简单算法，涵盖了排序、查找、递归等方面。

1. 冒泡排序（Bubble Sort）：通过不断比较相邻元素的大小，将较大的元素逐步“冒泡”到数组的末尾。

2. 选择排序（Selection Sort）：每次从未排序的数组中选择最小（或最大）的元素，放到已排序数组的末尾。

3. 插入排序（Insertion Sort）：将数组分为已排序和未排序两个部分，每次将未排序部分中的元素插入到已排序部分的正确位置。

4. 快速排序（Quick Sort）：选择一个基准元素，将数组分成两部分，将小于基准的元素放在左边，大于基准的元素放在右边，然后递归地对两部分进行排序。

5. 归并排序（Merge Sort）：将待排序数组递归地分成两部分，分别进行排序，然后再将两个有序的数组合并成一个有序的数组。

6. 二分查找（Binary Search）：对于有序数组，通过比较中间元素和目标值的大小，缩小查找范围，直到找到目标值或查找范围为空。

7. 线性查找（Linear Search）：对于无序数组，逐个比较数组中的元素和目标值，直到找到目标值或遍历完整个数组。

8. 求阶乘（Factorial）：使用递归方式或循环方式计算给定数字的阶乘。

9. 斐波那契数列（Fibonacci Sequence）：使用递归方式或循环方式生成斐波那契数列。

10. 汉诺塔（Tower of Hanoi）：使用递归方式实现汉诺塔问题的解决，将一组盘子从一个柱子移动到另一个柱子。

11. 判断回文数（Palindrome）：判断给定数字是否为回文数，即正序和倒序相同。

12.求最大公约数（GCD）：使用辗转相除法或欧几里德算法求两个数的最大公约数。

13.求最小公倍数（LCM）：通过最大公约数求得最小公倍数。

14. 求质数（Prime Number）：判断给定数是否为质数，即只能被1和自身整除。

c语言基础算法知识

c语言基础算法知识C语言基础算法知识概述：C语言作为一种广泛应用的编程语言，其基础算法知识对于程序员来说至关重要。

本文将从常见的算法知识入手，介绍C语言中常用的算法及其应用。

一、排序算法排序算法是计算机科学中最基础也是最常用的算法之一。

常见的排序算法有冒泡排序、选择排序、插入排序、快速排序、归并排序等。

这些算法的实现原理各不相同，但都能对一组数据进行排序。

1. 冒泡排序冒泡排序是一种简单直观的排序算法，它重复地遍历待排序的元素，比较相邻的两个元素并将它们交换顺序，直至整个序列有序。

2. 选择排序选择排序是一种简单直观的排序算法，它每次从待排序的数据中选择最小（或最大）的元素，将其放到已排序序列的末尾。

3. 插入排序插入排序是一种简单直观的排序算法，它将待排序的数据分为已排序和未排序两部分，每次从未排序中取出一个元素插入到已排序的合适位置，直至整个序列有序。

4. 快速排序快速排序是一种高效的排序算法，它通过一趟排序将待排序的数据分割成独立的两部分，其中一部分的所有元素都比另一部分的元素小，然后对这两部分继续进行排序，直至整个序列有序。

5. 归并排序归并排序是一种稳定的排序算法，它采用分治策略，将待排序的数据不断二分，然后对子序列进行排序，最后将排序好的子序列合并成一个有序序列。

二、查找算法查找算法是在一组数据中寻找指定元素的算法。

常见的查找算法有线性查找、二分查找、哈希查找等。

1. 线性查找线性查找是一种简单直观的查找算法，它从待查找的数据中依次比较每个元素，直到找到目标元素或遍历完整个序列。

2. 二分查找二分查找是一种高效的查找算法，它要求待查找的数据必须是有序的，通过每次将查找范围缩小一半，直到找到目标元素或查找范围为空。

3. 哈希查找哈希查找是一种快速的查找算法，它通过将关键字映射到哈希表中的位置，以实现快速定位目标元素。

三、递归算法递归算法是一种重要的算法思想，它通过函数自身的调用来解决问题。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

汉诺塔C源码#include "stdio.h"#include "conio.h"#include "stdlib.h"#include "dos.h"#include "time.h"#include "graphics.h"#define S setcolor#define F setfillstyle#define R rectangle#define C circle#define B bar#define B3D bar3d#define L line#define O outtextxy#define X 200#define Y 20int nStep=0;int nRecord[7]={7,15,31,63,127,255,511},nRec; int nDisk,nDisknum;int nBaseNum;int nSelectDelay=1; /**USE IN AUTOPLAY**/float nDelay;char chMark[15];struct rod{int nDisk[10][5];int nDiskName[10];}tree[3];/********************************************/ ntoa(int s){int b[15];int i,j;for (i=0;i<15;i++)chMark[i]='\0';for (i=0;s>=10;i++){b[i]=s%10;s/=10;}b[i]=s;for(j=i;j>=0;j--)chMark[i-j]=b[j]+'0';}void INITIAL() /**GAME INITIAL**/ {int gd=DETECT,gm=0;registerbgidriver(EGAVGA_driver); initgraph(&gd,&gm,"");setbkcolor(0);}void Start_Logo(){F(1,8);B(200,150,439,329);S(7);R(201,151,438,328);S(WHITE);R(199,149,440,330);settextstyle(DEFAULT_FONT,HORIZ_DIR,2); O(233,180,"HANOI TOWER");S(1);O(232,179,"HANOI TOWER");S(WHITE);settextstyle(DEFAULT_FONT,HORIZ_DIR,2); O(284,204,"V 2.0");S(1);O(283,203,"V 2.0");settextstyle(DEFAULT_FONT,HORIZ_DIR,1); S(WHITE);O(236,240,"COPYRIGHT (C) 2002 BY");O(236,250,"--LING DONG STUDIO--");S(7);O(236,280," ************** "); }{char message[110]=">>> IF YOU WANT TO GET THE SOURCE PROGRAM\n\nPLEASE SEND AN E_MAIL TO TELL ME,AND I WILL SEND TO YOU!! ^-^";int NUM;closegraph();sleep(1);gotoxy(1,10);for(NUM=0;NUM<110;NUM++){printf("%c",message[NUM]);delay(500);sound(0);delay(50);nosound();}sleep(1);}void FLASH_REC(){int NUM,x1=8,x2=10;randomize();for(NUM=0;NUM<33;NUM++){F(1,rand()%16);B(x1,412,x2,414);x1=x1+20;x2=x2+20;}}void DRAW(){F(1,8);B(6,80,633,100); /**BROWN BAR**/B(6,415,633,430);B(6,430,633,479);F(1,7);B(6,77,633,80);B(6,430,633,432);F(1,4);B(6,100,633,102);B(6,410,633,415);F(1,7); /**GAME BACKGROUND**/B(7,102,632,410);S(15);R(6,0,633,479);settextstyle(DEFAULT_FONT,HORIZ_DIR,4);O(70,30,"HANOI TOWER V2.0");S(9);O(71,31,"HANOI TOWER V2.0");S(7); /**SHOW MESSAGE**/ settextstyle(DEFAULT_FONT,HORIZ_DIR,1);O(190,440,"-MADE BY BOLMAN--LINGDONG STUDIO-"); O(190,450,"***********************@-"); L(165,419,165,425);S(12);O(170,419,"MESSAGE:"); /**MESSAGE BOX**/S(7);O(20,419,"PRESS ESC TO QUIT");F(1,2);B(550,450,560,460);F(1,13);B(565,450,575,460);F(1,YELLOW);B(580,450,590,460);F(1,12);B(595,450,605,460);}void DrawRod(){F(1,8);B(118,150,122,400); /*ROD1*/B(318,150,322,400); /*ROD2*/B(518,150,522,400); /*ROD3*/F(6,LIGHTBLUE);B(119,151,123,401);B(319,151,323,401);B(519,151,522,401);}/*====END OF FUN DRAWROD====*/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 YOUR WORK");sleep(1);}else O(235,419,"YOU HAVE GET DOWN THE DISK");}/*====END OF FUN SHOWINFO====*/void ShowRecord(){settextstyle(DEFAULT_FONT,HORIZ_DIR,1);F(1,8);B(78,82,90,94);ntoa(nDisk);S(YELLOW);O(40,86,"DISK:");S(15);O(80,86,chMark);B(348,82,360,94);ntoa(nRec);S(YELLOW);O(290,86,"RECORD:");S(15);O(350,86,chMark);B(560,82,610,94);ntoa(nStep);S(YELLOW);O(520,86,"STEP:");S(15);O(562,86,chMark);}/*====END OF FUN SHOWRECORD====*/void FillDisk(int x1,int y1,int x2,int y2,int color,int color1) {S(color);F(1,color);B3D(x1,y1,x2,y2,5,5);F(1,color1);B3D(x1+1,y1+1,x2+1,y2+1,5,5);}void FadeIn(void){char R[256],G[256],B[256];int nNum,nNotFinish;for(nNum=0;nNum<256;nNum++){outportb(0x3c7,nNum);R[nNum]=inportb(0x3c9);G[nNum]=inportb(0x3c9);B[nNum]=inportb(0x3c9);}nNotFinish=1;while(nNotFinish==1){nNotFinish=0;for(nNum=0;nNum<256;nNum++){if(R[nNum]!=0){nNotFinish=1;R[nNum]--;}if(G[nNum]!=0){nNotFinish=1;G[nNum]--;}if(B[nNum]!=0)nNotFinish=1;B[nNum]--;}outportb(0x3c8,nNum);outportb(0x3c9,R[nNum]);outportb(0x3c9,G[nNum]);outportb(0x3c9,B[nNum]);}delay(1000);}}/*====END OF FUN FADEIN====*/void FadeOut(void){char R[256],G[256],B[256];char RR[256],GG[256],BB[256];int nNum,nNotFinish;for(nNum=0;nNum<256;nNum++){outportb(0x3c7,nNum);R[nNum]=RR[nNum]=inportb(0x3c9);G[nNum]=GG[nNum]=inportb(0x3c9);B[nNum]=BB[nNum]=inportb(0x3c9); }for(nNum=0;nNum<256;nNum++){R[nNum]=0;G[nNum]=0;B[nNum]=0;outportb(0x3c8,nNum);outportb(0x3c9,0);outportb(0x3c9,0);outportb(0x3c9,0);}delay(100);nNotFinish=1;while(nNotFinish==1){nNotFinish=0;for(nNum=0;nNum<256;nNum++){if(R[nNum]!=RR[nNum])nNotFinish=1;R[nNum]++;}if(G[nNum]!=GG[nNum]){nNotFinish=1;G[nNum]++;}if(B[nNum]!=BB[nNum]){nNotFinish=1;B[nNum]++;}outportb(0x3c8,nNum);outportb(0x3c9,R[nNum]);outportb(0x3c9,G[nNum]);outportb(0x3c9,B[nNum]);}delay(1500);}}/*====END OF FUN FADEOUT====*/void ClrScreen(void){int NUM;F(11,9);for (NUM=84;NUM<476;NUM++){ B(7,NUM,632,NUM+2);delay(20);}}int Ball(int nRn){F(1,7);B(20,105,609,130);F(1,RED);S(RED);C(118+(nRn*200),115,10);floodfill(118+(nRn*200),115, RED); }void Quit(){ClrScreen();settextstyle(DEFAULT_FONT,HORIZ_DIR,2);S(WHITE);O(180,210,"THANK YOU TO PLAY");O(180,230," 2002.7 ");S(RED);O(181,211,"THANK YOU TO PLAY");O(181,231," 2002.7 ");O(181,260," ANY KEY TO QUIT ");S(GREEN);O(180,180,"G A M E O V E R");S(15);O(181,181,"G A M E O V E R");getch();FadeIn();closegraph();END();exit(0);}/*====END OF FUN QUIT====*/int IsWin(){int i,nStep_Sub_Rec;int nDiskNum=0;for (i=0;i<nDisk;i++){ if(tree[2].nDisk[i][0]==1) nDiskNum++;}nStep_Sub_Rec=nStep-nRec;if (nDiskNum==nDisk){ ShowInfo(4,0); /**IT CAN BE SET AS YOUR WAY**/ nBaseNum=nRec/9;if (nStep_Sub_Rec<=nBaseNum) /**WIN**/{ ClrScreen();S(GREEN);settextstyle(DEFAULT_FONT,HORIZ_DIR,3);O(230,200,"YOU WIN");S(RED);O(231,201,"YOU WIN"); }else if (nStep_Sub_Rec<=nBaseNum*2){ ClrScreen();S(RED);settextstyle(DEFAULT_FONT,HORIZ_DIR,3);O(220,200,"JUST SOSO");S(LIGHTBLUE);O(221,201,"JUST SOSO"); }else{ ClrScreen();S(LIGHTBLUE);settextstyle(DEFAULT_FONT,HORIZ_DIR,3);O(175,200,"YOU PLAY BAD");S(CYAN);O(176,201,"YOU PLAY BAD"); }sound(1000);delay(1000);sound(1500);delay(300);sound(400);delay(2020);nosound();S(BLUE);settextstyle(DEFAULT_FONT,HORIZ_DIR,1);O(170,230,"PRESS ANY KEY TO CONTINUE(ESC TO QUIT)");S(WHITE);O(171,231,"PRESS ANY KEY TO CONTINUE(ESC TO QUIT)");if(getch()==27) {Quit();}else{ClrScreen();return(1);}}else ShowInfo(3,nStep_Sub_Rec);return(0);}/*====END OF FUN ISWIN====*/void HelpMessage(){S(15);L(7,314,632,314);L(7,432,632,432);S(12);settextstyle(DEFAULT_FONT,HORIZ_DIR,1);O(23,320,"HELP MESSAGE:");S(7);O(50,340,"1).............KEY: <-,->,A,D :MOVE THE RED BALL TO SELECT A ROD");O(50,365,"2).............KEY: UP,W :TO SELECT THE TOP DISK");O(50,390,"3).............KEY: DOWN,S :TO GET DOWN THE DISK WHICH SELECT"); O(50,415,"4).............KEY: ESC :QUIT THE GAME");S(12);O(50,442,"5).............IF STEP-RECORD<=A BASENUM THAN :YOU WIN");O(50,453,"6).............IF STEP-RECORD<=A BASENUM*2 THAN :JUST SOSO");O(50,464,"7).............ELSE:YOU BAD BAD^_^");}/*====END OF FUN HELPMESSAGE====*//*========GAME:PLAYER PLAY========*/void Game(){int nMoveDisk[4],nUpdiskName1,nUpdiskName2,nUpdiskNum1,nUpdiskNum2,nHaveMove=0,i,j,nRn=0; int nStage,nStage1,nStage2,nRn1,nRn2;int x1,y1,x2,y2;int a=0,b=0;int nName=1;nRec=nRecord[nDisk-3];DrawRod();ShowRecord();FLASH_REC();for (i=0;i<3;i++) /*---EXIST BIT=0---*/for (j=0;j<9;j++){tree[i].nDisk[j][0]=0;tree[i].nDiskName[j]=0;}for (i=0;i<nDisk;i++) /*DRAW THE DISKS OF THE FIRST ROD*/{tree[nRn].nDiskName[i]=nName;tree[nRn].nDisk[i][0]=1; /*DISK i-----exist bit*/tree[nRn].nDisk[i][1]=40+a; /*--X1--*/tree[nRn].nDisk[i][2]=390-b; /*--Y1--*/tree[nRn].nDisk[i][3]=200-a; /*--X2--*/tree[nRn].nDisk[i][4]=400-b; /*--Y2--*/nName=nName+1;a=a+8;b=b+20;}for (i=0;i<nDisk;i++) /*********DRAW THE DISKS***********/FillDisk(tree[nRn].nDisk[i][1],tree[nRn].nDisk[i][2],tree[nRn].nDisk[i][3],tree[nRn]. nDisk[i][4],8,BLUE);for (i=0;i<4;i++)nMoveDisk[i]=0;DrawRod();/*-----------------------------------------------------------------*/ Ball(nRn);S(13);O(239,419,"GAME START,PLEASE GO!!");while(1){if(kbhit())switch(getch())。