马踏棋盘c报告 数据结构课程设计
马踏棋盘c语言课程设计
![马踏棋盘c语言课程设计](https://img.taocdn.com/s3/m/063ed741a66e58fafab069dc5022aaea988f4174.png)
马踏棋盘c语言课程设计一、教学目标本课程的目标是让学生掌握C语言的基本语法、数据结构、算法和编程技巧,培养学生独立思考、解决问题和合作交流的能力。
具体分为以下三个部分:1.知识目标:学生能够理解并掌握C语言的基本语法、数据类型、运算符、控制结构、函数、数组、指针等概念,了解C语言的面向对象编程思想。
2.技能目标:学生能够运用C语言编写简单的程序,解决实际问题,具备一定的编程能力。
3.情感态度价值观目标:培养学生对计算机科学的兴趣,增强自信心,培养克服困难的勇气和团队协作精神。
二、教学内容教学内容主要包括C语言的基本语法、数据结构、算法和编程技巧。
具体安排如下:1.第一章:C语言概述,介绍C语言的发展历程、特点和基本语法。
2.第二章:数据类型和运算符,讲解整型、浮点型、字符型数据以及各类运算符的用法。
3.第三章:控制结构,包括条件语句、循环语句和跳转语句。
4.第四章:函数,讲解函数的定义、声明、调用以及函数的参数传递。
5.第五章:数组和指针,介绍数组的声明、初始化和使用,以及指针的基本概念和应用。
6.第六章:字符串和文件操作,讲解字符串的表示、操作方法以及文件读写。
7.第七章:编程实践,通过实际项目让学生综合运用所学知识解决实际问题。
三、教学方法本课程采用多种教学方法,包括讲授法、案例分析法、实验法和讨论法。
1.讲授法:用于讲解C语言的基本语法、数据结构和算法。
2.案例分析法:通过分析实际项目,让学生了解C语言在实际中的应用。
3.实验法:让学生动手编写程序,培养实际编程能力。
4.讨论法:鼓励学生提问、交流和分享,培养合作交流能力。
四、教学资源1.教材:《C程序设计语言》(K&R)或《C Primer Plus》。
2.参考书:《C语言编程之美》、《C语言深度剖析》。
3.多媒体资料:PPT课件、教学视频、在线教程。
4.实验设备:计算机、编程环境(如Code::Blocks、Visual Studio等)。
数据结构 马踏棋盘 设计报告
![数据结构 马踏棋盘 设计报告](https://img.taocdn.com/s3/m/31022a360912a2161479296b.png)
《数据结构》课程设计报告课程名称:《数据结构》课程设计课程设计题目:姓名:院系:专业:年级:学号:指导教师:2011年月日目录1、程序设计的目的2、设计题目3、分析4、设计思想5、算法6、测试结果7、调试分析8、小结1、课程设计的目的1、熟练使用C++语言编写程序,解决实际问题;2、了解并掌握数据结构与算法的设计方法,具备初步的独立分析和设计能力;3、初步掌握软件开发过程的问题分析、系统设计、程序编码、测试等基本方法和技能;4、提高综合运用所学的理论知识和方法独立分析和解决问题的能力;5、学习并熟悉栈的有关操作;6、利用栈实现实际问题;2、设计题目【马踏棋盘】*问题描述:将马随机放在国际象棋的8X8棋盘Bo阿rd[0..7,0..7]的某个方格中,马按走棋规则进行移动。
要求每个方格上只进入一次,走遍棋盘上全部64个方格。
编制非递归程序,求出马的行走路线,并按求出的行走路线,将数字1,2,…,64依次填入8X8的方阵输出之。
*测试数据:由读者指定,可自行指定一个马的初始位置。
*实现提示:每次在多个可走位置中选择一个进行试探,其余未曾试探过的可走位置必须用适当结构妥善管理,以备试探失败时的“回溯”(悔棋)使用。
并探讨每次选择位置的“最佳策略”,以减少回溯的次数。
3、分析确定输入值的范围,输入马的初始行坐标X和Y,X和Y的范围都是1到8之间。
程序的功能是输出马走的步骤,要使马从任一起点出发,通过程序能找到下一个地点,然后遍历整个棋盘。
每次在多个可走位置中选择一个进行试探,其余未曾试探过的可走位置必须用适当结构妥善管理,以备试探失败时的“回溯”(悔棋)使用。
并探讨每次选择位置的“最佳策略”,以减少回溯的次数。
输出时可以用二维数组。
4、设计思想输入马初始位置的坐标。
将初始位置进栈,经过一个while循环,取出符合条件的栈顶元素。
利用函数,找出栈顶元素周围未被占用的新位置,如果有,新位置入栈;否则弹出栈顶元素。
C++ 数据结构课程设计 马踏棋局文档
![C++ 数据结构课程设计 马踏棋局文档](https://img.taocdn.com/s3/m/317edc1eb7360b4c2e3f6489.png)
课程设计题目1 问题描述将马随机放在国际象棋的8*8棋盘Board[8][8]的某个方格中,马按走棋规则进行移动,要求每个方格上只进入一次,走遍棋盘上全部64个方格2 基本要求(1)采用图形界面实现该游戏。
(2)从键盘输入马的初始位置。
(3)编制程序,求出马的行走路线,并按求出的行走路线,将数字1,2,…,64依次填入一个8* 8的方阵,并输出之。
3系统分析与设计3.1 数据结构逻辑结构为线性结构,用顺序栈。
坐标点用已结构体来表示,并将其的位置放在s[step]的栈中,而且将每走一步的坐标放在另一栈s1中3.2 算法设计1.程序框架及功能模块划分:2.设计功能的分析与实现void exit(point p)参数:point功能:计算出下一步可能位置,按其各个位置下一个位置的和压栈到s[]中算法描述:接受参数传来的值,按次序加上int horizontal[]={2,1,-1,-2,-2,-1,1,2};int vertical[]={-1,-2,-2,-1,1,2,2,1};再根据legal函数来判断是否合法(x(0~7),y(0~7))是,则保存在point ap[]中,再按各自下一步的数目从大到小排序。
最后,将ap[]中的点压栈。
int number(point p)参数:point功能:找出当前位置下一步的各种可能位置,计算可能之和算法描述:接受参数传来的值,按次序加上int horizontal[]={2,1,-1,-2,-2,-1,1,2};int vertical[]={-1,-2,-2,-1,1,2,2,1};再根据legal函数来判断是否合法(x(0~7),y(0~7))是,则加1并将值返回void next(point p)参数:point功能:/找出各个位置并将其步数记录算法描述:将其步数记录在board[][]的相应位置,并将这点压栈到s1,判断步数是否小于64,再根据这四个条件选择执行其中的一个,再递归调用next.bool legal(point p)参数:point功能:判断是否可行,合法(是否在棋盘上,是否走过)算法描述:用这样的语句if((p.x>=0)&&(p.x<n)&&(p.y<n)&&(p.y>=0)&&(bo ard[p.x][p.y]==0))return true;elsereturn false;4 测试数据及结果测试数据和运行输出及结果分析输入x(0-7),y(0-7)0 01 34 3 18 49 32 13 164 19 56 33 14 17 50 3157 2 35 48 55 52 15 1220 5 60 53 36 47 30 5141 58 37 46 61 54 11 266 21 42 59 38 27 64 2943 40 23 8 45 62 25 1022 7 44 39 24 9 28 63 Press any key to continue输入x(0-7),y(0-7)0 9输入不合法,重输入!输入x(0-7!),y(0-7!)4 530 27 10 49 40 25 8 511 48 29 26 9 6 39 2428 31 56 45 50 41 4 747 12 51 42 19 44 23 3832 57 46 55 52 1 18 313 64 53 60 43 20 37 2258 33 62 15 54 35 2 1763 14 59 34 61 16 21 36 Press any key to continue5 总结调试过程中遇到的主要问题,是如何解决的;问题1:只走到63步原因:第64步就走完了,并且s[62]中只有一个元素,这个判断条件(s[step].base==s[step].top&&number(p2)==0)满足就进入了,而始终不能走完解决方法:改了判断条件,改为((s[step].base==s[step].top&&number(p2)==0)&&step!=n* n-1)解决方案:用InitStack(s1)初始化问题3:冒泡排序超出边界原因:循环次数大解决方案:减少循环次数看了其他同学,都差不多,我已经按马的下一位置最难的先走,再走难度次之的位置。
马踏棋盘课程设计实验报告
![马踏棋盘课程设计实验报告](https://img.taocdn.com/s3/m/6dab35f40722192e4436f695.png)
马踏棋盘课程设计实验报告《数据结构》课程设计实验报告课程名称: 《数据结构》课程设计课程设计题目: 马踏棋盘姓名: 邱可昉院系: 计算机学院专业: 计算机科学与技术班级: 10052313 学号: 10051319 指导老师: 王立波2012年5月18日1目录1.课程设计的目的...............................................................3 2.问题分析........................................................................3 3.课程设计报告内容 (3)(1)概要设计 (3)(2)详细设计 (3)(3)测试结果 (5)(4)程序清单...............................................................6 4.个人小结 (10)21.课程设计的目的《数据结构》是计算机软件的一门基础课程,计算机科学各领域及有关的应用软件都要用到各种类型的数据结构。
学好数据结构对掌握实际编程能力是很有帮助的。
为了学好《数据结构》,必须编写一些在特定数据结构上的算法,通过上机调试,才能更好地掌握各种数据结构及其特点,同时提高解决计算机应用实际问题的能力。
2.问题分析*问题描述:将马随机放在国际象棋的8X8棋盘Bo阿rd[0..7,0..7]的某个方格中,马按走棋规则进行移动。
要求每个方格上只进入一次,走遍棋盘上全部64个方格。
编制非递归程序,求出马的行走路线,并按求出的行走路线,将数字1,2,…,64依次填入8X8的方阵输出之。
*测试数据:由读者指定,可自行指定一个马的初始位置。
*实现提示:每次在多个可走位置中选择一个进行试探,其余未曾试探过的可走位置必须用适当结构妥善管理,以备试探失败时的“回溯”(悔棋)使用。
并探讨每次选择位置的“最佳策略”,以减少回溯的次数。
马踏棋盘数据结构报告参考模板
![马踏棋盘数据结构报告参考模板](https://img.taocdn.com/s3/m/1294581c941ea76e59fa0457.png)
《数据结构》课程设计报告课程设计题目:马踏棋盘姓名:张程浩院系:通信工程专业:信息安全年级:2011学号:11225104指导教师:任雪萍2012年11 月26 日(任雪萍编写)目录一、课程设计目的 (3)二、任务分析 (3)三、分析设计 (3)四、调试分析 (5)五、测试结果 (5)六、小结 (6)七、用户手册 (6)八、附录 (6)九、参考文献 (8)一、课程设计目的(1)熟练使用C语言编写程序,强化模块设计理念;(2)设计一个国际象棋马踏棋盘的演示程序。
(3)理解栈的特性“后进先出”和队列的特性“先进先出”。
(4)初步掌握软件开发过程的问题分析、系统设计、程序编码、测试等基本方法和技能;二、任务分析(1)要求:在国际象棋8×8棋盘上面,按照国际象棋规则中马的行进规则,实现从任意初始位置,每个方格只进入一次,走遍棋盘上全部64个方格。
编制程序,求出马的行走路线,并按求出的行走路线,将数字1,2,…,64依次填入一个8×8的方阵,并输出它的行走路线。
(2)输入:任意一个起始位置;输出:无重复踏遍棋盘的结果,以数字1-64表示行走路线。
三、分析设计●需要处理的数据的逻辑结构:线性结构●合适的存储结构:顺序储存●设计好的数据类型:#define BS 8 //棋盘大小typedef int Status;int step;int board[8][8]={0}; //定义棋盘int mayway[9]; //储存可能的路径int Htry1[8]={-2,-1,1,2,2,1,-1,-2},Htry2[8]={1,2,2,1,-1,-2,-2,-1};/*存储马各个出口位置相对当前位置列下标的增量数组*/typedef struct { //位置存储表达方式int i; //行坐标int j; //列坐标int from; //存储下一步所选方向}SElemType;typedef struct {SElemType *base; //在栈构造之前和销毁之后,base的值为NULLSElemType *top; //栈顶指针int stacksize; //当前已经分配的储存空间,以元素为单位}Stack;Stack Path;●本程序包含模块:1、主程序模块:void main(){定义变量;接受命令;处理命令;退出;}234、输出路径函数模块——输出马儿行走的路径;各模块之间的调用关系:●与功能对应的模块划分定义://构造一个空栈SStatus InitStack(Stack &s);//若栈不空,则用e返回s的栈顶元素,返回OK;否则返回ERRORStatus GetTop(Stack s,SElemType &e);//插入元素e为新的栈顶元素Status Push(Stack &s,SElemType e);//若栈不空,则删除s的栈顶元素,并用e返回其值,并返回OK;否则返回ERROR Status Pop(Stack &s,SElemType &e);//从栈底到栈顶依次对栈中每个元素输出。
数据结构课程设计-马踏棋盘实验报告(仅供参考)
![数据结构课程设计-马踏棋盘实验报告(仅供参考)](https://img.taocdn.com/s3/m/676cc53ca8956bec0875e311.png)
一、问题描述问题描述:将马随机放在国际象棋的8X8棋盘Bo阿rd[0..7,0..7]的某个方格中,马按走棋规则进行移动。
要求每个方格上只进入一次,走遍棋盘上全部64个方格。
编制非递归程序,求出马的行走路线,并按求出的行走路线,将数字1,2,…,64依次填入8X8的方阵输出之。
测试数据:由读者指定,可自行指定一个马的初始位置。
实现提示:每次在多个可走位置中选择一个进行试探,其余未曾试探过的可走位置必须用适当结构妥善管理,以备试探失败时的“回溯”(悔棋)使用。
并探讨每次选择位置的“最佳策略”,以减少回溯的次数。
二、实验目的熟练使用栈和队列解决实际问题;(1)了解并掌握数据结构与算法的设计方法,具备初步的独立分析和设计能力;(2)初步掌握软件开发过程的问题分析、系统设计、程序编码、测试等基本方法和技能;(3)提高综合运用所学的理论知识和方法独立分析和解决问题的能力;三、设计过程算法设计思想:根据分析先建了2个结构体struct PosType //马的坐标位置类型{int m_row; //行值int m_col; //列值};struct DataType //栈的元素类型8 17 26 35 4{PosType seat; //马在棋盘中的“坐标位置”int di; //换方向的次数};chess::chess()bool chess::chessPath(PosType start) //在棋盘中进行试探寻找下一步位置并同时记录位置,以及涉及到的入栈出栈void chess::Print() //打印马走的路径PosType chess::NextPos(PosType a,int di)//根据当前点的位置a和移动方向di,试探下一位置(1)、位置的存储表示方式typedef struct{int x;int y;int from;}Point;(2)、栈的存储方式#define STACKSIZE 70#define STACKINCREASE 10typedef struct Stack{Point *top;Point *base;int stacksize;};(3)设定栈的抽象数据类型定义:ADT Stack {数据对象:D={a i | a i∈ElemSet,i=1,2,…,n,n≥0}数据关系:R1={<a i-1 , a i>|a i-1, a i∈D,i=2,…,n}约定a n端为栈顶,a i端为栈顶。
马踏棋盘 数据结构实践报告
![马踏棋盘 数据结构实践报告](https://img.taocdn.com/s3/m/5e31ff3b67ec102de2bd8979.png)
马踏棋盘问题摘要:马踏棋盘就是在国际象棋8X8棋盘上面,按照国际象棋规则中马的行进规则,实现从任意初始位置,每个方格只进入一次,走遍棋盘上全部64个方格。
理解栈的“后进先出”的特性以及学会使用回溯。
关键字:马踏棋盘、递归、栈、回溯1.引言马踏棋盘就是在国际象棋8X8棋盘上面,按照国际象棋规则中马的行进规则,实现从任意初始位置,每个方格只进入一次,走遍棋盘上全部64个方格。
编制程序,求出马的行走路线,并按求出的行走路线,将数字1,2….64依次填入一个8X8的方阵,并输出它的行走路线。
输入:任意一个起始位置;输出:无重复踏遍棋盘的结果,以数字1-64表示行走路线。
2.需求分析(1)需要输出一个8X8的棋盘,可以采用二维数组的方法实现。
(2)输入马的起始位置,必须保证输入的数字在规定范围内,即0<=X<=7,0<=Y<=7。
(3)保证马能走遍整个棋盘,并且不重复。
(4)在棋盘上输出马的行走路线,标记好数字1、2、3直到64。
3.数据结构设计采用栈数组为存储结构。
#define maxsize 100struct{int i;int j;int director;}stack[maxsize];4.算法设计4.1 马的起始坐标void location(int x,int y) //马的位置坐标的初始化{top++;stack[top].i=x; //起始位置的横坐标进栈stack[top].j=y; //起始位置的竖坐标进栈stack[top].director=-1;a[x][y]=top+1; //标记棋盘Try(x,y); //探寻的马的行走路线}4.2 路径探寻函数void Try(int i,int j){ int count,find,min,director;int i1,j1,h,k,s;intb[8]={-2,-2,-1,1,2,2,1,-1},c[8]={1,-1,-2,-2,-1,1,2,2};//存储马各个出口相对当前位置行、列坐标的增量数组int b2[8],b1[8];for(h=0;h<=7;h++)//用数组b1[8]记录当前位置的下一个位置的可行路径的条数{ count=0;i=stack[top].i+c[h];j=stack[top].j+b[h];if(i>=0&&i<=7&&j>=0&&j<=7&&a[i][j]==0)//如果找到下一个位置{for(k=0;k<=7;k++){i1=i+c[k];j1=j+b[k];if(i1>=0&&i1<=7&&j1>=0&&j1<=7&&a[i1][j1]==0) //如果找到下一个位置count++; //记录条数}b1[h]=count; //将条数存入b1[8]中}}for(h=0;h<=7;h++)//根据可行路径条数的大小,从小到大排序,并放入数组b2[8]中{min=9;for(k=0;k<=7;k++)if(min>b1[k]){min=b1[k];b2[h]=k;s=k;}b1[s]=9;}find=0;director=stack[top].director;for(h=director+1;h<=7;h++)//向8个方向进行寻找{i=stack[top].i+c[b2[h]];j=stack[top].j+b[b2[h]];if(i>=0&&i<=7&&j>=0&&j<=7&&a[i][j]==0){stack[top].director=h; //存储栈的寻找方向top++; //进栈stack[top].i=i;stack[top].j=j;stack[top].director=-1;//重新初始化下一栈的方向a[i][j]=top+1;find=1; //找到下一位置break;}}if(find!=1){a[stack[top].i][stack[top].j]=0; //清除棋盘的标记top--; //退栈}if(top<63)Try(i,j); //递归}4.3输出函数void display(){int i,j;for(i=0;i<=7;i++){ for(j=0;j<=7;j++)printf("\t%d ",a[i][j]); //输出马的行走路线printf("\n\n");}printf("\n");}5.程序实现5.1 主函数void main(){int i,j,x,y;for(i=0;i<=7;i++) //棋盘的初始化for(j=0;j<=7;j++)a[i][j]=0;printf("输入X Y (0=<X<=7,0=<Y<=7)\n");scanf("%d%d",&x,&y);if(x>=0&&x<=7&&y>=0&&y<=7)//判断输入的起始位子是否正确{location(x,y);display();}else printf("错误\n");}5.2运行结果(1)当输入不符合要求时(2)正确输入时5.3 算法分析(1)马的起始坐标一开始先建立一个栈数组,里面包括横坐标和竖坐标还有方向。
数据结构课程设计 马踏棋盘分解
![数据结构课程设计 马踏棋盘分解](https://img.taocdn.com/s3/m/6ea945b727d3240c8547efaa.png)
杭州师范大学钱江学院课程设计2013 年12 月21 日目录一.概述 (3)二.总体方案设计 (3)三.详细设计 (4)四.最终输出 (6)五.课程设计总结 (10)参考文献 (13)一概述1.课程设计的目的(1)课题描述设计一个国际象棋的马踏遍棋盘的演示程序。
(2)课题意义通过“马踏棋盘”算法的研究,强化了个人对“栈”数据结构的定义和运用,同时也锻炼了自身的C语言编程能力。
另一方面,通过对“马踏棋盘” 算法的研究,个人对“迷宫”、“棋盘遍历”一类的问题,有了深刻的认识,为今后解决以此问题为基础的相关的问题,打下了坚实的基础。
(3)解决问题的关键点说明解决问题的关键首先要熟练掌握 C语言编程技术,同时能够熟练运用“栈”数据结构。
另外,态度也是非常重要的。
在课程设计过程中,难免会遇到困难,但是不能轻易放弃,要肯花时间,能静得下心,积极查阅相关资料,积极与指导老师沟通。
2.课程设计的要求(1)课题设计要求将马随机放在国际象棋的8X 8棋盘Board[0〜7][0〜7]的某个方格中,马按走棋规则进行移动。
要求每个方格只进入一次,走遍棋盘上全部64个方格。
编制非递归程序,求出马的行走路线,并按求出的行走路线,将数字1,2,…,64依次填入一个8X 8的方阵,输出之。
程序由回溯法和贪心法实现,比较两种算法的时间复杂度。
(2)课题设计的思路首先,搞清楚马每次在棋盘上有 8个方向可走,定义两个一位数组,来存储马下一着点的水平和纵向偏移量。
程序再定义一个8*8二维数组,初始所有元素置0,起始点元素置1。
若为回溯法,初始方向数据(一维数组下标) 入栈。
随后,马从起始点开始,每次首先寻找下一可行的着点,然后记下方向,方向数据入栈,把该位置元素置为合适的序列号,若无下一可行着点,则回溯,寻找下一方向位置着点,以此类推,直到 64填入数组中,则输出二维数组,即为马可走的方案。
若为贪婪法,选择下一出口的贪婪标准是在那些允许走的位置中,选择出口最少的那个位置。
数据结构课程设计(马踏棋盘)
![数据结构课程设计(马踏棋盘)](https://img.taocdn.com/s3/m/805ed311af45b307e8719762.png)
中南民族大学数据结构课程设计报告姓名:康宇年级: 2010学号: 10061014专业:计算机科学与技术指导老师:宋中山2013年4月15日实习报告:2.4题 马踏棋盘题目:设计一个国际象棋的马踏棋盘的演示程序班级:计科一班 姓名:康宇 学号:10061014 完成日期:2013.4.15 一、需求分析1、国际象棋的马踏棋盘的功能是:将马随机放在国际象棋的N*N 棋盘board[N][N]的某个方格中,马按走棋规则进行移动。
要求每个方格只进一次,走遍棋盘上全部N*N 个方格。
编制非递归程序,求出马的行走路线,并按求出的行走路线,将数字1,2,...,N*N 依次填入一个N*N 的方阵,输出之。
2、测试数据:N 由读者指定。
马开始的位置也有读者指定(x,y ),1<=x<=N,1<=y<=N.3、实现提示:下图显示了N 为6,马位于方格(3,3),8个可能的移动位置。
一般来说,马位于位置(x ,y )时,可以走到下列8个位置之一。
但是,如果(x,y )靠近棋盘的边缘,上述有些位置可能超出棋盘范围,成为不允许的位置。
8个可能的位置可以用两个一维数组hi[0...7],hj[0...7]来表示:1 2 3 4 5 6二、概要设计为实现上述程序功能,应用栈Stack[Max*Max]来表示棋盘的行和列。
定义棋盘的规格N,马在下一步可以走的8个位置,hi[0...7],hj[0...7],用数组board[Max][Max]来标记棋盘,top 标记栈指针。
用户在输入了期盼的规格和起始坐标后,程序通过八个方向的探寻,123456输出第一个符合要求的棋盘,棋盘上显示了马每一步的位置,每一个位置只踏了一次,且踏遍棋盘。
1、元素类型(栈):struct Stack{int i; //行坐标int j; //列坐标} stack[Max][ Max];2、建立三个全局位置数组:int hi[8]={-2,-1,1,2,2,1,-1,-2};int hj[8]={1,2,2,1,-1,-2,-2,-1};用来存放下一个可能位置的横纵坐标;int board[Max][Max];用来标记棋盘。
马的遍历VC课程设计报告.doc
![马的遍历VC课程设计报告.doc](https://img.taocdn.com/s3/m/c9b3530a767f5acfa1c7cdef.png)
马的遍历VC课程设计报告课程设计报告学院、系专业名称网络工程课程设计科目VC程序课程设计学生姓名指导教师完成时间2010年9月-11月解骑士巡游问题一、设计任务与目标国际象棋中马采用“日”字走法,对棋盘上马所在的结点,一步内到达的结点最多有八个,即假设马所在点的坐标为(i,j),那么其它八个结点的坐标为(i1,j2),(i2,j1),(i2,j-1),(i1,j-2),(i-1,j-2),(i-2,j-1),(i-2,j1),(i-1,j2)把这些点看作马所在点的邻接点,所以可以采用类似图的深度优先遍历,以马所在点为初始点对整个棋盘进行遍历。
然后按遍历的顺序输出结点棋盘的规格限制为8*8,输入数据为起始点的位置(0-7)。
输出数据为可以遍历成功的若干方案(本程序设置为至多八种)。
二、方案设计与论证解决马的遍历问题,可以用一个二维数组board[][]来表示棋盘,一开始用来存放步骤号,若走过了则把它赋值为1。
另对马的8种可能走法设定一个顺序,如当前位置在棋盘的(i,j)方格,下一个可能的位置依次为(i2,j1)、(i1,j2)、(i-1,j2)、(i-2,j1)、(i-2,j-1)、(i-1,j-2)、(i1,j-2)、(i2,j-1),实际可以走的位置尽限于还未走过的和不越出边界的那些位置。
为便于程序的同意处理,可以引入两个数组mover[]、movec[],分别存储各种可能走法对当前位置的纵横增量。
整形变量step存放步骤号,start存放遍历次数,在numable 函数和number函数中的语句kistartN;中是用于定位,保证不会超过棋盘范围和八次遍历都不会走同样的路径test存放遍历成功次数。
在88方格的棋盘上,从任意指定的方格出发,为马寻找一条走遍棋盘每一格并且只经过一次的一条路径。
程序框图或流程图,程序清单与调用关系主函数调用Number函数Next函数调用调用Numable函数函数调用关系2.重要模块(next 模块)的流程图开始Next[],num,num1,minnum,I,k 的初始化将返回下次可以查找的增量赋给num 判断num是否为0 是返回-1 否将i赋值为0 判断i是否小于num 否返回k 是给Num1赋值判断num小于1是否minnum 否是给Minnum和k赋值I 自增图2.2 流程图三、全部源程序清单include include include define N 8//棋盘行列数define INF 9999999 int mover[]{-2,-1,1,2,2,1,-1,-2};//用来表示要走向该i行,需要移动的格子数int movec[]{1,2,2,1,-1,-2,-2,-1};//用来表示要走向该j列,需要移动的格子数class qi { private int board[N1][N1];//用于保存走的次序int start;//测试次数int ber,bec;//用于保存输入(初始)的行列int step;//走的步数int test;//可以遍历成功的次数int r,c;//当前行列值int i,j;//循环变量int k;//下次可以查找的增量的个数public qi; qiint a,int b; int nextint r, int c; int numableint r,int c,int nexta[];//返回下次可以查找的增量int numberint r,int c;//返回下次可以查找的增量的个数bool beginint a,int b; void setint a,int b; }; qiqiint a,int b { bera; becb; } qiqi { } void qisetint a,int b { bera; becb; } int qinextint r,int c { int nexta[20],num,num10,minnum,i,k; minnumINF;//初始化minnum numnumabler,c,nexta;//下次可以查找的增量ifnum0 return -1; //没有出口fori0;iN*N//如果步数大于棋盘的格子数则表明遍历成功{ cout0 q.begina,b; coutc; ifc y ||c Y d1; else d0; system“cls“; } return 0; }四、程序运行的测试与分析因为本程序最大的特点就是可以将所有可遍历成功的路径都显示出来,所以我用了两组测试数据分别对有八种成功遍历路径和小于八种成功遍历路径的情况进行说明。
数据结构课程设计实习报告-马踏棋盘
![数据结构课程设计实习报告-马踏棋盘](https://img.taocdn.com/s3/m/cd950595312b3169a551a408.png)
数据结构课程设计实习报告题目:马踏棋盘(实习题 2.4 )班级:计算机科学与技术2004 班学031010151552010号:姓游尾妹名:日期:二OO五年七月八日指导老师:李杨老师源程序结构1. 定义函数caculate () 计算各点的权值dirctions () 求出各点的最佳方向序列,即优先向权值小的方向,以使运行速度加快 check (int i,int j ) 检查( i,j )是否在棋盘内print () 输出路径走过的序号2. 程序步骤简介(1) 计算各点的权值,方向(2) 用户输入行数和列数(3) 寻找点的八个可走方向,若所有方向都已走过,则退回前一步,并将此步 抹去,使前一步的方向发生变化。
( 4) 确定下一步该走的方向,依次走完全部点(5) 记录每一步(6) 当步数已满时输出,根据需要可输出一条或多条路径3. 源程序描述#include "stdio.h" #define N 8int w=0; /* 第几条可走路径 */int way1[8]={-2,-1,1,2, 2, 1,-1,-2};int way2[8]={ 1,2, 2,1,-1,-2,-2,-1}; /*在( i,j )位置处的 8 个可能走的位置 */ int ch[N*N]={0}; /*走过的相应的点的赋值 */int a[N*N+1][3]={0}; /* 路径所经过点的记录 */int dir[N][N][8];/* ( i,j )点的八个可能走的方向 */ int st=1; /* 走过的步数 *//* 每个点的权值 *//* 计算各点的权值 */ 求出各点的最佳方向序列,即优先向权值小的方向 /* 输出路径走过的序号 */ /* /*检查(i,j )是否在棋盘内*/ 计算各点的权值,将权值存在 weight[i][j] 中*//*int i,j,k;for(i=1;i<=N;i++)for(j=1;j<=N;j++) for(k=0;k<N;k++)char c='y'; int weight[N][N]; void caculate(); voiddirctions(); voidprint(); intcheck(int i,int j);void caculate() { */int x,y;x=i+way1[k];y=j+way2[k]; /* 下一步走的点 */if(x>=1&&x<=N&&y>=1&&y<=N)weight[i-1][j-1]++; /*权值 */ }}int check(int i,int j) /*检查 (i,j) 是否在棋盘内,在返回 1,不在返回 {if(i<1||i>8||j<1||j>8)return 0;return 1;}void directions() /* 求出各点的最佳方向序列,即优先向权值小的方向 {int i,j,k,m,n1,n2,x1,y1,x2,y2,way_1,way_2; for(i=0;i<N;i++)0*/ */ for(j=0;j<N;j++){ for(k=0;k<8;k++)dir[i][j][k]=k; for(k=0;k<8;k++) for(m=k+1;m<8;m++) { way_1=dir[i][j][k]; x1=i+way1[way_1];y1=j+way2[way_1];way_2=dir[i][j][m]; x2=i+way1[way_2];y2=j+way2[way_2];n1=check(x1+1,y1+1); n2=check(x2+1,y2+1);{/* 对每个方向考察看有没有更好的*//*k 方向时的下一个点 *//*m 方向时的下一个点 *//*判断 n1,n2 是否在棋盘内*/if(( n1==0 && n2)||( n1 && n2&&weight[x1][y1]>weight[x2][y2])) 到,而 m 方向可达到 */ || /*都可达到,但 m 方向权值小 *//*k 方向不可达 { dir[i][j][k]=way_2;dir[i][j][m]=w ay_1; 即权值小的一步) *//* 交换两个方向值,将 k 走更好的一步棋 }}void print() /* 输出路径走过的序号 */ {int x,y;printf("\n - %d answer --- \n",++w); for(x=1;x<N+1;x++) /*输出是第 w 条路径的序号 */printf("\n");printf("\n");}printf("\nPress n to quit ,press any other key to continue.\n"); c=getchar(); /* 询问是否继 续输出结果 */}main(){int x,y,way,way0; caculate();directions();printf("Please enter the row and column of the starting point.\n");scanf("%d,%d",&a[1][0],&a[1][1]); /* 输入行数和列数 */getchar();y=a[st][1];ch[(x-1)*N+y-1]=0; /* 将这一点被走过的痕迹抹去 */a[st][0]=a[st][1]=a[st][2]=0;a[st-1][2]++; /* 将上一次走的点走的方向发生变化 */st--; /* 步数减一 */}else /* 此点的八个方向未全走过,应走此方向 */{way0=a[st][2];a[st][2]++; /* 确定下次应走的方向 */ x=a[st][0];y=a[st][1]; way=dir[x-1][y-1][way0];x=a[st][0]+way1[way];y=a[st][1]+way2[way]; /* 确定按这次的方向走应走到的 x,y 坐标 */ if(x<1||y<1||x>N||y>N||ch[(x-1)*N+y-1]!=0)continue; /* 此点不满足要求 */ a[st][0]=x; a[st][1]=y;a[st][2]=0; if(st==N*N){ p rint(); /* 标记这一点*//* 步数已满 *//* 输出结果 */if(c=='n')break; a[st][0]=a[st][1]=a[st][2]=0;a[st-1][2]++;}}}}二、 程序运行结果 for(y=1;y<N+1;y++)printf("%2d ",ch[(x-1)*N+y-1]); x=a[1][0],y=a[1][1];ch[(x-1)*N+y-1]=1; while(1){if(a[1][2]>=8)break; if(a[st][2]>=8) { x=a[st][0]; /*在 ch 数组中对相应点赋值,即输出时用到的各点的顺序号/* 出发点的八个方向都已走过,表示所有的方法均已找出 此点的八个方向都已走过,应该退回到上一次走的点 */ */ */ ch[(x-1)*N+y-1]=++st; /* 走到这一点 */ch[(x-1)*N+y-1]=0;例如:输入数值为2,3 时,并且要求输入第2条路径(只按回车键即可)Please enter the row and column of the starting point.2,3---- 1 answer --2 29 54 15 12 31 56 1753 14 1 30 55 16 11 3228 3 52 13 64 61 18 5751 46 63 60 39 58 33 104 27 50 45 62 37 40 1949 24 47 38 59 44 9 3426 5 22 43 36 7 20 4123 48 25 6 21 42 35 8Press n to quit ,press any other key to continue.---- 2 answer --2 29 54 15 12 31 60 1753 14 1 30 55 16 11 3228 3 52 13 64 61 18 5951 46 63 56 39 58 33 104 27 50 45 62 37 40 1949 24 47 38 57 44 9 3426 5 22 43 36 7 20 4123 48 25 6 21 42 35 8Press n to quit ,press any other key to continue.。
数据结构课程设计马踏棋盘
![数据结构课程设计马踏棋盘](https://img.taocdn.com/s3/m/607779696529647d2628525a.png)
数据结构课程设计-马踏棋盘目录1 前言 (1)2 需求分析 (1)2.1 任务和要求 (1)2.2 运行环境 (1)2.3 开发工具 (1)3 分析和设计 (1)3.1 系统分析及设计思路 (1)3.2 主要数据结构及算法 (2)3.3 函数流程图 (2)4 具体代码实现 (10)5 课程设计总结 (17)5.1 程序运行结果 (17)5.2 设计结论 (17)参考文献 (20)致谢 (20)1 前言编写一个C语言程序,作为国际象棋中的马踏遍棋盘的演示程序。
在这里,我们用一个main函数通过调用其他一些分功能函数来实现求并且输出马踏遍棋盘的行走路线。
2 需求分析2.1 任务和要求将马随机放在国际象棋的8×8棋盘的某个方格中,马按照走棋的规则进行移动。
每个方格只进入一次,走遍棋盘的全部64个方格。
编写算法,求出马的行走路线,并按求出的行走路线,将1,2,…,64依次填入一个8×8的方阵,并输出。
要求:画出算法的流程图,分析算法的时间复杂度。
2.2 运行环境(1)WINDOWS2000/XP系统(2)Visual C++ 6.0编译环境或TC编译环境2.3 开发工具C语言3 分析和设计3.1 系统分析及设计思路根据需求分析可知,我们所设计的程序要达到让马从任意一起点出发都不重复地遍历所有的8×8棋格的功能。
按照需求,并考虑到程序的可读性,我们按顺序共设计了以下六大模块:(1)定义头文件和宏定义模块:这是C程序必不可少的一个部分,通过头文件来调用程序所需库函数,而通过宏定义进行宏替换。
(2) 数据类型定义模块:该模块定义了全局数据结构,它们的作用域为从定义开始到本源文件结束,以便于让后面很多函数都可以用到它们,而不必再重新定义。
(3) 探寻路径函数模块:按照马的行走规则对棋盘进行遍历,寻找马的行走路径,每次仅访问一个棋格,保证每个棋格都访问到且每个棋格仅访问一次。
(4) 输出路径函数模块:对探寻路径函数模块中保存下来的顺序进行输出,输出格式按照棋盘8×8的方阵格式。
棋盘游戏c课程设计报告
![棋盘游戏c课程设计报告](https://img.taocdn.com/s3/m/c283ab5ceef9aef8941ea76e58fafab068dc445f.png)
棋盘游戏c 课程设计报告一、课程目标知识目标:1. 学生能理解棋盘游戏的起源、种类及基本规则。
2. 学生掌握运用数学知识进行棋盘游戏策略分析,如概率、组合等基本概念。
3. 学生了解棋盘游戏在不同文化背景下的历史发展和应用。
技能目标:1. 学生能够运用所学知识设计简单的棋盘游戏,提高创新能力和逻辑思维能力。
2. 学生通过棋盘游戏实践,培养团队协作和沟通能力,提高解决问题的策略选择和决策能力。
3. 学生能够运用所学知识对棋盘游戏进行评价和改进,提高批判性思维和分析能力。
情感态度价值观目标:1. 学生通过棋盘游戏培养对数学学科的兴趣和热情,激发学习积极性。
2. 学生在棋盘游戏活动中,学会遵守规则、尊重对手,培养良好的竞争意识和合作精神。
3. 学生通过了解棋盘游戏的文化背景,增强对传统文化的尊重和传承意识。
课程性质:本课程为数学学科拓展课程,以棋盘游戏为载体,结合数学知识,培养学生综合素质。
学生特点:四年级学生具备一定的数学基础和逻辑思维能力,对游戏具有较强的兴趣和好奇心。
教学要求:教师需结合学生实际情况,以引导为主,激发学生兴趣,注重培养创新精神和实践能力。
在教学过程中,关注学生个体差异,因材施教,确保课程目标的实现。
通过有效的教学设计和评估,使学生在知识、技能和情感态度价值观方面取得具体的学习成果。
二、教学内容1. 棋盘游戏简介:介绍棋盘游戏的起源、种类及发展历程,关联教材中数学史相关章节,让学生了解棋盘游戏的文化价值。
2. 棋盘游戏规则与策略:结合教材中逻辑思维与策略制定相关内容,讲解典型棋盘游戏(如五子棋、国际象棋等)的基本规则及策略运用。
3. 数学知识在棋盘游戏中的应用:运用教材中的概率、组合等知识,分析棋盘游戏中的数学问题,提高学生的数学应用能力。
4. 设计与改进棋盘游戏:鼓励学生结合所学知识,创新设计棋盘游戏,关联教材中创新思维与问题解决相关内容,提升学生实践能力。
5. 棋盘游戏的评价与反思:指导学生运用所学知识对现有棋盘游戏进行评价和改进,结合教材中批判性思维相关内容,提高学生的分析能力。
马踏棋盘c++课程设计
![马踏棋盘c++课程设计](https://img.taocdn.com/s3/m/5e922363e55c3b3567ec102de2bd960591c6d976.png)
马踏棋盘c++课程设计1.问题描述设计一个国际象棋的马踏棋盘的演示程序2.需求分析(1)将马随即放在国际象棋的8×8棋盘Board[8][8]的某个方格中,马按走棋规则进行移动。
要求每个方格只进入一次,走遍棋盘上全部64个方格。
(2)编制非递归程序,求出马的行走路线,并按求出的行走路线,将数字1,2,……,64依次填入一个8×8的方阵,输出之。
(3)程序执行命令为:1)输入起始方格坐标(X,Y)2)求解第一组路径并显示,按Q键退出系统,按其他任意键求解并显示下一组路径。
(4)测试数据:(0,0),(1,2)3概要设计3.1[程序设计思路].按照顺时针顺序,每次产生一个新的路点,并验证此路点的可用性,需要考虑的问题包括是否超出棋盘和此点已经走过与否。
如新路点可用,则入栈,并执行下一步,每次按照上一路点的位置生成新路点。
如一个路点的可扩展路点数为0,则走不下去了,进行回溯。
3.2[存储结构设计]8个可能位置可以用两个一维数组表示:数组1: 0 1 2 3 4 5 6 7-2 -1 1 1221-1 -2数组2:0 1 2 3 4 5 6 71 2 2 1 -1 -2 -2 -1位于(i,j)的马可以走到的新位置是在棋盘范围内的(I+数组1[h],j+数组2[h]),其中h=0,1,…7。
每次在多个可走位置中选择其中一个进行试探,其中未曾试探过的可走位置用适当栈结构妥善管理,也备试探失败时的“回溯”(悔棋)使用,即用栈结构存储试探的路径来进行路径试探操作。
3.3[主要算法设计]3.3.1栈类的定义和接口:templateclass MyStack{private:Type *bottom; // 元素存放的动态数组int size,ptr; // 堆栈大小和当前栈顶元素索引inline int extent(){…}; //当栈满时,自动扩充public://构造函数MyStack() {bottom=new Type[BASESIZE];ptr=-1;size=BASESIZE;};//用默认大小初始化MyStack(int i) {bottom=new Type[i];ptr=-1;size=i;}; //用指定大小初始化//析构函数~MyStack(){if(bottom!=NULL) delete []bottom;};//清栈inline void clear(){…};//判栈空inline bool IsEmpty(){…};//入栈int push(Type e);//出栈int pop(Type &e);//获得栈顶元素int top(Type &e);//直接修改栈定元素int settop(Type e);// 用callback函数对栈从栈底向上遍历void traverse(void callback(Type *),Type *); };3.3.2本程序的结构1)主程序模块:void main(){初始化;向屏幕输出输入提示;接受输入起始坐标(X,Y);输出第一组解的路径和回溯情况;while(1){接受命令;处理命令{if(命令==退出)退出;其他命令{输出下一组解的路径及回溯情况;}}}异常处理{};正常退出;}2)路径求解模块---求解所有可行的路径3)可行路径求解的核心算法:bool Result(int start_x, int start_y, int board[][8]){初始化路径栈sPath;初始化方向栈sDir;初始化当前步数序号和当前方向step = 1, d = 0将点(start_x,start_y)入路径栈,将该点方向d入方向栈;while(1){将当前的路径栈中点出栈并保存,将该点方向出栈并保存;//为上一次的目标点和目标方向if(方向=>8){ 抹去该点痕迹;步数序号-1;调用MyStack的traverse函数演示退栈情况;退栈;方向栈中的方向++;continue;}if(方向<8)//方向未走完{if(目标点在棋盘内且未被走过){ 记录序号,目标点入栈,目标点方向初始为0入栈;continue;}else(目标点已被走过或目标点不在棋盘内){方向++;continue;//继续}}//enf if(d<8)if (步数序号已满){向屏幕输出路径if(查看下一路径){回退一步;方向++;continue;}}} //end while(1)}3.4[测试用例设计]依次输入(0,0)(1,2)4详细设计4.1堆栈类MyStack参见文件base 中MyStack模板类的定义和实现。
数据结构课程设计 马踏棋盘求全部解及演示程序
![数据结构课程设计 马踏棋盘求全部解及演示程序](https://img.taocdn.com/s3/m/ba92c7ce9ec3d5bbfd0a749a.png)
安徽工程大学信息10 课程设计马踏棋盘的求解及演示设计摘要数据结构是计算机科学与技术专业的一门核心专业基础课程,是一门理论性强、思维抽象、难度较大的课程。
我认为学习数据结构的最终目的是为了获得求解问题的能力。
对于现实世界中的问题,我们应该能从中抽象出一个适当的数学模型,该数学模型在计算机内部用相应的数据结构来表示,然后设计一个解此数学模型的算法,再进行编程调试,最后获得问题的解答。
《数据结构》课程设计是计算机科学技术专业集中实践性环节之一,是学习完《数据结构》课程后进行的一次全面的综合练习。
开设本课程设计实践的主要目的就是要达到理论与实际应用相结合,提高学生的动手能力,完成计算机应用能力的培养;本课程设计主要解决马踏棋盘的问题,找出踏遍棋盘的多种路径,并实现动态要是过程。
马踏棋盘问题,实际上是图论中的哈密顿通路问题,是典型的NP问题,求解的问题与算法设计有很大关系,如果采取穷举搜索的话,很容易陷入海量搜索的状态,耗费巨大的时间,使问题几乎不可解,因此马在棋盘上遍历采用算法当中的深度优先算法和启发式贪心算法,用栈来存储遍历过程,通过对栈的使用实现对所有路径的搜索。
在调试过程发现,启发式贪心算法,针对于马踏棋盘问题有着极大的好处,就是无论从棋盘上哪个点开始,找到一条遍历完棋盘的通路是不需要回溯的,也就节省了大量的时间,而试探性的操作对于每个点都也只有168步,所以求出所有路径在不到一秒的时间内完成。
关键词:马踏棋盘;骑士周游;哈密顿通路;NP-完全问题;贪心算法;回溯法;目录马踏棋盘的求解及演示设计 (1)目录 (2)第一章引言 (3)第二章需求分析 (4)2.1问题描述 (4)2.2基本要求 (4)2.3具体需求 (4)2.4开发环境 (4)第三章概要设计 (5)3.1 系统概述 (5)3.2 系统描述 (6)3.3逻辑设计 (6)第四章详细设计 (7)4.1 功能模块设计 (7)4.2 数据结构设计 (7)4.3算法设计 (9)第五章调试与分析 (13)5.1 调试分析 (13)第六章系统试用说明 (14)6.1 系统试用说明 (14)第七章总结与体会 (14)参考文献 (15)第一章引言本课程设计主要研究马踏棋盘的问题,即骑士周游问题,是将马随机放在国际象棋的8×8棋盘的某个方格中,“马”按照走棋规则进行移动,要求每个方格只进入一次,走遍棋盘上全部64个方格。
马踏棋盘课程设计摘要
![马踏棋盘课程设计摘要](https://img.taocdn.com/s3/m/21577d546d85ec3a87c24028915f804d2b168791.png)
马踏棋盘课程设计摘要一、课程目标知识目标:使学生掌握“马踏棋盘”问题中的基本算法原理,理解程序设计的顺序、选择和循环结构,掌握利用算法解决实际问题的方法。
技能目标:培养学生运用所学算法知识解决“马踏棋盘”问题的能力,提高学生的逻辑思维和编程技能,使其能独立编写并优化程序代码。
情感态度价值观目标:激发学生对计算机科学的兴趣,培养他们面对问题积极思考、勇于挑战的精神,增强团队协作意识,认识到合作解决问题的重要性。
课程性质:本课程以算法与程序设计为核心,结合实际操作,注重培养学生的动手能力和解决问题的能力。
学生特点:五年级学生已具备一定的逻辑思维能力和计算机操作技能,对新鲜事物充满好奇心,但需进一步引导和培养。
教学要求:结合学生特点,采用任务驱动教学法,引导学生自主探究、合作学习,实现课程目标。
将目标分解为具体学习成果,如:学生能独立编写“马踏棋盘”程序,并在课堂上展示和分享成果,以便进行教学评估。
二、教学内容本课程以《信息技术》教材中“算法与程序设计”章节为基础,结合“马踏棋盘”问题进行教学。
具体内容包括:1. 算法原理:介绍“马踏棋盘”问题的背景和基本算法原理,如贪心算法、回溯算法等。
2. 程序设计结构:回顾顺序、选择和循环结构,引导学生运用这些结构编写程序解决“马踏棋盘”问题。
3. 编程实践:指导学生使用编程软件(如Scratch或Python等)进行“马踏棋盘”程序编写和调试。
4. 算法优化:探讨优化算法的方法,如剪枝策略,提高程序的效率和性能。
教学大纲安排如下:第一课时:导入“马踏棋盘”问题,介绍算法原理,让学生了解课程目标。
第二课时:复习程序设计结构,引导学生思考如何运用这些结构解决问题。
第三课时:分组讨论,每组制定解决方案,开始编写程序。
第四课时:展示学生成果,互相评价,教师点评和指导,优化算法。
第五课时:总结课程,让学生分享学习心得,巩固所学知识。
教学内容与教材紧密关联,注重实践操作,旨在提高学生的编程能力和问题解决能力。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
实现顺序栈或循环队列的存储一、实验目的(1)、理解栈的特性“后进先出”和队列的特性“先进先出”。
(2)、仅仅认识到栈和队列是两种特殊的线性表是远远不够的,本次实验的目的在于更深入的了解栈和队列的特性,以便在实际问题背景下灵活运用他们。
(3)、在了解他特性的基础上,还将巩固对这种结构的构造方法的理解。
二、实验环境(1)Windows XP系统下(2)编程环境:VC6.0++三、实验内容(1)、要求:在国际象棋8×8棋盘上面,按照国际象棋规则中马的行进规则,实现从任意初始位置,每个方格只进入一次,走遍棋盘上全部64个方格。
编制程序,求出马的行走路线,并按求出的行走路线,将数字1,2,…,64依次填入一个8×8的方阵,并输出它的行走路线(棋盘如图所示)。
(2)、输入:任意一个起始位置;输出:无重复踏遍棋盘的结果,以数字1-64表示行走路线。
(3)、数据结构要求:采用顺序栈或者链栈实现。
四、实验步骤为了实现上述程序功能,可以采用顺序栈或者链栈来存储它的数据,本实验所需要的存储空间不是很大,不需动态的开辟很多空间,所以采用相对简单的顺序栈来存储数据,既方便有简单,而用链栈在实现上相对比顺序栈复杂的一点。
(一)、概要设计(1)、顺序栈的抽象数据类型定义:ADT Stack{数据对象:D={a i| a i∈(0,1,…,9),i=0,1,2,…,n,n≥0}数据关系:R={< a i-1, a i >| a i-1, a i∈D,i=1,2,…,n}} ADT Stack(2)本程序包含三个模块:1、主程序模块:void main(){定义变量;接受命令;处理命令;退出;}2、起始坐标函数模块——马儿在棋盘上的起始位置;3、探寻路径函数模块——马儿每个方向进行尝试,直到试完整个棋盘;4、输出路径函数模块——输出马儿行走的路径;(二)、详细设计(1)、定义头文件和预定义#include<stdio.h>#define MAXSIZE 100#define N 8(2)、数据类型定义int board[8][8]; //定义棋盘int Htry1[8]={1,-1,-2,2,2,1,-1,-2};/*存储马各个出口位置相对当前位置行下标的增量数组*/int Htry2[8]={2,-2,1,1,-1,-2,2,-1};/*存储马各个出口位置相对当前位置列下标的增量数组*/ struct Stack{ //定义栈类型int i; //行坐标int j; //列坐标int director; //存储方向}stack[MAXSIZE]; //定义一个栈数组int top=-1; //栈指针(3)、函数声明void InitLocation(int xi,int yi); //马儿在棋盘上的起始位置坐标int TryPath(int i,int j); //马儿每个方向进行尝试,直到试完整个棋盘void Display(); //输出马儿行走的路径(4)、起始坐标函数模块void InitLocation(int xi,int yi){int x,y; //定义棋盘的横纵坐标变量top++; //栈指针指向第一个栈首stack[top].i=xi; //将起始位置的横坐标进栈stack[top].j=yi; //将起始位置的纵坐标进栈stack[top].director=-1; //将起始位置的尝试方向赋初值board[xi][yi]=top+1; //标记棋盘x=stack[top].i; //将起始位置的横坐标赋给棋盘的横坐标y=stack[top].j; //将起始位置的纵坐标赋给棋盘的纵坐标if(TryPath(x,y)) //调用马儿探寻函数,如果马儿探寻整个棋盘返回1否则返回0 Display(); //输出马儿的行走路径elseprintf("无解");}(5)、探寻路径函数模块int TryPath(int i,int j){int find,director,number,min;//定义几个临时变量int i1,j1,h,k,s; //定义几个临时变量int a[8],b1[8],b2[8],d[8];//定义几个临时数组while(top>-1) //栈不空时循环{for(h=0;h<8;h++) //用数组a[8]记录当前位置的下一个位置的可行路径的条数{number=0;i=stack[top].i+Htry1[h];j=stack[top].j+Htry2[h];b1[h]=i;b2[h]=j;if(board[i][j]==0&&i>=0&&i<8&&j>=0&&j<8) //如果找到下一位置{for(k=0;k<8;k++){i1=b1[h]+Htry1[k];j1=b2[h]+Htry2[k];if(board[i1][j1]==0&&i1>=0&&i1<8&&j1>=0&&j1<8)//如果找到下一位置number++; //记录条数}a[h]=number; //将条数存入数组a[8]中}}for(h=0;h<8;h++) //根据可行路径条数小到大按下表排序放入数组d[8]中{min=9;for(k=0;k<8;k++)if(min>a[k]){min=a[k];d[h]=k; //将下表存入数组d[8]中s=k;}a[s]=9;}director=stack[top].director;if(top>=63) //如果走完整个棋盘返回1return (1);find=0; //表示没有找到下一个位置for(h=director+1;h<8;h++) //向八个方向进行探寻{i=stack[top].i+Htry1[d[h]];j=stack[top].j+Htry2[d[h]];if(board[i][j]==0&&i>=0&&i<8&&j>=0&&j<8) //如果找到下一位置{find=1; //表示找到下一个位置break;}}if(find==1) //如果找到下一个位置进栈{stack[top].director=director; //存储栈结点的方向top++; //栈指针前移进栈stack[top].i=i;stack[top].j=j;stack[top].director=-1; //重新初始化下一栈结点的尝试方向board[i][j]=top+1; //标记棋盘}else //否则退栈{board[stack[top].i][stack[top].j]=0; //清除棋盘的标记top--; //栈指针前移退栈}}return (0);}(6)输出路径函数模块void Display(){int i,j;for(i=0;i<N;i++){for(j=0;j<N;j++)printf("\t%d ",board[i][j]); //输出马儿在棋盘上走过的路径printf("\n\n");}printf("\n");}(5)主程序模块void main(){int i,j;int x,y;for(i=0;i<N;i++) //初始化棋盘for(j=0;j<N;j++)board[i][j]=0;for(;;){printf("Please input importpoint(1<=x<=8 and 1<=y<=8)\n");printf("Input x = ");scanf("%d",&x); //输入起始位置的横坐标printf("Input y = ");scanf("%d",&y); //输入起始位置的纵坐标if(x>=1&&x<=8&&y>=1&&y<=8)break;printf("Your input is worng\n");}printf("begin with %d board:\n\n", 8*(x-1)+y);InitLocation(x-1,y-1); //调用起始坐标函数}五、调试分析(1)、本次实验的主要目的是在于掌握和理解栈的特性和它的应用。
在编制该程序中遇到了很多问题。
首先,在开始刚编制程序的时候遇到的问题是,程序编译都通不过,主要在一些细节的问题上,还有在程序的返回值在刚开始时也没有正确返回。
经过编译慢慢调试,编译都能通过,没有错误和警告。
(2)、虽然编译都能通过,但是运行时却出错,程序不能终止,只有通过人工方式结束程序,可能是在某些地方出现了无限死循环了,然后在仔细检查代码,发现没有标记马儿尝试的方向director,这样的话,马儿回溯的时候,下一次又有可能走那个方向,这样就出现了死循环。
(3)、标记好马儿尝试的方向后,编译运行,但是运行结果却不符合程序所要求的结果,说明在算法上肯定有错误,检查发现,马儿走的坐标没有控制后,它的横纵坐标必须控制0到7之间,否则的话马儿就会踏出棋盘以外,这样输出的结果就不对。
还有就是棋盘走过的位置要标记一下,以便下次走不重复走,当回溯的时候的记得把标记给清掉,这个地方有时候也很容易混淆。
(4)、还有一点就是,该程序运算量大,算法复杂度高,所以运行的时候很慢,特别占内存,CPU的使用也很高,几乎都在70%到90%之间,配置低了可能还运行不了。
六、运行结果结果1:结果2:七、实验体会通过本次实验的编写,能够掌握栈的性质以及它的应用。
这次实验花了很多时间才完成,其实本应该早完成的,在检查的过程中有多多少少修改完美了一下,不过算法思想却没有改变。
这个程序也让我头疼了几次,就是运行速度很慢,要等很久才能输出结果,这样的话很占内存资源,而且CPU的使用记录也很高,主要是它需要的运算太多,所以CPU 使用记录也是很高的。
虽然我也参考了一些优化的算法,可以找到最优路进走,但是这些最优算法都和栈的应用失去了联系,本次的实验主要目的就是要了解栈,所以不用栈来写该程序就失去了该实验的意义。