马踏棋盘课程设计实验报告

合集下载

数据结构 马踏棋盘 设计报告

数据结构 马踏棋盘 设计报告

《数据结构》课程设计报告课程名称:《数据结构》课程设计课程设计题目:姓名:院系:专业:年级:学号:指导教师: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");

马踏棋盘实习报告

马踏棋盘实习报告

一、实习背景马踏棋盘问题是一个经典的算法问题,也是数据结构课程中的一个重要实验。

通过对马踏棋盘问题的研究和实现,可以加深对栈和队列这两种抽象数据类型的理解,提高算法设计能力和编程能力。

本次实习旨在通过编程实现马踏棋盘问题,并分析其算法的复杂度和优化策略。

二、实习目的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)在遍历过程中,避免重复访问已经访问过的位置。

马踏棋盘-大学课程设计

马踏棋盘-大学课程设计

马踏棋盘一目的1、巩固和加深对线性表、栈、队列、字符串、树、图、查找、排序等理论知识的理解。

2、掌握现实复杂问题的分析建模和解决方法(包括问题描述、系统分析、设计建模、代码实现、结果分析等)。

3、提高利用计算机分析解决综合性实际问题的基本能力。

4、加强对基础知识的运用,做到学以致用。

5、二需求分析1、从键盘输入马起始的横坐标x和纵坐标y,其范围都是0-7。

2、马按走棋规则进行移动,要求每个方格只进入一次,走遍棋盘上全部64个方格。

3、一般说来,当马位于位置(i,j)时,可以走到下列8个位置之一( x-2,y+1),(x-1,y+2),(x+1,y+2),(x+2,y+1),(x+2,y-1)(x+1,y-2),(x-1,y-2),(x-2,y-1)4、求出马的行走路线,将数字1到64依次填入一个8X8的方阵,输出到文本中(文本中能清楚看到方阵)。

输出的形式;(1)以数组下标形式输入,代表起始位置,i表示行标,j表示列标。

(2)以棋盘形式输出,每一格打印马走的步数,这种方式比较直观。

3、程序所能达到的功能;(1)让马从任一起点出发都能够历遍整个8×8的棋盘。

(2)能寻找多条不同的行走路径。

4.测试数据,包括正确的输入及输出结果和含有错误的输入及其输出结果。

数据可以任定,只要 0<=X<7&&0<=Y<7 就可以了。

正确的输出结果为一个2维数组,每个元素的值表示马行走的第几步。

若输入有错,程序会显示“输入错误,请重新输入:”并且要求用户重新输入数据,直至输入正确为止。

三概要设计initstack(s) //构建一个空栈。

push(s,e) //在栈顶插入新的元素。

pop(s,e)//将栈顶元素弹出。

settop(s, e) //将e设为栈顶元素。

gettop(s, e)//将栈顶元素取出。

stackempty(s) //判断栈是否为空check(int x,int y)//判断点(x,y)是否在棋盘内weighting()//求棋盘中每一点的权值四详细设计1、名称详细内容详细内容详细内容详细内容详细内容详细内容详细内容详细内容详细内容详棋盘点的结构类型定义typedef struct{int x;该点的横坐标int y;该点的纵坐标int z;}elemtype;栈的类型定义typedef struct SNode{elemtype data;struct SNode *next;}SNode,*Linkstack;栈的初始化操作int initstack(Linkstack &s){s=(Linkstack)malloc(sizeof(SNode));if(!s){printf("初始化失败!");return 0;}s->next=NULL;return 1;}入栈操作int push(Linkstack &s,elemtype e){Linkstack p;p=(Linkstack)malloc(sizeof(SNode));if(!p) return 0;p->next=s->next;s->next=p;p->data=e;return 1;}出栈操作int pop(Linkstack &s,elemtype &e) {Linkstack p=s->next;if(p==NULL) return 0;s->next=p->next;e=p->data;free(p);return 1;}取栈顶元素操作gettop(Linkstack &s,elemtype &e) {Linkstack p=s->next;if(p==NULL) return 0;e=p->data;return 1;}判断栈是否为空操作int stackempty(Linkstack s){int flag=0;if(s->next==NULL)flag=1;return flag;}设为栈顶元素操作int settop(Linkstack &s,elemtype e) {if(s->next!=NULL){s->next->data=e;return 1;}else return 0;}void setmap(){int i,j,k,m,d1,d2,x1,x2,y1,y2,l1,l2; for(i=0;i<N;i++)//for 1{for(j=0;j<N;j++)//for 2{for(k=0;k<8;k++)map[i][j][k]=k;//默认8个方向顺时针赋值for(k=0;k<8;k++)//for 3 与 for 4 两个循环对方向索引按点的权值升序排列,不能到达的方向排在最后{for(m=k+1;m<8;m++) //for 4{d1=map[i][j][k];x1=i+HTry1[d1];y1=j+HTry2[d1];d2=map[i][j][m];x2=i+HTry1[d2];y2=j+HTry2[d2];l1=check(x1,y1);l2=check(x2,y2);if((l1==0&&l2)||(l1&&l2&&(weight[x1][y1]>weight[x2][y2]))){map[i][j][k]=d2;map[i][j][m]=d1; //交换两个方向值,按权值递增排列,不可到达的目标点(超出棋盘)的方向放在最后面}//end if}//end for 4}//end for 3}//end for 2}//end for 1}//end setmap()void path(int xx, int yy){ int c[N*N]={0},h[N*N]={0};Linkstack a;elemtype ptemp;elemtype pop_temp,get_temp;elemtype p,dest_p; //当前点和目标点int step=0,x,y,s,k=1,l=1,d =0;char ch;p.x = xx; p.y = yy;p.z = 0;//初始化出发点board[xx][yy]=1;initstack(a);push(a,p); //起始点的坐标和首选方向入栈while(1){if (step==63){output(a);exit(1);}if(stackempty(a)) break;gettop(a,p);x=p.x; y=p.y; d=p.z;if(d>=8)//该点所有方向已走完,退栈{board[x][y]=0; //抹去痕迹step--; //步数减一pop(a,pop_temp); //退栈gettop(a,get_temp); //取当前栈顶元素ptemp.x=get_temp.x;ptemp.y=get_temp.y;ptemp.z=get_temp.z+1;settop(a,ptemp); //更改方向gettop(a,p);} //end if (d>=8)if(d<8)//方向未走完{s=map[x][y][d];//map[x][y][0]未必是(x,y)点的HTry[0]方向,而是到该点可到的权值最小的点的方向即HTry[map[x][y][0]dest_p.x=x+HTry1[s];dest_p.y=y+HTry2[s];if(check(dest_p.x,dest_p.y)&&board[dest_p.x][dest_p.y]==0)//目标点在棋盘内且未被走过,则将目标点入栈同时标记当前点为已走过{h[step]=step;board[x][y]=1;step++;//步数加一dest_p.z=0;push(a,dest_p);//存入目标点,方向栈初始}else//目标点已被走过或目标点不在棋盘内,换方向{ //printf(" 进行");ptemp.x=p.x;ptemp.y=p.y;ptemp.z=d+1;//取下一个方向 settop(a,ptemp);//切换方向// gettop(a,p);//gettop(a,p);//x=p.x; y=p.y; d=p.z;检测重新将d赋值//printf("%d %d %d",x,y,d);}} //enf if(d<8)//printf("步数%d\n ",step);} //end while(1)}void output(Linkstack a){ Linkstack b;int c[8][8]={0},i,j,k=N*N,l=1,x,y;initstack(b);elemtype e;while(!stackempty(a)){pop(a,e);c[e.x][e.y]=k;k--;push(b,e);}gettop(b,e);x=e.x;y=e.y;printf("起始坐标:(%d,%d)\n",x,y);while(!stackempty(b)){ pop(b,e);printf("(%d,%d)",e.x,e.y);push(a,e);}printf("棋盘表示为:\n");for(i=0;i<8;i++){for(j=0;j<8;j++){printf("%2d",c[i][j]);printf(" ");if(j==7) printf("\n");}}}五调试分析1、设计gettop函数时误将栈顶元素取出,原因是多加了一条s->next=p->next语句,造成不应有的错误2、写settop(s)函数时,忘记了s仅为头结点误将e赋值给了s->data,而实际上应为s->next->data=e;由此造成的错误极难发现,这也进一步说明了基础知识的重要。

马踏棋盘的实习报告

马踏棋盘的实习报告

马踏棋盘实习报告题目:设计一个国际象棋的马踏遍棋盘的演示程序班级:姓名:学号:完成日期:一.需求分析将马随机放在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篇)

棋盘算法实验报告(3篇)

个人自我介绍简单大方
很抱歉,但我无法为您提供____字的自我介绍。

以下是一个简洁而大方的自我介绍示例,供您参考:
大家好,我叫[姓名]。

很高兴有机会向大家介绍一下自己。

我出生并长大在[所在地],是一个勤奋、积极向上的人。

在学业方面,我于[毕业时间]从[学校名称]获得了[学位/专业]学位。

在大学期间,我通过自我努力和课外学习,取得了良好的学术成绩,并参与了一些学生组织和社团活动。

这些经历不仅培养了我的团队合作和领导能力,也加强了我的沟通和组织能力。

在工作方面,我有[工作年限]年的相关工作经验。

我曾在[公司/组织名称]担任[职位],负责[工作职责]。

在这期间,我不断努力提升自己的专业知识和技能,以适应快速发展的工作环境。

我善于分析问题并找出解决方案,能够有效地与团队合作并承担责任,这些都为我赢得了同事和上级的认可。

除了工作,我也积极参与志愿者活动,希望能为社区和弱势群体做一点贡献。

我相信,通过奉献和关心他人,我们可以建立一个更加和谐和温暖的社会。

在个人生活中,我喜欢阅读、旅行和运动。

阅读扩展了我的视野,旅行让我能够体验不同的文化和风景,而运动则让我保持健康和积极的精神状态。

此外,我也很喜欢与家人和朋友相处,分享彼此的喜怒哀乐。

总的来说,我是一个热情、乐观、有责任心的人。

我相信勤奋和坚持可以取得成功,而真诚和善良可以赢得他人的信任和支持。

我希望能够在您的团队中发挥我的才能,并与大家一同成长和进步。

这就是我简单的自我介绍,谢谢大家!。

马踏棋盘 数据结构实践报告

马踏棋盘 数据结构实践报告

马踏棋盘问题摘要:马踏棋盘就是在国际象棋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。

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

《数据结构》课程设计实验报告课程名称:《数据结构》课程设计课程设计题目:马踏棋盘姓名:***院系:计算机学院专业:计算机科学与技术班级:10052313 学号:******** 指导老师:***2012年5月18日目录1.课程设计的目的 (3)2.问题分析 (3)3.课程设计报告内容 (3)(1)概要设计 (3)(2)详细设计 (3)(3)测试结果 (5)(4)程序清单 (6)4.个人小结 (10)1.课程设计的目的《数据结构》是计算机软件的一门基础课程,计算机科学各领域及有关的应用软件都要用到各种类型的数据结构。

学好数据结构对掌握实际编程能力是很有帮助的。

为了学好《数据结构》,必须编写一些在特定数据结构上的算法,通过上机调试,才能更好地掌握各种数据结构及其特点,同时提高解决计算机应用实际问题的能力。

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; //棋盘格子};然后对每个函数进行定义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;}(3)测试结果对于一次死路后退栈次数进行测试1次用时很长且为运行出来2次3次4次5次6次又测试了其他几个点得出一次死路退栈5次能尽量少的减少退栈次数其他几个点的数据(4)程序清单#include<iostream>#include "SqStack.h"using 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){ //根据输入的当前点设置下一个点的可能方向坐标Point 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);break;}}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;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.个人小结这是第二次写数据结构课程设计的代码,相对于第一次的生疏,这次已经能比较熟练地知晓题目应该如何编写的框架了,但具体实现的想法还是在网络中寻找了思路,然后写出了代码,一开始调试时一直出错,结果是自己在一个while循环的判断条件处多加了一个“!”,这导致了我一直无法运行起程序,后来在自习检查代码后发现了这一点,由此看出,数据结构编写程序不仅要对学习的只是能够灵活运用在编写代码的时候还要仔细仔细再仔细。

相关文档
最新文档