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

《数据结构》课程设计报告课程名称:《数据结构》课程设计课程设计题目:姓名:院系:专业:年级:学号:指导教师: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 课程设计的目的 (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、巩固和加深了对数据结构的理解,提高综合运用本课程所学知识的能力。
马踏棋盘实习报告

一、实习背景马踏棋盘问题是一个经典的算法问题,也是数据结构课程中的一个重要实验。
通过对马踏棋盘问题的研究和实现,可以加深对栈和队列这两种抽象数据类型的理解,提高算法设计能力和编程能力。
本次实习旨在通过编程实现马踏棋盘问题,并分析其算法的复杂度和优化策略。
二、实习目的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)在遍历过程中,避免重复访问已经访问过的位置。
数据结构 马踏棋盘

理解栈的特性“后进先出” 和队列的特性“先进先出”。
仅仅认识到栈和队列是两种特殊的线性表是远远不够的,本次实验的目的在于更深入的了解栈和队列的特性,以便在实际问题 背景下灵便运用他们。
在了解他特性的基础上,还将巩固对这种结构的构造方法的理解。
要求:在国际象棋 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)本次实验的主要目的是在于掌握和理解栈的特性和它的应用。
马踏棋盘的实习报告

马踏棋盘实习报告题目:设计一个国际象棋的马踏遍棋盘的演示程序班级:姓名:学号:完成日期:一.需求分析将马随机放在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.刚开始的时候并没有采用贪心算法,时间复杂度很大,探测量也很大。
利用顺序栈或循环队列的存储来实现马踏棋盘的算法

河南工业大学实验报告课程数据结构实验名称利用顺序栈或循环队列的存储来实现马踏棋盘的算法学院信息科学与工程学院专业班级姓名学号实验报告日期 2009 年 4 月 1 日教师审批签字实验报告一实验题目:马踏棋盘二实验要求:将马放在国际象棋的8*8棋盘Board[8][8]的某个方格中,马按走棋的规则进行移动。
要求每个方格只能进入一次。
走遍棋盘上的全部的64个方格。
输入:任意一个起始位置.输出:无重复踏遍棋盘的结果,以数字1-64表示行走路线.数据结构要求:采用顺序栈或者链栈实现三实验目的:1熟悉栈的定义和栈的基本操作2 熟悉每一种栈操作的一般函数实现和成员函数实现。
3在实际问题背景下灵活运用它们,并巩固这两种结构的构造方法四程序设计如下:#include "stdio.h"#define M 70#define FALSE 0#define TRUE 1typedef struct node //结点的类型{int vec,x,y;struct node *link;}listnode;#define MAXSIZE 70typedef struct{int stack[MAXSIZE];int top;}seqstack;seqstack *s; //顺序栈指针listnode ag[M];int flag[M];void setnull(seqstack *s){s->top=-1;}int push(seqstack *s,int x){if(s->top>=MAXSIZE-1){printf("stack overflow!\n");return FALSE;}else{s->stack[++s->top]=x;/*栈顶指针上移,数据元素入栈*/ return TRUE;}}int pop(seqstack *s)/*出当前栈S的栈顶元素*/{ int p;if(s->top<0){printf("stack empty!\n");/*栈空,返回空值 */ return NULL;}else{s->top--;return(s->stack[s->top+1]);}/*由于return语句的特点,必须先使top减1,然后再执行return语句。
棋盘算法实验报告(3篇)

个人自我介绍简单大方
很抱歉,但我无法为您提供____字的自我介绍。
以下是一个简洁而大方的自我介绍示例,供您参考:
大家好,我叫[姓名]。
很高兴有机会向大家介绍一下自己。
我出生并长大在[所在地],是一个勤奋、积极向上的人。
在学业方面,我于[毕业时间]从[学校名称]获得了[学位/专业]学位。
在大学期间,我通过自我努力和课外学习,取得了良好的学术成绩,并参与了一些学生组织和社团活动。
这些经历不仅培养了我的团队合作和领导能力,也加强了我的沟通和组织能力。
在工作方面,我有[工作年限]年的相关工作经验。
我曾在[公司/组织名称]担任[职位],负责[工作职责]。
在这期间,我不断努力提升自己的专业知识和技能,以适应快速发展的工作环境。
我善于分析问题并找出解决方案,能够有效地与团队合作并承担责任,这些都为我赢得了同事和上级的认可。
除了工作,我也积极参与志愿者活动,希望能为社区和弱势群体做一点贡献。
我相信,通过奉献和关心他人,我们可以建立一个更加和谐和温暖的社会。
在个人生活中,我喜欢阅读、旅行和运动。
阅读扩展了我的视野,旅行让我能够体验不同的文化和风景,而运动则让我保持健康和积极的精神状态。
此外,我也很喜欢与家人和朋友相处,分享彼此的喜怒哀乐。
总的来说,我是一个热情、乐观、有责任心的人。
我相信勤奋和坚持可以取得成功,而真诚和善良可以赢得他人的信任和支持。
我希望能够在您的团队中发挥我的才能,并与大家一同成长和进步。
这就是我简单的自我介绍,谢谢大家!。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
目录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、巩固和加深了对数据结构的理解,提高综合运用本课程所学知识的能力。
2、培养了我选用参考书,查阅手册及文献资料的能力。
培养独立思考,深入研究,分析问题、解决问题的能力。
二、根据我在实习中遇到得问题,我将在以后的学习过程中注意以下几点:1、认真上好专业实验课,多在实践中锻炼自己。
2、写程序的过程中尽量在正确的基础上追求简洁。
3、在做设计的时候要有信心,有耐心,切勿浮躁。
4、认真的学习课本知识,掌握课本中的知识点,并在此基础上学会灵活运用,不过也不能完全依赖课本。
5、在课余时间里多写程序,熟练掌握在调试程序的过程中所遇到的常见错误,以便能节省调试程序的时间。
6、参考文献(1)万健主编,数据结构实用教程(C++版),电子工业出版社,2011(2)网上搜索相关程序作为参考7、程序运行结果:附件:#include <iostream>using namespace std;#include "SqStack.h"struct PosType //马的坐标位置类型{int m_row; //行值int m_col; //列值};struct DataType //栈的元素类型{PosType seat; //马在棋盘中的“坐标位置”int di; //换方向的次数};class chess{public:chess();bool chessPath(PosType);void Print();private:PosType NextPos(PosType c , int d );int m_chess[8][8]; // 棋盘数组};chess::chess(){int i,j;for(i=0;i<=7;i++)for(j=0;j<=7;j++)m_chess[i][j]=0;}bool chess::chessPath(PosType start){SqStack<DataType> path(64); //创建栈PosType curpos;DataType e;curpos=start ;int curstep=1; //第几次走的位置do{if(curpos.m_row<=7 && curpos.m_row>=0 &&curpos.m_col>=0 && curpos.m_col<=7)//走在棋盘之内{ if(m_chess[curpos.m_row][curpos.m_col]==0){m_chess[curpos.m_row][curpos.m_col]=curstep; //留下足迹,标注当前位置是马第几次走e.seat.m_row=curpos.m_row;e.seat.m_col=curpos.m_col;e.di=0;path.Push(e); //当前位置和方向入栈curstep++;if(curstep==65)return true;curpos=NextPos(curpos,e.di); }elsecurpos=NextPos(curpos,e.di++); //在棋盘之外自动进行下一次试探}else{ //当前位置已走过if(!path.Empty()){e=path.Top();path.Pop();curstep--;while(e.di==7 && !path.Empty()){ //该位置已无路可走m_chess[e.seat.m_row][e.seat.m_col]=0;e=path.Top(); //退回一步path.Pop();curstep--;}if(e.di<7){ //没到可能的最后一个位置e.di++; //换下一个位置path.Push(e);curstep++;curpos=NextPos(e.seat,e.di);}}}}while(curstep<=64); //马已经走的步数return false;}void chess::Print(){int i,j;for(i=0;i<8;i++){for(j=0;j<8;j++)cout<<m_chess[i][j]<<'\t'; //输出对齐,水平制表cout<<endl;}cout<<endl;}PosType chess::NextPos(PosType a,int di)//根据当前点的位置a和移动方向di,试探下一位置{PosType direct[8]={{2,1},{1,2},{-1,2},{-2,1},{-2,-1},{-1,-2},{1,-2},{2,-1}};//按照顺时针试探的8个位置a.m_row+=direct[di].m_row;a.m_col+=direct[di].m_col;return a;}void main(){PosType first;chess chess;cout<<"请输入马的初始位置(第几行第几列):";cin>>first.m_row>>first.m_col;chess.chessPath(first);cout<<"马走过的一条路径如下:"<<endl;chess.Print();}#define _SQSTACK_H_//定义顺序栈类template <class ElemType>//声明一个类模板class SqStack{public: //顺序栈类的各成员函数SqStack(int m = 100);~SqStack();void Clear();bool Empty() const;int Length() const;ElemType & Top() const;void Push(const ElemType &e);void Pop();private: //顺序栈类的数据成员ElemType *m_base; //基地址指针int m_top; //栈顶指针int m_size; //向量空间大小};//构造函数,分配m个结点的顺序空间,构造一个空的顺序栈。
template <class ElemType>SqStack <ElemType>::SqStack(int m){m_top = 0;m_base = new ElemType[m];m_size = m;}//SqStack//析构函数,将栈结构销毁。
template <class ElemType>SqStack <ElemType>::~SqStack(){if (m_base != NULL) delete[] m_base;}//~SqStack//清空栈。
template <class ElemType>void SqStack <ElemType>::Clear()m_top = 0;}//Clear//判栈是否为空,若为空,则返回true,否则返回false。
template <class ElemType>bool SqStack <ElemType>::Empty() const{return m_top == 0;}//Empty//求栈的长度。
template <class ElemType>int SqStack <ElemType>::Length() const{return m_top;}//Length//取栈顶元素的值。
先决条件是栈不空。
template <class ElemType>ElemType & SqStack <ElemType>::Top() const{return m_base[m_top - 1];}//Top//入栈,若栈满,则先扩展空间。
插入e到栈顶。
template <class ElemType>void SqStack <ElemType>::Push(const ElemType &e){if(m_top >= m_size){ //若栈满,则扩展空间。
ElemType *newbase;newbase = new ElemType[m_size + 10];for(int j = 0; j < m_top; j++)newbase[j] = m_base[j];delete[] m_base;m_base = newbase;m_size += 10;}m_base[m_top++] = e;}//Push//出栈,弹出栈顶元素。