数据结构马踏棋盘

合集下载

第七次实验 马踏棋盘问题

第七次实验  马踏棋盘问题
桂林电子科技大学
数学与计算科学学院综合性、设计性实验报告
实验室:06406实验日期:2015年05月29日
院(系)
信息与计算科学系
年级、专业、班
1300710226
姓名
庞文正
成绩
课程
名称
数据结构实验
实验项目
名 称
马踏棋盘问题
指导
教师
教师
评语
教师签名:
年 月 日
一 ,实验目的
加深对图的理解,培养解决实际问题的编程能力。根据数据对象的特性,学会数据组织的方
start.y--;
curstep=1; //第一步
Move(start); //求解
}
五,实验结果分析或总结
运行半天不出来,比如输入 2 2还以为算法有误,后来想通了,真开心!
{n");
scanf("%d%d",&start.x,&start.y);
}
else
{
break;
}
}
for(i=0;i<8;i++) //初始化棋盘个单元位置
{
for(j=0;j<8;j++)
{
chessboard[i][j]=0;
}
}
start.x--;
格子具有集合性,故考虑使用无向图来表示格子及其间关系;以邻接表作为该无向图中结点与相邻8个结点(4黑4白)的存储结构;以顶点表存储格子,每格为顶点表中一结点,其指针域指向该顶点所能到达的第一个结点。
表头结点:
Vex
x
y
link
Vex:头结点所在的序号
x:头结点所在的横坐标;

马踏棋盘 正式作业

马踏棋盘 正式作业

数据结构与算法分析课程设计报告设计题目:马踏棋盘专业计算机科学与技术学号姓名年月日<<马踏棋盘>>数据结构课程设计概要设计功能模块化分析通过对问题描述的分析,可知马踏棋盘问题所要求实现的功能大致由三个部分组成:⑴接收用户输入的马的起始位置;⑵从起始位置开始在棋盘上标记马按问题描述中的行走规则访问棋盘中每个格子的顺序;⑶输出棋盘上标记的访问顺序。

系统结构的总体设计⑴输入模块:提示用户输入数据,接收用户输入的数据,即马的起始位置,并判断该位置是否在棋盘内。

若该起始位置在棋盘内,则接着执行下一模块的功能;若该起始位置不在棋盘内,则提示用户输入无效,并要求用户再次输入;⑵初始化模块:初始化所有的数据结构中的数据;⑶棋盘遍历模块:采用特定算法,按照马的行走规则对棋盘进行遍历,每次访问一个格子时,要测试该格子是否在棋盘范围内,保存马的访问顺序;⑷位置测试模块:接收格子的x和y坐标,判断该格子是否在棋盘内,然后根据该格子是否在棋盘内返回不同的信号;⑸输出模块:将棋盘遍历模块中保存下来的讯号进行输出,输出格式遵从棋盘格式;⑹总控模块:负责调用个处理模块,完成马踏棋盘问题的求解。

处理方式设计针对问题和核心模块,采用深度优先遍历思想和回溯算法的非递归形式。

⑴深度优先遍历的基本思想深度优先遍历可以从任意顶点开始访问图的顶点,然后把该顶点标记为已访问。

在每次迭代的时侯,该算法紧接着处理与当前顶点邻接的未访问顶点。

如果有若干个这样的顶点,可以任意选择一个顶点。

凡在实际应用中,选择哪一个邻接的未访问候选顶点主要是由表示图的数据结构决定的。

⑵回溯算法的基本思想回溯法是穷举查找技术的一个变种。

它每次只构造解的一个分量,然后按照下面的方法来评估这个部分构造解。

如果一个部分构造解可以进一步构造而不会违反问题的约束,我们就接受对解的下一个分量所做的第一个合法选择。

如果无法对下一分量进行合法的选择,就不必对剩下的任何分量再做任何选择了。

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

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

马踏棋盘课程设计实验报告《数据结构》课程设计实验报告课程名称: 《数据结构》课程设计课程设计题目: 马踏棋盘姓名: 邱可昉院系: 计算机学院专业: 计算机科学与技术班级: 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的方阵输出之。

*测试数据:由读者指定,可自行指定一个马的初始位置。

*实现提示:每次在多个可走位置中选择一个进行试探,其余未曾试探过的可走位置必须用适当结构妥善管理,以备试探失败时的“回溯”(悔棋)使用。

并探讨每次选择位置的“最佳策略”,以减少回溯的次数。

数据结构课程设计 马踏棋盘分解

数据结构课程设计 马踏棋盘分解

杭州师范大学钱江学院课程设计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填入数组中,则输出二维数组,即为马可走的方案。

若为贪婪法,选择下一出口的贪婪标准是在那些允许走的位置中,选择出口最少的那个位置。

实验报告马踏棋盘

实验报告马踏棋盘

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。

java学习笔记之马踏棋盘算法

java学习笔记之马踏棋盘算法

java学习笔记之马踏棋盘算法马踏棋盘或骑⼠周游问题1、马踏棋盘算法也被称为骑⼠周游问题2、将马随机放在国际象棋的 8×8 棋盘 Board[0~7][0~7]的某个⽅格中,马按⾛棋规则(马⾛⽇字)进⾏移动。

要求每个⽅格只进⼊⼀次,⾛遍棋盘上全部 64 个⽅格思路会使⽤到深度优先思想和类似迷宫问题的寻路策略问题,和⼋皇后问题也有相似。

1、⽤⼀个⼆维数组建⽴整张棋盘。

⽤另外⼀个⼆维数组保存棋盘的每⼀个位置是否⾛过2、马在棋盘上有⼀个初始位置,将这个位置设为已⾛过,并将步数设为1.3、获得在这个位置上,马下⼀步能⾛的位置集合。

4、遍历集合⾥的所有位置,如果那个位置没⾛过,下⼀步(步数+1)就⾛它(递归)5、设置递归结束的标志.⽤⼀个布尔变量标志游戏是否成功。

当游戏成功时,步数应该等于棋盘格⼦数。

假如某⼀次,马⾛完了所有能⾛的下⼀步位置,步数还⼩于棋盘格⼦数并且还没成功,说明这个位置不能成功的完成游戏,就把这个位置恢复原样(棋盘设为0,设为未⾛过),接下来的递归会重新去寻找合适的路。

如果步数等于棋盘总格⼦数,说明游戏成功,把标志的布尔变量设为true,这样在层层返回时就不会再进⼊上⾯的条件,递归就会逐渐结束⽽不会深⼊下去。

涉及到的⽅法:根据此时的位置,判断马接下来能⾛的位置集合。

x的值代表列⽽y的值代表⾏马是按照⽇字⾛的,所有当它在中间时最多有8种位置可以⾛,⼀⼀判断那个位置是否超过棋盘边界。

每种可能都是if,⽽不是if-else if,因为要获得所有的可能性,⽽不是找出⼀个假如list时⼀定要新建⼀个坐标,不能使⽤同⼀个,不然值就会互相影响/*** 根据现在的坐标返回可以⾛的坐标 x列y⾏** @param current* @return*/public static ArrayList<Point> findWay(Point current) {ArrayList<Point> res = new ArrayList<>();//可以⾛的坐标Point p = new Point();//5if ((p.x = current.x - 2) >= 0 && (p.y = current.y - 1) >= 0) {res.add(new Point(p));}//6if ((p.x = current.x - 1) >= 0 && (p.y = current.y - 2) >= 0) {res.add(new Point(p));}//7if ((p.x = current.x + 1) < X && (p.y = current.y - 2) >= 0) {res.add(new Point(p));}//0if ((p.x = current.x + 2) < X && (p.y = current.y - 1) >= 0) {res.add(new Point(p));}//1if ((p.x = current.x + 2) < X && (p.y = current.y + 1) < Y) {res.add(new Point(p));}//2if ((p.x = current.x + 1) < X && (p.y = current.y + 2) < Y) {res.add(new Point(p));}//3if ((p.x = current.x - 1) >= 0 && (p.y = current.y + 2) < Y) {res.add(new Point(p));}//4if ((p.x = current.x - 2) >= 0 && (p.y = current.y + 1) < Y) {res.add(new Point(p));}return res;}马塔棋盘不能单纯以step < X * Y来判断是否完成游戏,因为递归回溯时步数也会回溯,所以要设置⼀个变量/*** 马踏棋盘算法** @param chess 棋盘* @param row 坐标⾏* @param col 坐标列* @param step 步数*/public static void traversalChessboard(int[][] chess, int row, int col, int step) {//先⾛⼀步chess[row][col] = step;visit[row][col] = true;//下⼀步能⾛的地ArrayList<Point> way = findWay(new Point(col, row));while (!way.isEmpty()) {//取出⼀个能⾛的地⽅Point point = way.remove(0);//⾛下⼀步if (!visit[point.y][point.x]) {traversalChessboard(chess, point.y, point.x, step + 1);}}//判断是否完成游戏,如果没完成就要回溯if (step < X * Y && !finshed) {chess[row][col] = 0;visit[row][col] = false;}else {finshed=true;}}优化这样计算效率⽐较低,算法⽐较慢。

马踏棋盘——一个数据结构综合实验案例新解

马踏棋盘——一个数据结构综合实验案例新解
生 容 易 下 手 ,容 易 通 过 对 已学 理 论 举 一 反 三 ,进 行 求 解 。 传 统 的马 踏 棋 盘 问题 采 用 的 回 溯 法 或 者 贪 心 法 求 解 , 学 生 学 完 了数 据 结 构 课 程 ,用 此 类 方 法 求 解 仍 具 有 一 定 难 度 。 就 其 原 因 , 学 生 对 数 据 结构 的 理 论 知 识 不 能 灵 活 运 用 以及 相
总第 1 4卷 1 7期 5 21 0 2年 9月
大 众 科 技
P uar in e & Te h oo y op l e c Sc c n lg
Vo . 4 N0 9 L1 .
Se t pemb r 2 1 e 0 2
马踏 棋 盘
一 个 数 据 结构 综 合 实验 案 例 新解
知从 何 下 手 ,产 生 畏 难 心 理 ,会 打 击 学 生解 决 问题 的 自信 心 ;
而 案 例 过 于 简 单 , 则 达 不 到 综 合 实验 要 求 ,起 不 到锻 炼 学 生 的 目的 。一 个 合 适 的 综 合 实 验 案 例 ,应 该具 有 以 下几 个 特 点 :
课程打 下坚 实的基础 。然而 , 数据 结构也是一门理论性很强 的课程 ,理论 知识抽象 、概 念多 、算法 多而杂 ,学 生不好理 解 ,设 计程序无 从下手 。很 多学生反 映这 门课 “ 难懂 、不好 用 ”。学生不通 过实践很难对其 理论有深入 理解和应用 。因
Ab t a t I h sp p r t ep o lm f o s r v l g o h s b ad wa n r d c d i t a a s u t r x e me t e c i g a n s r c : n t i a e , h r b e o r eta ei n c e s o r si to u e n o d t t c u ee p r h n r i n a h n sa t

数据结构课程设计 马踏棋盘概论

数据结构课程设计 马踏棋盘概论

学习数据结构的最终目的是解决实际的应用问题,特别是非数值计算类型的应用问题,数据结构课程设计就是为此目的一次实际训练。

要求我们在对题目进行独立分析的基础上,完成设计和开发,并最终接受严格的测试考核。

以深化对数据结构课程中基本概念、理论和方法的理解,提升综合运用所学知识处理实际问题的能力,使我们的的程序设计能力与调试水平有一个明显的提升。

课程设计所安排的题目,都有一定的难度和深度,从抽象数据类型的提炼、数据结构选择到算法的设计,均由我们每个人自主完成。

在一周的时间内,历经查找参考资料、使用技术手册、设计编码和撰写文档的实践,进一步升华对软件工程师和程序员人格素质的认识和理解。

本课程设计的主要设计内容是:设计一个马踏棋盘问题的演示程序。

即将马随机地放在国际象棋的8*8棋盘的某个方格中,然后令马按走棋规则开始进行移动。

要求马将棋盘上的每个方格进入且只进入一次,走遍全部64个方格。

要求编制非递归程序,求出马的行走路线,将数字1,2,…,64依次填入一个8*8的方阵在屏幕上显示输出。

针对该问题本课程设计采用的是面向对象的开发语言Java,在Windows7, myeclipse8.5.0的平台上开发出来,并有图形界面。

最终较好的实现了全部要求,达到了预期效果。

从中我也学到了很多,不仅仅是课堂外的新知识,还有那种会查资料,会学习新知识的能力。

这个课程设计的顺利完成,离不开胡老师的指导和帮助,在他的细心指导和帮助下,我对马踏棋盘程序开发的整个流程有了深刻地了解和系统地掌握,在这里学生表示真诚地感谢。

另外也谢谢这次课程设计提供给我帮助的同学们。

此外,本课程设计还参考了一些文献资料,在此向这些文献资料的作者深表谢意。

本课程设计可作为数据结构和Java课程教学的参考案例。

由于时间仓促和本人水平所限,设计中难免有不当和欠妥之处,敬请老师不吝批评指正。

笔者2016.6摘要 (3)第一章需求分析 (4)第二章概要设计 (5)2.1系统描述。

数据结构课程设计 马踏棋盘求全部解及演示程序

数据结构课程设计  马踏棋盘求全部解及演示程序

安徽工程大学信息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个方格。

数据结构马踏棋盘

数据结构马踏棋盘

数据结构马踏棋盘第一点:马踏棋盘的起源与发展马踏棋盘,是一种源自中国传统的棋类游戏,具有悠久的历史和丰富的文化内涵。

它是在象棋的基础上演变而来的一种棋类运动,以马作为主要棋子,通过马的移动来占领对方的棋盘。

马踏棋盘不仅具有高度的策略性和技巧性,而且蕴含着深厚的哲学思想和人生哲理。

从历史角度看,马踏棋盘的起源可以追溯到中国古代的战国时期。

当时,诸侯割据,战争频繁,人们为了娱乐和消磨时间,便创造了这种棋类游戏。

随着时间的推移,马踏棋盘逐渐在全国各地流传开来,并逐渐形成了不同的地域流派和玩法。

从文化角度看,马踏棋盘不仅是一种游戏,更是一种艺术。

它的棋盘布局、棋子造型、规则设计等方面都蕴含着丰富的中国传统文化元素。

例如,棋盘的布局模仿了中国古代的宫殿建筑,棋子的造型则借鉴了古代兵器和宫廷用品。

同时,马踏棋盘的规则设计也体现了中国古代的哲学思想,如阴阳、五行等。

第二点:马踏棋盘的策略与技巧马踏棋盘作为一种策略性棋类游戏,其胜负往往取决于玩家的策略和技巧。

在游戏中,玩家需要充分运用自己的智慧和思维,通过巧妙的布局和战术,来实现占领对方棋盘的目的。

首先,玩家需要掌握马踏棋盘的基本规则和棋子的行走方式。

马踏棋盘的棋子行走方式与象棋有所不同,马的移动方式是“日”字形,即每次移动可以横向或纵向移动一格,然后横向或纵向移动一格,类似于马的奔腾。

玩家需要熟练掌握马的行走方式,才能在游戏中更好地发挥其作用。

其次,玩家需要学会运用不同的战术和策略。

在马踏棋盘游戏中,玩家可以通过设置陷阱、封锁对方棋子、保护自己的棋子等方式来达到胜利的目的。

例如,玩家可以利用棋盘上的障碍物来设置陷阱,让对方棋子无法移动或被迫移动到不利的位置。

同时,玩家还需要保护自己的棋子,避免被对方轻易攻破。

最后,玩家需要具备良好的思维和应变能力。

在马踏棋盘游戏中,局势变化无常,玩家需要能够迅速分析局势,制定出合理的策略和方案。

同时,玩家还需要具备较强的应变能力,能够灵活应对各种突发情况,从而取得胜利。

C++ 数据结构课程设计 马踏棋局文档

C++ 数据结构课程设计 马踏棋局文档

课程设计题目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:冒泡排序超出边界原因:循环次数大解决方案:减少循环次数看了其他同学,都差不多,我已经按马的下一位置最难的先走,再走难度次之的位置。

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

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

目录1 课程设计的目的 (x)2 需求分析 (x)3 课程设计报告内容 (x)1、概要设计 (x)2、详细设计 (x)3、调试分析 (x)4、用户手册 (x)5、测试结果 (x)6、程序清单 (x)4 小结 (x)5 参考文献 (x)2011年5月23日1、课程设计的目的(1)熟练使用栈和队列解决实际问题;(2)了解并掌握数据结构与算法的设计方法,具备初步的独立分析和设计能力;(3)初步掌握软件开发过程的问题分析、系统设计、程序编码、测试等基本方法和技能;(4)提高综合运用所学的理论知识和方法独立分析和解决问题的能力;2、需求分析*问题描述:将马随机放在国际象棋的8X8棋盘Bo阿rd[0..7,0..7]的某个方格中,马按走棋规则进行移动。

要求每个方格上只进入一次,走遍棋盘上全部64个方格。

编制非递归程序,求出马的行走路线,并按求出的行走路线,将数字1,2,…,64依次填入8X8的方阵输出之。

*测试数据:由读者指定,可自行指定一个马的初始位置。

*实现提示:每次在多个可走位置中选择一个进行试探,其余未曾试探过的可走位置必须用适当结构妥善管理,以备试探失败时的“回溯”(悔棋)使用。

并探讨每次选择位置的“最佳策略”,以减少回溯的次数。

3、课程设计报告内容根据分析先建了2个结构体struct PosType //马的坐标位置类型{int m_row; //行值int m_col; //列值};struct DataType //栈的元素类型{PosType seat; //马在棋盘中的“坐标位置”int di; //换方向的次数};chess::chess()bool chess::chessPath(PosType start) //在棋盘中进行试探寻找下一步位置并同时记录位置,以及涉及到的入栈出栈void chess::Print() //打印马走的路径PosType chess::NextPos(PosType a,int di)//根据当前点的位置a和移动方向di,试探下一位置4、总结一、这次课程设计的心得体会通过实践我的收获如下:1、巩固和加深了对数据结构的理解,提高综合运用本课程所学知识的能力。

数据结构 马踏棋盘

数据结构  马踏棋盘

理解栈的特性“后进先出” 和队列的特性“先进先出”。

仅仅认识到栈和队列是两种特殊的线性表是远远不够的,本次实验的目的在于更深入的了解栈和队列的特性,以便在实际问题 背景下灵便运用他们。

在了解他特性的基础上,还将巩固对这种结构的构造方法的理解。

要求:在国际象棋 8×8 棋盘上面,按照国际象棋规则中马的行进规则,实现从任意初始 位置,每一个方格只进入一次,走遍棋盘上全部 64 个方格。

编制程序,求出马的行走路线,并 按求出的行走路线, 将数字 1,2,…,64 挨次填入一个8×8 的方阵, 并输出它的行走路线 (棋 盘如图所示)。

输入:任意一个起始位置;输出:无重复踏遍棋盘的结果,以数字 1-64 表示行走路线。

为了实现上述程序功能,可以采用顺序栈或者链栈来存储它的数据,本实验所需要的存储空间不是很大,不需动态的开辟不少空间,所以采用相对简单的顺序栈来存储数据,既方 便有简单,而用链栈在实现上相对照顺序栈复杂的一点。

1234567414285 523176 3H6 7ADT Stack{数据对象:D={ai| ai∈(0,1,…, 9),i=0,1,2,…, n,n≥0}数据关系: R={< ai-1, ai >| ai-1, ai∈D,i=1,2,…, n}} ADT Stack1、主程序模块:void main(){定义变量;接受命令;处理命令;退出;}2、起始坐标函数模块——马儿在棋盘上的起始位置;3、探寻路径函数模块——马儿每一个方向进行尝试,直到试完整个棋盘;4、输出路径函数模块——输出马儿行走的路径;主程序模块输入的初始位置是否正确否是起始坐标函数模探寻路径函数模输出路径函数模结束#include<stdio.h>#define MAXSIZE 100#define N 8int 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; //定义栈类型//行坐标//列坐标//存储方向//定义一个栈数组//栈指针void InitLocation(int xi,int yi); //马儿在棋盘上的起始位置坐标int TryPath(int i,int j); void Display(); //马儿每一个方向进行尝试,直到试完整个棋盘//输出马儿行走的路径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("无解");}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)return (1); find=0; //如果走完整个棋盘返回 1 //表示没有找到下一个位置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);}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");}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)本次实验的主要目的是在于掌握和理解栈的特性和它的应用。

数据结构课程设计(马踏棋盘)

数据结构课程设计(马踏棋盘)

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

1实验题目马踏棋盘

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 : 该开始想着利用栈的数据结构,记录回溯的相关信息,后来查资料发现如果每次入结点路径最少的那个结点,根本不会产生回溯的过程,后来就省去了栈队列的应用;酽锕极額閉镇桧猪訣锥顧荭。

数据结构课内实验(栈和队列)

数据结构课内实验(栈和队列)

数据结构课内实验(栈和队列)西安邮电⼤学(计算机学院)数据结构课内实验报告实验名称:栈和队列专业名称:软件⼯程班级:软件⼯程xxxx班学⽣姓名:xxx学号(8位):xxxxxxxx指导教师:xx实验⽇期:xxxx年xx⽉xx⽇⼀.实验⽬的掌握栈和队列的逻辑结构和存储结构,以及栈和队列的基本算法,实现算法以及其应⽤⼆.实验内容马踏棋盘:将马随机地放在国际象棋8*8棋盘Board[8][8]的某个⽅格中,马按⾛棋规则进⾏移动,要求每个⽅格只进⾏⼀次,⾛遍整个棋盘的全部64个⽅格。

编制⾮递归程序,求出马的⾏⾛路线,并按求出的⾏⾛路线,将数字1,2,…,64依次填⼊⼀个8*8的⽅阵,输出之⼆.实验⽅案设计》1.基本思想:1)建⽴⼀个栈,定义其栈顶和栈底指针,以及栈的⼤⼩;2)将马的初始步压⼊栈中,计算其8个⽅向的权值,各点的8个⽅向按权值升序排列;3)马向最⼩权值⽅向⾏⾛,得到下⼀步,重复步骤2);4)某步的下⼀步超出棋盘,则应重新⾛,这⼀步出栈,由前⼀步重新选择⽅向;5)最后,根据栈中内容将马的⾏⾛路线填⼊⽅阵中,输出。

》2.函数说明:1.位置存储:typedef struct{ //每个坐标的位置int x; //x轴int y; //y轴}PosType;2.栈的存储信息:1. typedef struct{ //栈元素int ord;PosType seat; //位置int di; //马的⽅向(每个点都有8个⽅向可以选择,初始值为0,每使⽤⼀次⽅向给id++,它指向的是下⼀个该⾛的坐标位置,在函数Nextpos()和HorsePath()中会作为参数和变量⽤}ElemType;2.typedef struct{ //定义栈的结构ElemType *base; //base和top都是马每⾛⼀步存储的信息,不过base的信息类型都是为NULL//,top则存储真正的信息,base做为栈底的指针,top是栈顶指针ElemType *top;int stacksize;}SqStack3.各点的权值:weight[n][n] 描述该位置移动⽅向的个数4.存储待移动的⽅向,按升序移动Board[N][N][8]5.路径的存储path[N][N]》3.基本算法的实现1.IniStack();初始化栈其他栈操作省略2.Setweight()获取每个位置的权值,即可以移动的⽅向for(i=0;i{for(j=0;jweight[i][j]=0; //各点的权值for(k=0;k<8;k++){m=NextPos(elem.seat,k+1); //获取下次的坐标,有8个坐标可以择,if(m.x>=0&&m.x=0&&m.yweight[i][j]++; //(i,j)点有⼏个⽅向可以移动3.setmap()权值按照升序排列for(){for() NextPos(n2,h+1);//获取下个⽅位a[h]=weight[n1.x][n1.y];记录下个位置权值For() min=9 if(min>a[k]){min=a[k]; Board[i][j][m]=k; s=k; } a(s)=9;}4.NextPos(PosType curpos,int direction){switch() case1:... Case 2... ...}进⾏下次位置的查找5.HorsePath()创建马⾛过的路径并进⾏⼊栈和不合法位置的出栈操作{do{ if(pass(curpos) 位置是否合法{ push(elem)⼊站;board[x][y][id]+1; nextpos() 取得下⼀个节点} else{if(栈⾮空){while(栈⾮空且位置的8个⽅向已经⽤完){pop()出栈;Gettop() 取栈顶元素}if(还有⽅向没有⾛)Nextpos();读取下次的位置}}while(!StackEmpty())6.Outputpath() 输出⾛过的路径For(){ path[(*s1.base).seat.x][(*s1.base).seat.y]=i+1;++s1.base;}从栈底依次访问⾛过的位置,path元素从1开始标记,位置便是path的索引值,for(){printf(输出path的每个元素标记值)}三.该程序的功能和运⾏结果马踏棋盘:三.实验总结1.实验过程中遇到的问题及解决办法:开始时并不知道怎样去做这个程序,反复看了课本后开始对设计思路有了初步了解,建⽴⼀个位置(x,y),struct栈的信息和定义栈,每个栈需要存储马⾛过的位置,但怎样标记这些位置的先后顺序是⼀个很⼤的⿇烦,在创建⼀个路径,依次读取栈底位置并逐层从1开始标记就得到解决,之后碰到的最⼤问题是怎样将合法路径的压⼊栈内,⾸先要有⼀套规则,即⾛最⼩的路径,即权值,所以setweight()每个点的权值,setmap()函数存⼊到Board[][][]中(将下⼀步坐标按权值的⼤⼩排列),从输⼊的坐标开始读⼊下⼀步坐标并压⼊栈中,⽤while循环持续的压栈和出栈,知道所有的坐标都⾛完为⽌,2.实验中未完成的问题和已经完成的功能已经能够将马⾛过的每⼀步⼀⼀列举出来,但不能够完成多条⽅案的路径操作,输出界⾯也不够完善,缺少动态的功能3.对设计及调试过程的⼼得体会:整个代码的⼯作挺复杂的,算法有⼀定的难度。

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

实验二:栈和队列及其应用题目:马踏棋盘班级:姓名:学号:一、问题描述设计一个国际象棋的马踏遍棋盘的演示程序。

二、基本要求将马随机放在国际象棋的8*8的棋盘Board[8][8]的某个方格中,马按走棋规则进行移动。

要求每个方格只进入一次,走遍棋盘上全部64个方格。

编制非递归程序,求出马的行走路线,并按求出的行走路线,将数字1,2,……,64依次填入一个8*8的方阵,输出之。

三、概要设计1.定义头文件和预定义#include<stdio.h>#define MAXSIZE 100#define N 82.起始坐标函数:void InitLocation(int xi,int yi);3.探寻路径函数:int TryPath(int i,int j);4.输出路径函数:void Display();5.主程序:void main();四、详细设计1.函数声明void InitLocation(int xi,int yi); //马儿在棋盘上的起始位置坐标int TryPath(int i,int j); //马儿每个方向进行尝试,直到试完整个棋盘void Display(); //输出马儿行走的路径2. 起始坐标函数模块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否则返回0Display(); //输出马儿的行走路径elseprintf("无解");}3. 探寻路径函数模块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);}4. 输出路径函数模块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");}五、测试数据及测试结果测试数据:x=2,y=3测试结果:六、实验环境C-Free七、源程序代码#include<stdio.h>#define MAXSIZE 100#define N 8int 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; //栈指针void InitLocation(int xi,int yi); //马儿在棋盘上的起始位置坐标int TryPath(int i,int j); //马儿每个方向进行尝试,直到试完整个棋盘void Display(); //输出马儿行走的路径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否则返回0Display(); //输出马儿的行走路径elseprintf("无解");}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);}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");}int 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); //调用起始坐标函数}。

相关文档
最新文档