机软二次作业Word文档下载推荐.docx
《机软二次作业Word文档下载推荐.docx》由会员分享,可在线阅读,更多相关《机软二次作业Word文档下载推荐.docx(24页珍藏版)》请在冰豆网上搜索。
![机软二次作业Word文档下载推荐.docx](https://file1.bdocx.com/fileroot1/2022-12/14/5ea404d2-5856-45a6-bfc1-9a888ca82e44/5ea404d2-5856-45a6-bfc1-9a888ca82e441.gif)
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;