数据结构 上机报告.docx

数据结构 上机报告.docx

《数据结构 上机报告.docx》由会员分享，可在线阅读，更多相关《数据结构 上机报告.docx（49页珍藏版）》请在冰豆网上搜索。

数据结构上机报告

数据结构上机报告

（三次）

班级：

自动化1304

姓名：

王柄淋

学号：

U201314621

华中科技大学自动化学院

1.第一次上机

下雨

本程序要求彩色的雨点从天而降，当碰到虚拟的地面时，产生一个水波，同时有声音产生。

对于每一次运行，都能设计雨点的多少和下降的速度，不同的设计呈现出不同的效果。

可以随机的对雨点的位置进行设置，随时对雨点的下落位置进行定位。

多个雨点按照各自的随机参数和存在状态，同时演示在屏幕上，可以适当的控制雨点的密度、最大水圈和状态变化的时间间隔等参数

主要的数据类型有两个带头结点的双向循环链表，如下：

typedef

struct//单个雨滴

colorrefcolor;//雨滴颜色

boolvisibility;//可见性

floatradius;//半径

floatx;//雨滴中心位置x

floaty;//雨滴中心位置y

floatxvelocity;//雨滴速率vx

floatyvelocity;//雨滴速率vy>droplet;

structdropletchaintypedefstructripple;structripplechain

采用方便的用户输入界面，直接输入两个变量值，一个是雨点的数量，一个是雨点延迟时间，雨点的数量越多，运行的时间越多，所要用的内存也相对要多；同理输入的雨点的延迟时间越长，程序运行中所需要的保存状态的内存量就大，而其运行的时间也相对多点。

不管是用何种方式，运行的硬件的条件不变。

voidinitgr（void）

初始条件：

已经有雨点存在或者是水纹存在

操作结果：

图形显示

voidmain（）

操作结果：

创建主函数

voidbackground（void）

操作结果：

绘制背景图

voidrain（void）

操作结果：

创建下雨函数

structdrop*creatDrop（void）

操作结果：

创建雨点

voidrecreatDrop（structdrop*p）

操作结果：

雨点重新创建

voidcreatRain（void）

操作结果：

创建雨点链表

voiddrop（structdrop*p）

操作结果：

创建雨点下落过程的函数

voiddrawdrop（structdrop*p）

操作结果：

画雨点函数

voidcleardrop（structdrop*p）

操作结果：

清除雨点函数

voidwave（structdrop*p）

操作结果：

创建水纹产生函数

voiddraw（structdrop*p）

操作结果：

画水纹函数

voidclear（structdrop*p）

操作结果：

清除水纹函数

voidrelease（void）

操作结果：

清楚雨点链表函数

//源程序文件清单：

1.#include"stdlib.h"

2.#include"time.h"

3.#include"dos.h"

4.#include"stdio.h"

5.#include"Conio.h"

6.#include"graphics.h"

7.#defineclosegrclosegraph

8.#defineLENsizeof（structdrop）

9.#defineNULL0

10.intdowndelay=300;

11.intdropNumber=10;

12.structdrop/*雨点储存结构*/

13.{

14.intx;

15.inty0;

16.intyt;

17.intcolor;

18.intinc;

19.inti;

20.intj;

21.intr;

22.structdrop*next;

23.};

24.structdrop*head;

25.voidinitgr（void）

26.{

27.intgd=DETECT,gm=0;

28.//registerbgidriver（EGAVGA_driver）;

29.initgraph（&gd,&gm,"..//bgi"）;

30.}

31.voidmain（）/*主函数*/

32.{

33.voidbackground（void）;

34.voidcreatRain（void）;

35.voidrain（void）;

36.voidrelease（void）;

37.initgr（）;

38.printf（"Pleaseinputthenumberofdrops:

"）;

39.scanf（"%d",&dropNumber）;

40.printf（"Pleaseinputthedelay:

"）;

41.scanf（"%d",&downdelay）;

42.background（）;

43.creatRain（）;

44.rain（）;

45.release（）;

46.getch（）;

47.closegr（）;

48.}

49.

50./**********************RAIN*********************************/

51.voidbackground（void）/*画夜幕和池塘*/

52.{

53.setbkcolor（BLACK）;

54.setfillstyle（1,BLUE）;

55.bar（0,380,640,480）;

56.}

57.voidrain（void）/*下雨函数*/

58.{

59.voiddrop（structdrop*p）;

60.voidwave（structdrop*p）;

61.structdrop*p;

62.p=head;

63.while（!

kbhit（））

64.{

65.if（p==NULL）p=head;

66.else

67.{

68.if（p->inc==0）drop（p）;

69.elsewave（p）;

70.}

71.delay（downdelay）;

72.p=p->next;

73.}

74.}

75./**********************BASE*********************************/

76.structdrop*creatDrop（void）/*创建单个雨滴*/

77.{

78.structdrop*p;

79.p=malloc（LEN）;

80.p->x=rand（）%640;

81.p->y0=rand（）%430;

82.p->yt=430+rand（）%50;

83.p->color=rand（）%15+1;

84.p->inc=0;

85.p->i=0;

86.p->j=rand（）%15;

87.p->r=26;

88.p->next=NULL;

89.return（p）;

90.}

91.voidrecreatDrop（structdrop*p）/*重建雨滴*/

92.{

93.p->x=rand（）%640;

94.p->y0=rand（）%430;

95.p->yt=430+rand（）%50;

96.p->color=rand（）%15+1;

97.p->inc=0;

98.p->i=0;

99.p->j=rand（）%15;

100.p->r=26;

101.}

102.voidcreatRain（void）/*创建雨点链表*/

103.{

104.structdrop*p1,*p2;

105.inti;

106.p1=p2=creatDrop（）;

107.head=p1;

108.for（i=0;i

109.{

110.p2=creatDrop（）;

111.p1->next=p2;

112.p1=p2;

113.}

114.}

115.

116./**********************DROP*********************************/

117.voiddrop（structdrop*p）/*雨滴下落函数*/

118.{

119.voiddrawdrop（structdrop*p）;

120.voidcleardrop（structdrop*p）;

121.if（p->y0<=p->yt）

122.{

123.drawdrop（p）;

124.if（p->y0<385）setcolor（BLACK）;

125.elsesetcolor（BLUE）;

126.cleardrop（p）;

127.p->y0++;

128.}

129.else

130.{

131.setcolor（BLUE）;

132.line（p->x,p->y0,p->x,p->y0+5）;

133.p->inc=1;

134.}

135.}

136.voiddrawdrop（structdrop*p）/*画雨点函数*/

137.{

138.setcolor（p->color）;

139.setlinestyle（0,0,1）;

140.line（p->x,p->y0,p->x,p->y0+5）;

141.}

142.voidcleardrop（structdrop*p）/*清楚雨点函数*/

143.{

144.setlinestyle（0,0,1）;

145.line（p->x,p->y0-5,p->x,p->y0）;

146.}

147.

148./**********************WAVE*********************************/

149.voidwave（structdrop*p）/*水纹产生函数*/

150.{

151.voiddraw（structdrop*p）;

152.voidclear（structdrop*p）;

153.sound（500）;

154.nosound（）;

155.if（p->ir）

156.{

157.draw（p）;

158.clear（p）;

159.p->i+=2;

160.}

161.else

162.{

163.clear（p）;

164.recreatDrop（p）;

165.}

166.}/*绘画水纹函数*/

167.voiddraw（structdrop*p）

168.{

169.setcolor（p->color）;

170.setlinestyle（0,0,1）;

171.ellipse（p->x,p->yt,0,360,p->j+p->i,0+p->i）;

172.}

173.voidclear（structdrop*p）/*清楚水纹函数*/

174.{

175.setcolor（BLUE）;

176.setlinestyle（0,0,1）;

177.ellipse（p->x,p->yt,0,360,p->j+p->i-2,0+p->i-2）;

178.return（p）;

179.}

180./**********************CLEAR********************************/

181.voidrelease（void）/*清楚雨点链表*/

182.{

183.structdrop*p1,*p2;

184.p1=head;

185.while（p1!

=NULL）

186.{

187.p2=p1;

188.p1=p1->next;

189.free（p2）;

190.}

191.}

2.第二次上机

一．栈的操作

#defineSTACK_INIT_SIZE10/*存储空间初始分配量*/

#defineSTACKINCREMENT2/*存储空间分配增量*/

#defineOVERFLOW0

typedefstructSqStack

{

SElemType*base;/*在栈构造之前和销毁之后，base的值为NULL*/

SElemType*top;/*栈顶指针*/

intstacksize;/*当前已分配的存储空间，以元素为单位*/

}SqStack;/*顺序栈*/

StatusInitStack（SqStack*S）

{/*构造一个空栈S*/

（*S）.base=（SElemType*）malloc（STACK_INIT_SIZE*sizeof（SElemType））;

if（!

（*S）.base）

exit（OVERFLOW）;/*存储分配失败*/

（*S）.top=（*S）.base;

（*S）.stacksize=STACK_INIT_SIZE;

returnOK;

}

StatusDestroyStack（SqStack*S）

{/*销毁栈S，S不再存在*/

free（（*S）.base）;

（*S）.base=NULL;

（*S）.top=NULL;

（*S）.stacksize=0;

returnOK;

}

StatusClearStack（SqStack*S）

{/*把S置为空栈*/

（*S）.top=（*S）.base;

returnOK;

}

StatusStackEmpty（SqStackS）

{/*若栈S为空栈，则返回TRUE，否则返回FALSE*/

if（S.top==S.base）

returnTRUE;

else

returnFALSE;

}

intStackLength（SqStackS）

{/*返回S的元素个数，即栈的长度*/

returnS.top-S.base;

}

StatusGetTop（SqStackS,SElemType*e）

{/*若栈不空，则用e返回S的栈顶元素，并返回OK；否则返回ERROR*/

if（S.top>S.base）

{

*e=*（S.top-1）;

returnOK;

}

else

returnERROR;

}

StatusPush（SqStack*S,SElemTypee）

{/*插入元素e为新的栈顶元素*/

if（（*S）.top-（*S）.base>=（*S）.stacksize）/*栈满，追加存储空间*/

{

（*S）.base=（SElemType*）realloc（（*S）.base,（（*S）.stacksize+STACKINCREMENT）*sizeof（SElemType））;

if（!

（*S）.base）

exit（OVERFLOW）;/*存储分配失败*/

（*S）.top=（*S）.base+（*S）.stacksize;

（*S）.stacksize+=STACKINCREMENT;

}

*（（*S）.top）++=e;

returnOK;

}

StatusPop（SqStack*S,SElemType*e）

{/*若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR*/

if（（*S）.top==（*S）.base）

returnERROR;

*e=*--（*S）.top;

returnOK;

}

StatusStackTraverse（SqStackS,Status（*visit）（SElemType））

{/*从栈底到栈顶依次对栈中每个元素调用函数visit（）。

*/

/*一旦visit（）失败，则操作失败*/

while（S.top>S.base）

visit（*S.base++）;

printf（"\n"）;

returnOK;

}

二，迷宫问题

用一个字符类型的二维数组表示迷宫，数组中每个元素取值“0”（表示通路）或“1”（表示墙壁）。

二维数组的第0行、第m+1行、第0列、第m+1列元素全置成“1”，表示迷宫的边界；第1行第1列元素和第m行第n列元素置成“0”，表示迷宫的入口和出口走迷宫的过程可以模拟为一个搜索的过程：

每到一处，总让它按东、南、西、北4个方向顺序试探下一个位置；用二维数组move记录4个方向上行下标增量和列下标增量，则沿第i个方向前进一步，可能到达的新位置坐标可利用move数组确定：

x=x+move[i][0]Py=y+move[i][1]如果某方向可以通过，并且不曾到达，则前进一步，在新位置上继续进行搜索；如果4个方向都走不通或曾经到达过，则退回一步，在原来的位置上继续试探下一位置。

设迷宫为m行n列，利用maze[m][n]来表示一个迷宫，maze[i][j]=0或1;其中：

0表示通路，1表示不通，当从某点向下试探时，中间点有4个方向可以试探，（见图）而四个角点有2个方向，其它边缘点有3个方向，为使问题简单化我们用maze[m+2][n+2]来表示迷宫，而迷宫的四周的值全部为1。

这样做使问题简单了，每个点的试探方向全部为4，不用再判断当前点的试探方向有几个，同时与迷宫周围是墙壁这一实际问题相一致。

假设有6行8列的迷宫，如下图为maze[8][10]构造的迷宫。

在上述表示迷宫的情况下，每个点有4个方向去试探，如当前点的坐标（x,y），与其相邻的4个点的坐标都可根据与该点的相邻方位而得到，如图2所示。

因为出口在（m，n），因此试探顺序规定为：

从当前位置向前试探的方向为从正东沿顺时针方向进行。

为了简化问题，方便的求出新点的坐标，将从正东开始沿顺时针进行的这4个方向（用0，1，2，3表示东、南、西、北）的坐标增量放在一个结构数组move[4]中，在move数组中，每个元素有两个域组成，x：

横坐标增量，y：

纵坐标增量。

Move数组如图3所示。

栈的设计当到达了某点而无路可走时需返回前一点，再从前一点开始向下一个方向继续试探。

因此，压入栈中的不仅是顺序到达的各点的坐标，而且还要有从前一点到达本点的方向，即每走一步栈中记下的内容为（行，列，来的方向）。

源代码：

#include"stdio.h"

#include"malloc.h"

#include"stdlib.h"

#include

#defineTRUE1

#defineFALSE0

#defineOK1

#defineERROR0

#defineINFEASIBLE-1

typedefintStatus;

typedefstruct/*迷宫坐标位置类型*/

{

intx;/*行值*/

inty;/*列值*/

}PosType;

typedefintMazeType[10][10];/*迷宫数组[行][列]*/

MazeTypem;/*迷宫数组全局变量处理因为我在初始化的时候老是弄出毛病*/

intcurstep=1;/*当前足迹是第几个,初值为1*/

typedefstruct/*栈的元素类型*/

{

intord;/*通道块在路径上的＂序号＂*/

PosTypeseat;/*通道块在迷宫中的＂坐标位置＂*/

intdi;/*从此通道块走向下一通道块的＂方向＂（0～3表示东～北）*/

}SElemType;

#include"Stack.h"

/*此处因为在Stack.h中用到了SElemeType所以在此处导入stack.h*/

/*定义墙元素值为0,可通过路径为1,不能通过路径为-1,通过路径为足迹记录为*

voidmazeprint（）

{/*输出迷宫的解*/

inti,j;

for（i=0;i<10;i++）

{

for（j=0;j<10;j++）

{

if（m[i][j]==（int）"*"）//输出时如果是*则输出*

printf（"*"）;

else{

printf（"%2d",m[i][j]）;

if（j==9）

printf（"\n"）;

}

}

}

}

StatusPass（PosTypeb）

{/*当迷宫m的b点的序号为1（可通过路径），returnOK;否则，returnERROR。

*/

if（m[b.x][b.y]==1）

returnOK;

else

returnERROR;

}

voidFootPrint（PosTypea）/*使迷宫m的a点的序号变为足迹（curstep）*/

{m[a.x][a.y]=（int）"*";}

PosTypeNextPos（PosTypec,intdi）

{/*根据当前位置及移动方向，返回下一位置*/

PosTypedirec[4]={{0,1},{1,0},{0,-1},{-1,0}};/*{行增量,列增量}*/

/*移动方向,依次为东南西北*/

c.x+=direc[di].x;

c.y+=direc[di].y;

returnc;

}

voidMarkPrint（PosTypeb）

{/*使迷宫m的b点的序号变为-1（不能通过的路径）*/

m[b.x][b.y]=-1;

}

StatusMazePath（PosTypestart,PosTypeend）

{/*若迷宫maze中存在从入口start到出口end的通道，则求得一条*/

SqStackS;/*存放在栈中（从栈底到栈顶），并返回TRUE；否则返回FALSE*/

PosTypecurpos;

SElemTypee;

InitStack（&S）;

curpos=start;