马踏棋盘课程设计实验报告
数据结构 马踏棋盘 设计报告

《数据结构》课程设计报告课程名称:《数据结构》课程设计课程设计题目:姓名:院系:专业:年级:学号:指导教师: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循环,取出符合条件的栈顶元素。
利用函数,找出栈顶元素周围未被占用的新位置,如果有,新位置入栈;否则弹出栈顶元素。
第七次实验 马踏棋盘问题

#include<stdio.h>
#include<stdlib.h>
typedef struct
{
int x;
int y; //棋盘上的坐标
}Coordinate;
int chessboard[8][8];; //棋盘
int curstep; //马跳的步骤序号
Coordinate fangxiang[8]= //马可走的方向
桂林电子科技大学
数学与计算科学学院综合性、设计性实验报告
实验室:06406实验日期:2015年05月29日
院(系)
信息与计算科学系
年级、专业、班
1300710226
姓名
庞文正
成绩
课程
名称
数据结构实验
实验项目
名 称
马踏棋盘问题
指导
教师
教师
评语
教师签名:
年 月 日
一 ,实验目的
加深对图的理解,培养解决实际问题的编程能力。根据数据对象的特性,学会数据组织的方
19(4,4)
20(5,4)
11(1,3)
12(2,3)
13(3,3)
14(4,3)
15(5,3)
6(1,2)
7(2,2)
8(3,2)
9(4,2)
10(5,2)
1(1,1)
2(2,1)
3(3,1)
பைடு நூலகம்4(4,1)
5(5,1)
综合起来,马踏棋盘问题就可以转化为图的遍历问题。
三,使用仪器,材料
XP系统电脑一台,vc++软件!
{
printf("输入数值越界,请重新输入!\n");
马踏棋盘的实习报告

马踏棋盘的实习报告实习报告:马踏棋盘一、实习单位及实习岗位简介实习单位:ABC软件公司实习岗位:算法工程师助理二、实习内容和任务作为算法工程师助理,我的主要任务是协助开发团队完成一个名为“马踏棋盘”的小游戏的设计和实现。
该游戏是基于棋盘上的骑士的移动规则进行设计的。
具体任务及完成情况如下:1.学习和理解“马踏棋盘”游戏的规则。
在开始设计游戏之前,首先需要深入了解和理解“马踏棋盘”的规则。
通过查阅相关资料和与开发团队成员的讨论,我对游戏规则有了初步的认识和理解。
2.设计游戏的棋盘和角色。
根据游戏规则的要求,我与开发团队成员一起设计和绘制了游戏的棋盘和角色。
棋盘采用8*8的方格,并且在其中的随机位置放置了一些障碍物,增加游戏的难度和挑战性。
角色则是一个具有代表骑士的形象的图标。
3.实现骑士的移动和规则判断。
在游戏中,骑士可以根据特定的移动规则在棋盘上移动。
根据游戏规则的要求,我编写了相应的算法,实现了骑士的移动和规则判断的功能。
通过这个功能,用户可以通过点击棋盘上的方格,移动骑士来完成游戏的目标。
4.添加游戏的界面和交互。
除了基本的游戏功能以外,我们还为游戏设计了用户友好的界面和交互。
通过游戏界面,用户可以清楚地看到棋盘和角色的位置,并且可以通过点击方格或者使用方向键来控制骑士的移动。
同时,我们还添加了计时器和得分系统,提升了游戏的趣味性和挑战性。
5.进行游戏的测试和优化。
为了确保游戏的稳定性和良好的体验效果,我们进行了多轮的测试和优化。
通过不断地发现和修复bug,我们最终完成了一个可以正常运行、界面友好、操作流畅的游戏。
三、实习收获和体会在这次实习中,我通过与开发团队的合作,深入了解了算法在游戏开发中的应用。
通过参与“马踏棋盘”游戏的设计和实现,我不仅加深了对算法和数据结构的理解,在实践中熟悉了常用的算法编程技巧,还提升了团队协作和解决问题的能力。
通过这次实习,我深刻体会到了算法在实际项目中的重要性和应用价值。
马踏棋盘实习报告

一、实习背景马踏棋盘问题是一个经典的算法问题,也是数据结构课程中的一个重要实验。
通过对马踏棋盘问题的研究和实现,可以加深对栈和队列这两种抽象数据类型的理解,提高算法设计能力和编程能力。
本次实习旨在通过编程实现马踏棋盘问题,并分析其算法的复杂度和优化策略。
二、实习目的1. 理解马踏棋盘问题的背景和意义;2. 掌握栈和队列的应用,以及它们在解决实际问题中的作用;3. 提高算法设计能力和编程能力;4. 分析马踏棋盘问题的算法复杂度,并尝试优化算法。
三、实习内容1. 马踏棋盘问题介绍马踏棋盘问题是指在8x8的国际象棋棋盘上,将一匹马随机放在棋盘上的一个位置,然后按照国际象棋的走法,即“日”字形移动,使得马能够走遍棋盘上的所有方格。
要求使用非递归的方式实现。
2. 栈和队列的应用在解决马踏棋盘问题时,我们可以使用栈来存储马走过的路径,使用队列来实现广度优先搜索(BFS)策略,以寻找马的所有可能走法。
3. 算法实现(1)初始化棋盘和路径栈首先,我们需要初始化一个8x8的二维数组来表示棋盘,并将起始位置设置为(0,0)。
同时,创建一个栈来存储马走过的路径。
(2)定义马的移动规则根据国际象棋的规则,马可以走到以下八个位置之一:(-2,-1),(-2,1),(-1,-2),(-1,2),(1,-2),(1,2),(2,-1),(2,1)在实现时,我们需要判断这些位置是否在棋盘范围内,以及是否已经走过。
(3)广度优先搜索使用队列来实现广度优先搜索策略,从起始位置开始,按照BFS的顺序,依次尝试马的所有可能走法。
每走一步,就将新的位置压入栈中,并更新队列。
(4)输出结果当队列中所有位置都尝试过一遍后,栈中的路径即为马的行走路线。
按照路径输出棋盘上的数字,即可得到最终结果。
4. 算法优化为了提高算法的效率,我们可以考虑以下优化策略:(1)使用邻接矩阵来表示棋盘,减少重复计算;(2)在遍历队列时,优先考虑距离起始位置较近的位置;(3)在遍历过程中,避免重复访问已经访问过的位置。
马踏棋盘的实习报告

马踏棋盘实习报告题目:设计一个国际象棋的马踏遍棋盘的演示程序班级:姓名:学号:完成日期:一.需求分析将马随机放在m*n棋盘Board[m][n]的某个方格中,马按国际象棋行棋的规则进行移动。
要求每个方格只行走一次,走遍棋盘上全部m*n个方格。
编写非递归程序,求出马的行走路线,并按求出的行走路线,将数字1, 2, . m*n依次填入-一个m*n的方阵中。
程序要求:在国际象棋8×8棋盘上面,按照国际象棋规则中马的行进规则,实现从任意初始位置,每个方格只进入一次,走遍棋盘上全部64个方格。
编制程序,求出马的行走路线,并按求出的行走路线,将数字1,2,…,64依次填入一个8×8的方阵,并输出它的行走路线。
输入:任意一个起始位置;输出:无重复踏遍棋盘的结果,以数字1-64表示行走路线。
二.概要设计棋盘可用二维数组表示,马踏棋盘问题可采用回溯法解题。
当马位于棋盘某-位置时,它有唯一坐标,根据国际象棋的规则,它 6 7有8个方向可跳,对每一方向逐探测,从中选择可行方向继续行棋,每一行棋坐标借助栈记录。
若8个方向均不可行则借助栈回溯,在前一位置选择下一可行方向继续行棋,直至跳足m*n步,此时成功的走步记录在栈中。
或不断回湖直至栈空失败。
关于栈的抽象数据类型定义:否则返回ERRORPushStack( &s,SElemType e);操作结果:插入元素e为新的栈顶元素PopStack (&s,SElemType &e);操作结果:若栈不空,则删除s的栈顶元素,并用e返回其值,并返回OK;否则返回ERROR本程序包含以下模块:主程序模块:void main(){定义变量;接受命令;处理命令;退出;}起始坐标函数模块——马儿在棋盘上的起始位置;搜索路径函数模块——马儿每个方向进行尝试,直到试完整个棋盘;输出路径函数模块——输出马儿行走的路径模块调用关系:函数调用关系:三.详细设计#define OK 1#define TRUE 1#define ERROR 0#define FALSE 0#define M 8#define N 8int direction[2][9]={{0,-2,-1,1,2,2,1,-1,-2},{0,1,2,2,1,-1,-2,-2,-1}}; //增量数组int pow[M][N];int check[M][N],next[M][N]; //创建棋盘,初始为0struct Element //数据域{int x,y; //x行,y列int d; //下一步的方向};typedef struct LStack //链栈}*PLStack;typedef struct check //定义棋盘内点的坐标{int x;int y;}Check;/*************栈函数****************/ int InitStack(PLStack &S)//构造空栈{S=NULL;return OK;}int StackEmpty(PLStack S)//判断栈是否为空{if(S==NULL)return OK;elsereturn FALSE;}int Push(PLStack &S, Element e)//元素入栈PLStack p;p=(PLStack)malloc(sizeof(LStack));p->data=e;p->next=S;S=p;return OK;}int Pop(PLStack &S,Element &e) //元素出栈{PLStack p;if(!StackEmpty(S)){e=S->data;p=S;S=S->next;free(p);return OK;}/********贪心权值函数********/void Printf(int p[M][N]){ //打印权值数组for(int i=0;i<M;i++){for(int j=0;j<N;j++)printf(" %2d ",p[i][j]);printf("\n");}}void InitWeight(){ //创建权值数组并初始化每个位置的权值for(int i=0;i<M;i++)for(int j=0;j<N;j++)pow[i][j]=0;for(int i=0;i<M;i++){for(int j=0;j<N;j++){for(int dir=1;dir<=8;dir++){int x1=i+direction[0][dir];int y1=j+direction[1][dir];if(x1>=0&&x1<=7&&y1>=0&&y1<=7)pow[i][j]++;}}}}void SetWeight(int x,int y) { //位置(x,y)设置为被占用时,修改权值数组,被占用时为9pow[x][y]=9;for(int dir=1;dir<=8;dir++){int x1=x+direction[0][dir];int y1=y+direction[1][dir];if(x1>=0&&x1<=7&&y1>=0&&y1<=7&& pow[x1][y1]!=9)pow[x1][y1]--;}}void UnSetWeight(int x,int y){ //位置(x,y)设置为未占用时,修改权值数组for(int dir=1;dir<=8;dir++){ int x1=x+direction[0][dir];struct Element t,data;int pow_min=9;for(int dir=1;dir<=8;dir++){ //探测下一步可走的方向int x1=x+direction[0][dir];int y1=y+direction[1][dir];if(x1>=0&&x1<=7&&y1>=0&&y1<=7&& pow[x1][y1]!=9){if(pow_min>pow[x1][y1])//找出下一步位置中权值最小的{pow_min=pow[x1][y1];t.d=dir; //上一步的方向t.x=x1;t.y=y1;}}}data.x=x; //入栈data.y=y;data.d=t.d;Push(H,data);x=t.x; //坐标更新y=t.y;i++; //步数增加}PLStack H;InitStack(H);Check start;printf("请输入起始坐标x y:");scanf("%d%d",&start.x,&start.y);Step(start,H);Printf(check);return 0;}四.调试分析1.刚开始的时候并没有采用贪心算法,时间复杂度很大,探测量也很大。
棋盘算法实验报告(3篇)

个人自我介绍简单大方
很抱歉,但我无法为您提供____字的自我介绍。
以下是一个简洁而大方的自我介绍示例,供您参考:
大家好,我叫[姓名]。
很高兴有机会向大家介绍一下自己。
我出生并长大在[所在地],是一个勤奋、积极向上的人。
在学业方面,我于[毕业时间]从[学校名称]获得了[学位/专业]学位。
在大学期间,我通过自我努力和课外学习,取得了良好的学术成绩,并参与了一些学生组织和社团活动。
这些经历不仅培养了我的团队合作和领导能力,也加强了我的沟通和组织能力。
在工作方面,我有[工作年限]年的相关工作经验。
我曾在[公司/组织名称]担任[职位],负责[工作职责]。
在这期间,我不断努力提升自己的专业知识和技能,以适应快速发展的工作环境。
我善于分析问题并找出解决方案,能够有效地与团队合作并承担责任,这些都为我赢得了同事和上级的认可。
除了工作,我也积极参与志愿者活动,希望能为社区和弱势群体做一点贡献。
我相信,通过奉献和关心他人,我们可以建立一个更加和谐和温暖的社会。
在个人生活中,我喜欢阅读、旅行和运动。
阅读扩展了我的视野,旅行让我能够体验不同的文化和风景,而运动则让我保持健康和积极的精神状态。
此外,我也很喜欢与家人和朋友相处,分享彼此的喜怒哀乐。
总的来说,我是一个热情、乐观、有责任心的人。
我相信勤奋和坚持可以取得成功,而真诚和善良可以赢得他人的信任和支持。
我希望能够在您的团队中发挥我的才能,并与大家一同成长和进步。
这就是我简单的自我介绍,谢谢大家!。
数据结构课程设计-马踏棋盘实验报告(仅供参考)

一、问题描述问题描述:将马随机放在国际象棋的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端为栈顶。
马踏棋盘 数据结构实践报告

马踏棋盘问题摘要:马踏棋盘就是在国际象棋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)马的起始坐标一开始先建立一个栈数组,里面包括横坐标和竖坐标还有方向。
实验报告马踏棋盘

2.4题马踏棋盘题目:设计一个国际象棋的马踏棋盘的演示程序班级::学号:完成日期:一.需求分析(1)输入的形式和输入值的围:输入马的初始行坐标X和列坐标Y,X和Y的围都是[1,8]。
(2)输出形式:以数组下表的形式输入,i为行标,j为列标,用空格符号隔开。
以棋盘形式输出,每一格打印马走的步数,这种方式比较直观(3)程序所能达到的功能:让马从任意起点出发都能够遍历整个8*8的棋盘。
(4)测试数据,包括正确输入及输出结果和含有错误的输入及其输出结果。
数据可以任定,只要1<=x,y<=8就可以了。
正确的输出结果为一个二维数组,每个元素的值表示马行走的第几步,若输入有错,则程序会显示:“输入有误!请重新输入……”并且要求用户重新输入数据,直至输入正确为止。
二.概要设计(1)、位置的存储表示方式(2) typedef struct {int x;int y;int from;}Point;(2)、栈的存储方式#define STACKSIZE 70#define STACKINCREASE 10typedef struct Stack {Point *top;Point *base;int stacksize;};(1)、设定栈的抽象数据类型定义: ADT Stack {数据对象:D={ai | ai∈ElemSet,i=1,2,…,n,n≥0}数据关系:R1={<ai-1 , ai>|ai-1, ai∈D,i=2,…,n} 约定an端为栈顶,ai端为栈顶。
基本操作:InitStack(&s)操作结果:构造一个空栈s,DestroyStack(&s)初始条件:栈s已存在。
操作结果:栈s被销毁。
ClearStack(&s)初始条件:栈s已存在。
操作结果:栈s清为空栈。
StackEmpty(&s)初始条件:栈s已存在。
操作结果:若栈s为空栈,则返回TRUE,否则返回FALSE。
数据结构课程设计(马踏棋盘)

中南民族大学数据结构课程设计报告姓名:康宇年级: 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];用来标记棋盘。
数据结构课程设计实习报告-马踏棋盘

数据结构课程设计实习报告题目:马踏棋盘(实习题 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.。
马踏棋盘的实习报告

马踏棋盘实习报告题目:设计一个国际象棋的马踏遍棋盘的演示程序班级:姓名:学号:完成日期:一.需求分析将马随机放在m*n棋盘Board[m][n]的某个方格中,马按国际象棋行棋的规则进行移动。
要求每个方格只行走一次,走遍棋盘上全部m*n个方格。
编写非递归程序,求出马的行走路线,并按求出的行走路线,将数字1, 2, . m*n依次填入-一个m*n的方阵中。
程序要求:在国际象棋8×8棋盘上面,按照国际象棋规则中马的行进规则,实现从任意初始位置,每个方格只进入一次,走遍棋盘上全部64个方格。
编制程序,求出马的行走路线,并按求出的行走路线,将数字1,2,…,64依次填入一个8×8的方阵,并输出它的行走路线。
输入:任意一个起始位置;输出:无重复踏遍棋盘的结果,以数字1-64表示行走路线。
二.概要设计棋盘可用二维数组表示,马踏棋盘问题可采用回溯法解题。
当马位于棋盘某-位置时,它有唯一坐标,根据国际象棋的规则,它 6 7有8个方向可跳,对每一方向逐探测,从中选择可行方向继续行棋,每一行棋坐标借助栈记录。
若8个方向均不可行则借助栈回溯,在前一位置选择下一可行方向继续行棋,直至跳足m*n步,此时成功的走步记录在栈中。
或不断回湖直至栈空失败。
关于栈的抽象数据类型定义:否则返回ERRORPushStack( &s,SElemType e);操作结果:插入元素e为新的栈顶元素PopStack (&s,SElemType &e);操作结果:若栈不空,则删除s的栈顶元素,并用e返回其值,并返回OK;否则返回ERROR本程序包含以下模块:主程序模块:void main(){定义变量;接受命令;处理命令;退出;}起始坐标函数模块——马儿在棋盘上的起始位置;搜索路径函数模块——马儿每个方向进行尝试,直到试完整个棋盘;输出路径函数模块——输出马儿行走的路径模块调用关系:函数调用关系:三.详细设计#define OK 1#define TRUE 1#define ERROR 0#define FALSE 0#define M 8#define N 8int direction[2][9]={{0,-2,-1,1,2,2,1,-1,-2},{0,1,2,2,1,-1,-2,-2,-1}}; //增量数组int pow[M][N];int check[M][N],next[M][N]; //创建棋盘,初始为0struct Element //数据域{int x,y; //x行,y列int d; //下一步的方向};typedef struct LStack //链栈}*PLStack;typedef struct check //定义棋盘内点的坐标{int x;int y;}Check;/*************栈函数****************/ int InitStack(PLStack &S)//构造空栈{S=NULL;return OK;}int StackEmpty(PLStack S)//判断栈是否为空{if(S==NULL)return OK;elsereturn FALSE;}int Push(PLStack &S, Element e)//元素入栈PLStack p;p=(PLStack)malloc(sizeof(LStack));p->data=e;p->next=S;S=p;return OK;}int Pop(PLStack &S,Element &e) //元素出栈{PLStack p;if(!StackEmpty(S)){e=S->data;p=S;S=S->next;free(p);return OK;}/********贪心权值函数********/void Printf(int p[M][N]){ //打印权值数组for(int i=0;i<M;i++){for(int j=0;j<N;j++)printf(" %2d ",p[i][j]);printf("\n");}}void InitWeight(){ //创建权值数组并初始化每个位置的权值for(int i=0;i<M;i++)for(int j=0;j<N;j++)pow[i][j]=0;for(int i=0;i<M;i++){for(int j=0;j<N;j++){for(int dir=1;dir<=8;dir++){int x1=i+direction[0][dir];int y1=j+direction[1][dir];if(x1>=0&&x1<=7&&y1>=0&&y1<=7)pow[i][j]++;}}}}void SetWeight(int x,int y) { //位置(x,y)设置为被占用时,修改权值数组,被占用时为9pow[x][y]=9;for(int dir=1;dir<=8;dir++){int x1=x+direction[0][dir];int y1=y+direction[1][dir];if(x1>=0&&x1<=7&&y1>=0&&y1<=7&& pow[x1][y1]!=9)pow[x1][y1]--;}}void UnSetWeight(int x,int y){ //位置(x,y)设置为未占用时,修改权值数组for(int dir=1;dir<=8;dir++){ int x1=x+direction[0][dir];struct Element t,data;int pow_min=9;for(int dir=1;dir<=8;dir++){ //探测下一步可走的方向int x1=x+direction[0][dir];int y1=y+direction[1][dir];if(x1>=0&&x1<=7&&y1>=0&&y1<=7&& pow[x1][y1]!=9){if(pow_min>pow[x1][y1])//找出下一步位置中权值最小的{pow_min=pow[x1][y1];t.d=dir; //上一步的方向t.x=x1;t.y=y1;}}}data.x=x; //入栈data.y=y;data.d=t.d;Push(H,data);x=t.x; //坐标更新y=t.y;i++; //步数增加}PLStack H;InitStack(H);Check start;printf("请输入起始坐标x y:");scanf("%d%d",&start.x,&start.y);Step(start,H);Printf(check);return 0;}四.调试分析1.刚开始的时候并没有采用贪心算法,时间复杂度很大,探测量也很大。
马踏棋盘c++课程设计

马踏棋盘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模板类的定义和实现。
1实验题目马踏棋盘

1:实验题目:马踏棋盘,2:实验目的:队列和栈的操作练习:3:实验具体内容:设计一个国际象棋的马踏遍棋盘的演示程序。
将马随机放在国际象棋8x8棋盘Board[8][8]的某个方格中,马按走棋规则进行移动。
要求每个方格只进入一次,走遍棋盘上全部64个方格。
编制非递归程序,求出马的行走路线,并按求出的行走路线,将数字1,2,…,64依次填入一个8x8的方阵,输出之。
矚慫润厲钐瘗睞枥庑赖賃軔。
4:数据结构算法思想:数据结构:简单的结构体和相关数组;算法思想:a :首先定义一个8*8的数组用于存放马的跳步过程;定义方向结点;b :获得马的第一个踩入点,调用findway()函数,该函数的while()语句将获得下一个要踩入的结点坐标,该过程调用pathnum()函数(注解:该函数给出了可踩入的所有结点各自的路径数目); 在findway()中,选择的要进入的下一个结点就是在pathway()中找到的结点(注解:该结点是可跳入的所有结的中路径最少的一个);聞創沟燴鐺險爱氇谴净祸測。
c : 在每步踩入前,将该结点的下标和踩入的次序做记录并输出;d : 读取最后一个结点的相关信息;5:模块划分:6:详细设计及运行结果:A:定义一个8*8的数组,用于存放每次踩入的结点位置;B:获取第一个踩入点;C:调用findway()函数Findway() 函数功能介绍:定义一个结点类型数组,用于存放8个下一步可踩入结点的信息;期间调用pathnum() 函数,该函数功能是记录所有下一个可踩入结点的可执行路径数目);选择下一个结点中路径最少的结点为下一个踩入的结点;在进入下一个踩入点前,先保存该结点的信息并输出,然后依次寻找下一个结点;残骛楼諍锩瀨濟溆塹籟婭骒。
D:寻找最后一个结点,并赋给相应信息;运行结果如下:7:调试情况,设计技巧和相关方法:A : 该开始想着利用栈的数据结构,记录回溯的相关信息,后来查资料发现如果每次入结点路径最少的那个结点,根本不会产生回溯的过程,后来就省去了栈队列的应用;酽锕极額閉镇桧猪訣锥顧荭。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
马踏棋盘课程设计实验报告《数据结构》课程设计实验报告课程名称: 《数据结构》课程设计课程设计题目: 马踏棋盘姓名: 邱可昉院系: 计算机学院专业: 计算机科学与技术班级: 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的方阵输出之。
*测试数据:由读者指定,可自行指定一个马的初始位置。
*实现提示:每次在多个可走位置中选择一个进行试探,其余未曾试探过的可走位置必须用适当结构妥善管理,以备试探失败时的“回溯”(悔棋)使用。
并探讨每次选择位置的“最佳策略”,以减少回溯的次数。
3.课程设计报告内容(1)概要设计定义一张棋盘,定义一个栈保存马走的路径的点坐标和来自方向,用函数计算周围可走坐标,并检查正确性,当周围没有可走格子时退栈到最优位置,继续进行,然后将路径输出。
(2)详细设计定义结构体,方向数组和Qioan类struct Point{int x; //记录横坐标int y; //记录纵坐标int from; //前一个位置的方向};Point side[8]={0,0,0}; //记录可能的方向坐标class Qipan{public:Qipan();~Qipan();void Setside(Point); //设置方向坐标bool Getside(int,Point &); //将指定方向的坐标给特定指针bool HorseVisit(Point); //输入开始点运行棋盘bool Pass(Point); //输出路径private:int **gezi; //棋盘格子};3然后对每个函数进行定义Qipan::Qipan(){ //构造函数构建棋盘……}Qipan::~Qipan(){ //销毁棋盘……}void Qipan::Setside(Point cur){ //根据输入的当前点设置下一个点的可能方向坐标……}bool Qipan::Getside(int i,Point &next ) { //根据方向把将坐标赋给下一个点……}bool Qipan::HorseVisit(Point begin){ //棋盘运行……}最后是主函数,设计一些用户界面int main(){bool s=true;while(s){int count=0;int gezi[8][8]={0};Point begin;cout<<"请输入马的初始位置x和y:";cout<<endl;cout<<"其中1<=x,y<=8,如:1 1 "<<endl;cout<<"输入:" ;cin>>begin.x>>begin.y; //输入起始点,并判断正确性while(begin.x>8||begin.x<1||begin.y>8||begin.y<1){ cout<<"输入有误,请重新输入x和y:"<<endl;cout<<"其中1<=x,y<=8,如:1 1 "<<endl;cout<<"输入:" ;cin>>begin.x>>begin.y;}begin.x--;begin.y--;begin.from=0;Qipan A; //定义Qipan类的对象As=A.HorseVisit(begin); //A运行函数HorseVisit}return 0;}4(3)测试结果对于一次死路后退栈次数进行测试1次用时很长且为运行出来 2次3次4次5次6次5又测试了其他几个点得出一次死路退栈5次能尽量少的减少退栈次数其他几个点的数据(4)程序清单#include<iostream>#include "SqStack.h"6using namespace std;#define MAXSIZE 70 #define N 8struct Point{int x; //记录横坐标int y; //记录纵坐标int from; //前一个位置的方向};Point side[8]={0,0,0}; //记录可能的方向坐标class Qipan{public:Qipan();~Qipan();void Setside(Point); //设置方向坐标bool Getside(int,Point &); //将指定方向的坐标给特定指针bool HorseVisit(Point); //输入开始点运行棋盘bool Pass(Point); //输出路径 private:int **gezi; //棋盘格子 };Qipan::Qipan(){ //构造函数构建棋盘int i,j;gezi = new int *[N];for(i=0; i<N; i++){gezi[i]=new int[N];}for(i=0; i<N; i++)for(j=0; j<N; j++)gezi[i][j]=0;}Qipan::~Qipan(){ //销毁棋盘for(int i=0; i<N;i++) {if(gezi[i]==NULL)delete[] gezi[i];}if(gezi==NULL)delete[] gezi;}void Qipan::Setside(Point cur){ //根据输入的当前点设置下一个点的可能方向坐标7Point round[] = { {cur.x-2,cur.y-1,0},{cur.x-1,cur.y-2,0},{cur.x+1,cur.y-2,0},{cur.x+2,cur.y-1,0},{cur.x+2,cur.y+1,0},{cur.x+1,cur.y+2,0},{cur.x-1,cur.y+2,0},{cur.x-2,cur.y+1,0},};for(int i=0;i<8;i++) {side[i].x = round[i].x;side[i].y = round[i].y;}}bool Qipan::Getside(int i,Point &next ) { //根据方向把将坐标赋给下一个点next.x = side[i-1].x;next.y = side[i-1].y;if(next.x<0 || next.y<0 || next.x>7 || next.y>7) //判断坐标正确性return false;elsereturn true;}bool Qipan::HorseVisit(Point begin){ //棋盘运行SqStack<Point> horseVisit(MAXSIZE); //新建栈int count=1; //定义count初始值为1,用于记录棋盘步数char yn; //用于根据用户输入来选择执行或退出程序bool s; //通过yn来改变s真值改变程序运行int cc[65]={0}; //保存棋盘路径Point cur,next; //定义当前点,下一个点horseVisit.Push(begin); //把起始点压栈gezi[begin.x][begin.y]=count; //在棋盘上记录步数while(count<64) { //后续63步走法cur=horseVisit.Top(); //从栈中提取当前点Setside(cur); //设置当前点周围方向坐标bool flag = false; //定义标志for(int i=cur.from+1;i<=8;i++) {if(Getside(i,next)&&(gezi[next.x][next.y]==0)) { //如果设置方向正确,且格子为走过则运行flag = true;gezi[next.x][next.y]= ++count;cur=horseVisit.Top();horseVisit.Pop();cur.from=i;horseVisit.Push(cur);next.from = 0;horseVisit.Push(next);8break;}}if(!flag){ //如果for循环执行完毕没有找到周围可走的格子,则退栈5次int j=0;while(j<5 && horseVisit.Length()>1) { //根据测试连续退栈五次最优化,退栈次数比较少cur=horseVisit.Top();horseVisit.Pop();gezi[cur.x][cur.y] = 0;count--;j++;}}}while(!horseVisit.Empty()){ //上面运行完毕后,如果栈非空则取栈顶,计算出对应步数的格子序号保存起来输出路径cur=horseVisit.Top();horseVisit.Pop();cc[count--]=(cur.x*8+cur.y+1);}horseVisit.Clear(); //释放栈空间cout<<"马踏棋盘的路线为:"; //输出路径for(int i=1;i<65;i++)cout<<cc[i]<<" ";cout<<endl;cout<<"您是否需要继续运行该程序(y--继续:n--退出):";cin>>yn;cout<<endl;if(yn=='y'||yn=='Y') s=true;else s=false;return s;}int main(){bool s=true;while(s){int count=0;int gezi[8][8]={0};Point begin;cout<<"请输入马的初始位置x和y:";cout<<endl;cout<<"其中1<=x,y<=8,如:1 1 "<<endl;9cout<<"输入:" ;cin>>begin.x>>begin.y; //输入起始点,并判断正确性while(begin.x>8||begin.x<1||begin.y>8||begin.y<1){ cout<<"输入有误,请重新输入x和y:"<<endl;cout<<"其中1<=x,y<=8,如:1 1 "<<endl;cout<<"输入:" ;cin>>begin.x>>begin.y;}begin.x--;begin.y--;begin.from=0;Qipan A; //定义Qipan类的对象As=A.HorseVisit(begin); //A运行函数HorseVisit}return 0;}4.个人小结这是第二次写数据结构课程设计的代码,相对于第一次的生疏,这次已经能比较熟练地知晓题目应该如何编写的框架了,但具体实现的想法还是在网络中寻找了思路,然后写出了代码,一开始调试时一直出错,结果是自己在一个while循环的判断条件处多加了一个“~”,这导致了我一直无法运行起程序,后来在自习检查代码后发现了这一点,由此看出,数据结构编写程序不仅要对学习的只是能够灵活运用在编写代码的时候还要仔细仔细再仔细。