机软二次作业Word文档下载推荐.docx
《机软二次作业Word文档下载推荐.docx》由会员分享，可在线阅读，更多相关《机软二次作业Word文档下载推荐.docx（24页珍藏版）》请在冰豆网上搜索。
top==N-1）{
printf（"
\nStackOverflow!
\n"
）;
return（False）;
}
else{
s->
top++;
|*新节点指向栈顶并将其数据赋值*|
stack[s->
top]=x;
return（True）;
}/*InitializeStack*/
ElemTypePop（STACK*s）{
ElemTypex;
inti;
top<
0）{
x.num=Null;
x.arrtime=Null;
return（x）;
}
top--;
|*后面的车依次开出*|
i=s->
top+1;
x=s->
stack[i];
|*该走的车开出后其余的车依原来的次序进场*|
returnx;
}/*Pop*/
voidIniLinkedQue（LinkedQueTp*s）{
QUEUE*p1;
front=（QUEUE*）malloc（sizeof（QUEUE））;
|*申请新节点*|
rear=s->
front;
|*队空*|
p1=s->
p1->
next=Null;
/*头结点指针域初始化*/
num=0;
/*头结点数据域初始化*/
}/*IniLinkedQue*/
voidEnLinkedQue（LinkedQueTp*s,intnum1）{/*数据入队列（链接式循环队列）*/
QUEUE*p,*p1;
p=（QUEUE*）malloc（sizeof（QUEUE））;
/*产生一个新节点*/
p->
num=num1;
rear;
/*加入队尾*/
next=p;
rear=p;
num++;
/*修改保存在头结点数据域中的车辆数*/
}/*EnLinkedQue*/
intDeLinkedQue（LinkedQueTp*s）{/*数据节点出队列*/
QUEUE*p;
intn;
front==s->
rear）return（Null）;
|*判断是否队空*|
p=s->
front->
next;
|*令p指向头指针的前一个*|
next=p->
|*删除节点p*|
if（p->
next==Null）s->
|*判断是否为空*|
n=p->
num;
free（p）;
|*释放节点p*|
num--;
|*s指向队头数量递减*|
return（n）;
}
}/*DeLinkedQue*/
voidArrive（STACK*s1,LinkedQueTp*p,ElemTypex）{/*车辆到达处理*/
intf,no1,no2;
/*可以删去*/
f=Push（s1,x）;
/*新到车辆进入停车场栈*/
if（f==False）{/*如停车场满,就进入便道队列等待*/
EnLinkedQue（p,x.num）;
no1=p->
/*可以删去*/
printf（"
第%d号车停在便道的第%d号车位上\n"
x.num,no1）;
/*改为：
x.num,p->
num）;
*/
else{/*新到车辆进入停车场*/
no1=s1->
/*可以删去*/
no2=x.num;
第%d号车停在停车场的第%d号车位上\n"
no2,no1）;
x.num,s1->
top+1）;
}/*Arrive*/
voidDelive（STACK*s1,STACK*s2,LinkedQueTp*p,ElemTypex）{/*离开处理*/
intn,f=False;
ElemTypey,z;
/*增加z*/
QUEUE*q;
while（（s1->
top>
-1）&
&
（f!
=True））{/*在停车场中寻找要离开的车辆*/
y=Pop（s1）;
if（y.num!
=x.num）/*如果栈顶元素不是要离开的车辆,就将其放如车辆规闭所*/
n=Push（s2,y）;
elsef=True;
/******/
if（y.num==x.num）{/*在停车场中找到要离开的车辆*/
第%d号车应收费%d元"
y.num,（x.arrtime-y.arrtime）*M）;
while（s2->
-1）{
-1）{/*调整到*****处，将y改为z*/
y=Pop（s2）;
f=Push（s1,y）;
n=DeLinkedQue（p）;
if（n!
=Null）{/*有车在队列中等待*/
y.num=n;
y.arrtime=x.arrtime;
第%d号车停在停车场第%d号车位上\n"
y.num,s1->
else{/*在停车场中没有找到要离开的车辆*/
-1）{/*删除*/
y=Pop（s2）;
f=Push（s1,y）;
q=p->
/*指向队头*/
f=False;
while（f==False&
q->
next!
=Null）/*在便道上寻找要离开的车辆*/
if（q->
next->
num!
=x.num）q=q->
next=q->
/*在便道上找到该车辆*/
next==Null）p->
rear=q;
/*=p->
front是错误的*/
第%d号车离开便道\n"
x.num）;
/*该车离开便道,但不收费*/
f=True;
if（f==False）
输入数据错误,停车场和便道上均无第%d号车\n"
voidmain（）{/*停车场模拟管理程序*/
charch1,ch2;
STACK*s1,*s2;
LinkedQueTp*p;
intflag,t1,t2;
s1=（STACK*）malloc（sizeof（STACK））;
s2=（STACK*）malloc（sizeof（STACK））;
p=（LinkedQueTp*）malloc（sizeof（LinkedQueTp））;
IniStack（s1）;
/*初始化停车场栈*/
IniStack（s2）;
/*初始化车辆规避所栈*/
IniLinkedQue（p）;
/*初始化便道队列*/
flag=True;
for（;
;
）{
clrscr（）;
\n输入数据：
'
A'
/'
D'
车牌号，到达时间/离开时间\n"
E---退出。
scanf（"
%c,%d,%d"
&
ch1,&
t1,&
t2）;
x.num=t1;
x.arrtime=t2;
/*只记录小时值，没有考虑分钟*/
ch2=getchar（）;
/*清空输入缓冲区*/
switch（ch1）{
case'
a'
:
Arrive（s1,p,x）;
\nPressanykeytocontinue...\n"
getch（）;
break;
d'
Delive（s1,s2,p,x）;
e'
E'
flag=False;
printf（"
\n程序正常结束\n"
break;
default:
\n输入数据错误，重新输入\n"
if（flag==False）break;
/*退出循环*/
}
/*迷宫问题*/
#defineM212
#defineN211
#defineMAXLENM2
string.h>
intM=M2-2,N=N2-2;
typedefstructelem{
intx,y,dir;
typedefstructstktag{
ElemTypestack[MAXLEN];
|*存放站的数据元素*|
|*棧顶指针用来存放棧顶元素在数组中的下标*|
typedefstructmoved{
intdx,dy;
}MOVE;
voidIniMaze（intmaze[][N2]）;
/*初始化迷宫*/
voidIniMove（MOVEmove[]）;
|*移动位置*|
|*初始化棧s*|
|*进栈*|
voidpath（intmaze[][N2],MOVEmove[],STACK*s）;
|*初始化路径*|
voiddraw（intmaze[][N2],STACK*s）;
|*初始化迷宫数组*|
voidmain（）{/*寻找迷宫通路程序*/
STACK*s;
intmaze[M2][N2];
MOVEmove[8];
IniMaze（maze）;
/*初始化迷宫数组*/
s=（STACK*）malloc（sizeof（STACK））;
IniStack（s）;
|*初始化棧s为空栈*|
IniMove（move）;
|*移动位置*|
path（maze,move,s）;
|迷宫路径*|
draw（maze,s）;
}/*main*/
voidIniMaze（intmaze[][N2]）{/*初始化迷宫*/
inti,j,num;
for（i=0,j=0;
i<
=M+1;
i++）maze[i][j]=1;
for（i=0,j=N+1;
i++）maze[i][j]=1;
|*沿数组横向移动*|
j<
=N+1;
j++）maze[i][j]=1;
for（i=M+1,j=0;
|*沿数组纵向移动*|
for（i=1;
=M;
i++）{
for（j=1;
=N;
j++）{
num=（800*（i+j）+1500）%327;
|*将0和1散乱分布*|
if（（num<
150）&
（i!
=M||j!
=N））maze[i][j]=1;
elsemaze[i][j]=0;
for（i=0;
for（j=0;
if（（i==0）&
（j==0）||（i==M+1）&
（j==N+1））printf（"
%3d"
0）;
elseprintf（"
maze[i][j]）;
|*输出坐标*|}
}/*IniMaze*/
voidIniMove（MOVEmove[]）{
move[0].dx=0;
move[0].dy=1;
/*North*/
move[1].dx=1;
move[1].dy=1;
/*North-East*/
move[2].dx=1;
move[2].dy=0;
/*East*/
move[3].dx=1;
move[3].dy=-1;
SouthEast*/
move[4].dx=0;
move[4].dy=-1;
South*/
move[5].dx=-1;
move[5].dy=-1;
/*SouthWest*/
move[6].dx=-1;
move[6].dy=0;
/*West*/
move[7].dx=-1;
move[7].dy=1;
/*NorthWest*/
}/*IniMove*/
voidIniStack（STACK*s）{|*初始化s棧*|
|*顺序棧的棧顶指针*|
}/*IniStack*/
intPush（STACK*s,ElemTypex）{
top==MAXLEN-1）return（False）;
|*判断是否棧满*|
stack[++s->
|*s进棧并将其赋值为x*|
/*Push*/
ElemTypePop（STACK*s）{|*出棧*|
ElemTypeelem;
elem.x=Null;
elem.y=Null;
elem.dir=Null;
return（elem）;
|*判断是否为空栈*|
|*从棧顶出棧*|
return（s->
top+1]）;
}/*pop*/
voidpath（intmaze[][N2],MOVEmove[],STACK*s）{|*移动路径*|
inti,j,dir,x,y,f;
i=1;
j=1;
dir=0;
maze[1][1]=-1;
/*设[1][1]为入口处*/
do{
x=i+move[dir].dx;
/*求下一步可行的到达点的坐标*/
y=j+move[dir].dy;
if（maze[x][y]==0）{
elem.x=i;
elem.y=j;
elem.dir=dir;
f=Push（s,elem）;
if（f==False）printf（"
栈长度太短\n"
i=x;
j=y;
maze[x][y]=-1;
elseif（dir<
7）dir++;
else{/*8个方向都不可行,就退回一步*/
elem=Pop（s）;
if（elem.x!
=Null）{
i=elem.x;
j=elem.y;
dir=elem.dir+1;
}while（!
（（s->
top==-1）&
（dir>
=7）||（x==M）&
（y==N）&
（maze[x][y]==-1）））;
top==-1）printf（"
此迷宫无路\n"
elem.x=x;
elem.y=y;
elem.dir=dir;
|*进棧函数*|
\n迷宫的通路是:
i=0;
while（i<
=s->
top）{
（%d,%d）"
s->
stack[i].x,s->
stack[i].y）;
/*显示迷宫通路*/
if（i!
top）printf（"
-->
"
|*非空*|
if（（i+1）%4==0）printf（"
i++;
}/*path*/
voiddraw（intmaze[][N2],STACK*s）{|*初始化路径数组*|
inti,j;
i++）/*将迷宫中全部的-1值恢复为0值*/
j++）
if（maze[i][j]==-1）maze[i][j]=0;
while（s->
-1）{/*根据栈中元素的坐标,将通路的各个点的值改为8*/
maze[i][j]=8;
elseif（maze[i][j]==8）printf（"
%c"
'
*'
|*再通路标记**|
/*显示已标记通路的迷宫*/
}/*draw*/
/*迷宫2---最短路线*/
#defineMAXLENM2*N2
typedefstructelem{/*定义栈元素的数据类型*/
intx,y;
intdir;
typedefstructstktag{/*定义顺序栈结构*/
|*存放棧的数据元素*|
}STACK;
typedefstructQueEle{/*定义队列元素的数据类型*/
intpre;
}QueElem;
typedefstructQueTag{
QueElemqueue[MAXLEN];
intfront,rear;
|*定义队头队尾*|
}QUEUE;
typedefstructmoved{/*定义方向位移数组元素的类型*/
}MOVE;
|8初始化移动方位*|
|*初始化s为空棧*|
|*x进棧*|
|*出栈函数*|
intshortpath（intmaze[][N2],MOVEmove[],QUEUE*p）;
voidIniQueue（QUEUE*s）;
/*初始化队列*/
voidprintpath（QUEUE*p,STACK*s）;
intmaze[M2][N2],f;
升级会员 