一、需求分析
1．车辆目前情况，用户通过键盘输入，以栈模拟停车场，以队列模拟车场外的便道，按照从终端读入的输入数据序列进行模拟管理。每一组输入数据包括三个数据项：汽车“到达”或“离去”信息、汽车牌照号码以及到达或离去的时刻。对每一组输入数据进行操作后的输出信息为：若是车辆到达，则输出汽车在停车场内或便道上的停车位置；若是车辆离去，则输出汽车在停车场内停留的时间（离开时间减去停在停车场的时间）和应交纳的费用（在便道上停留的时间不收费）。
2.依次输入一系列数据项（3个数据：第一个字符数据A或D表示车辆的到达或离开，第二整形数据表示车辆的车牌号码，第三个整形数据表示汽车到达或离去的时间），要求同一辆汽车到达的时间比离开的时间早。
3.测试数据
设停车场能容纳3辆车。
请输入车辆目前情况：A ,1，5
1车辆停入停车场1号。
请输入车辆目前情况：A ,2，6
1车辆停入停车场1号
2车辆停入停车场2号。
请输入车辆目前情况：A ,3，5
输入时间错误哦！
请输入车辆目前情况：A ,3，6
1车辆停入停车场1号
2车辆停入停车场2号。
3车辆停入停车场3号。
请输入车辆目前情况：A ,4，6
1车辆停入停车场1号。
2车辆停入停车场2号。
3车辆停入停车场3号。
4车辆在便道1号。
停车场已满。4车辆已放在便道。
请输入车辆目前情况：D ,1，7
1车辆已离开。时间5，收费10块。
2车辆停入停车场1号。
3车辆停入停车场2号。
4车辆停入停车场3号。
请输入车辆目前情况：E ,0，0
程序结束，感谢使用本程序哦。
本程序其他错误处理，没有设置处理。
二、概要设计抽象数据类型
基本操作对象是汽车类，包含来去信息，车牌号以及到达时间；
Class Car//车辆信息
{
Public：
int Lincese ；//车牌号
int ArriveTime ；//到达时间
}；
便道先进先出的特性用队列是十分好的，但停车场有一个要求就是先进的要出去时，所有车辆都要让路，所以停车场用栈来模拟，便道使用队列来模拟； ADT StopStack
数据对象：D={i a |i a ∈class car};
数据关系：R1＝{
约定an 端为栈顶，a1 端为栈底。
基本操作：
bool push （const Car& item ）；
Bool pop （Car&it ）；
bool topValue （Car&it ）；
int lengh （）const{return top;}
ADT StopQueue
数据对象：R={i a |i a ∈class car};
数据关系： R1＝{ | ai-1, ai ∈R, i=2,...,n}
约定其中a1 端为队列头， an 端为队列尾
基本操作：
bool enquene （constCar&item ）；
bool dequene （Car&it ）；
bool frontValue （Car&it ）；
int length （）；
算法的基本思想
（1）用一车类对象做中介，存储输入的要进停车场某一车量情况。
（2）当车进来的时候，首先让其按时间顺序依次入栈。（A 为入栈，D 为出栈，E 为输入结束。）
（3）当size=3即栈满时,让其在便道时按时间顺序依次入队；
（4）当输入某元素要出栈时，让其上面元素依次压入另一个临时栈，并用通过当时车类的对象减去入栈时时间，算出停车时间，计算出停车费用，。在将临时栈中元素入栈。队列第一个元素入栈。
程序的流程
程序由三个模块组成：
（1） 输入模块：通过键盘输入某一车辆现在状态。
（2） 管理模块：首先判断第一个字符为A 时，将该车类对象入栈，栈满时，
在依次入队，当字符为D 时，栈中元素出栈，记录当时出栈时间，得
到停留时间，算出停车费用，若队中元素出列，无停车费用。
(3)输出模块：输出车站目前车辆情况。
三、详细设计
物理数据类型
数据类型（物理数据结构）的实现：
Class Car//车辆信息
{
Public：
int Lincese；//车牌号
int ArriveTime；//到达时间
}；
模拟停车场的栈：
Class StopStack: public car
{
{
Private:
int size;
int top;
Car* listArray;
Public:
StopStack(int sz=DefaultListSize)
{size=sz;top=0;listArray=new Car[sz];}
~StopStack(){delete[]listArray;}
boolpush（constCar&item）
{if(top==size)Returnfalse;
Else{listArray[top++]=item;returnture;}}
boolpop（Car&it）
{if(top==0)Return false;
Else {it==listArray[--top];return true;}}
}
booltopValue（Car&it）
{if(top==0)return false;
Else{it=listArray[top-1];return true;}
int length（）const{return top;}
};
物理实现模拟便道的队列,使用顺序队列。
Class StopQuene
{
Private:
int size;
int front;
int rear;
Car *listArray;
Public:
StopQuene(
Int sz){size=sz+1;rear=0;front=1;listArray=newCar[size];} ~StopQuene(){delete []listArray;}
bool enquene（const Car&item）
{ if((rear+2)%size==front) return false;
Rear=(rear+1)%size;
listArray[rear]=it;
Return
ture;
}
bool dequene（Car&it）
{ if(length()==0)return false;
It=listArray[front];
front=(front+1)%size;returntrue;}
boolfrontValue（Car&it）
{ if(length()==0)returnfalse;
It=listArray[front];returntrue;}
intlength（）const{return((rear+size)-front+1)%size;}
};
算法的具体步骤
Stopstack depot(3); //定义停车场，最大元素为3
stopquence q(50);
while(1)
{
Stopstack temp(2); //定义临时栈Car c;
char ch,j;
cout<<"请输入车辆目前情况:";
cin>>ch;
cin>>c;
if(ch=='E')
break;
else if(ch=='A')
{
if(length()!=3)
depot.push(c); //元素（车辆）入栈 else
q.dequene(c); //元素入列
{......} //输出车站停车情况 }
else if(ch=='D')
{
while(top.lincese!=c.lincese)
{
car k;
k=depot.pop(); //栈中元素出栈
temp.push(k); //进入临时栈
}
{""""} //输出费用 while(temp.length())
{ car k;
k=temp.pop();
depot.push(k);
}
if(q.length!=0)
{ car k;
k=q.dequene(); //元素出栈
k.arrive=ch.arrive;
depot.push(k);
}
}
}
算法的时空分析
算法的执行，入栈，出栈，入队列，出队列。入栈时间复杂度O （1），出栈O（N），输入N次，时间复杂度最坏为O（N^2）,最好为 O（N），出入队同理。
输入和输出的格式
输入
请输入车辆到达或离开情况情况：
等待输入
输出：
车辆在停车场号
四、调试分析
代码太长了、
五、测试结果
六、用户使用说明（可选）
七、实验心得（可选）
异常处理太难了。
七、附录（可选）
#include
class car
{
public:
int lisence;
int arrive;
};
template
{
private:
int size;
int top;
Elem *listArray; public:
stopstack(int sz=0)
{
size=sz;
top=0;
listArray = new Elem[sz];
}
~stopstack(){ delete [] listArray; } void clear()
{
top = 0;
}
bool push(const Elem& item)
{
if (top == size) return false;
else
{
listArray[top++] = item;
return true;
}
}
bool pop(Elem& it)
{
if (top == 0)
return false;
else
{
it = listArray[--top];
return true;
}
}
bool topValue(Elem& it) const
{
if (top==0)
return false;
else
{ it = listArray[top-1];
return true;
}
}
int length() const
{
return top;
}
};
template
class stopqueue//队列的类
{
private:
Elem* Array;
int fence,maxsize;
public:
stopqueue(int sz)
{
maxsize=sz;
fence=0;
Array=new Elem[sz];
} //队列的构建
~stopqueue()
{
delete Array;
} //队列的销毁
void clear()
{
fence=0;
Array=new Elem[axsize];
} //队列的清空
bool enqueue(const Elem& it)
{
if(fence<(maxsize))
{
Array[fence]=it;
fence++;
return true;
}
else
return false;
} //入队
bool dequeue(Elem& it)
{
if(fence>0)
{
it=Array[0];
for(int i=1;i Array[i-1]=Array[i]; fence--; return true; } else return false; } //出队 bool backvalue(Elem&it) { if(fence>0) it=Array[fence-1]; return true; } int length() const { return fence; } }; void main() { stopstack stopqueue int a=0; while(1) { cout<<"请输入车辆到达或者离开:(A：到达 D:离开 E:输入结束)"<<'\n'; car c; char ch; cin>>ch>>c.lisence>>c.arrive; if(ch=='E') break; else if(ch=='A') { if(depot.length()<2) { car l; depot.topValue(l); if(c.arrive>l.arrive) { int num=a=depot.length(); while(num--) { depot.pop(l); temp.push(l); if(c.lisence==l.lisence) { cout<<"车牌重复。请重新输入."<<'\n'; break; } } while(a--) { temp.pop(l); depot.push(l); } if(num==-1) { depot.push(c); cout< } } else { cout<<"时间应比上一时间晚!请重新输入:"<<'\n'; continue; } } else { car l; q.backvalue(l); if(q.length()==2) { cout<<"停车场已满!"<<'\n'; continue; } if(c.arrive>l.arrive) { int num=a=depot.length(); while(num--) { depot.pop(l); temp.push(l); if(c.lisence==l.lisence) { cout<<"停车场已有该车。请重新输入."<<'\n'; break; } } while(a--) { car l; temp.pop(l); depot.push(l); } int n=a=q.length(); while(n--) { car h; q.dequeue(h); te.enqueue(h); if(h.lisence==c.lisence) { cout<<"便道已有该停车。请重新输入."<<'\n'; break; } } while(a--) { car h; te.dequeue(h); q.enqueue(h); } if((num==-1)&&(n==-1)) { q.enqueue(c); cout< } } else { cout<<"时间应比上一时间晚!请重新输入:"<<'\n'; continue; } } } else if(ch=='D') { car f,d; if(depot.length()==0) { depot.topValue(f); if(c.arrive>f.arrive) { while(1) { car k; depot.pop(k); if(c.lisence!=k.lisence) { temp.push(k); a++; } else { cout< } } while(a--) { car k; temp.pop(k); depot.push(k); } } else { cout<<"时间应比上一时间晚!请重新输入:"<<'\n'; continue; } } else if(q.length()>0) { q.backvalue(f); if(c.arrive>f.arrive) { q.dequeue(d); d.arrive=c.arrive; depot.push(d); cout< } else { cout<<"时间应比上一时间晚!请重新输入:"<<'\n'; continue; } } } } } #include using namespace std; class car { public: int lisence; int arrive; }; template class stopstack { private: int size; int top; Elem *listArray; public: stopstack(int sz=0) { size=sz; top=0; listArray = new Elem[sz]; } ~stopstack(){ delete [] listArray; } void clear() { top = 0; } bool push(const Elem& item) { if (top == size) return false; else { listArray[top++] = item; return true; } } bool pop(Elem& it) { if (top == 0) return false; else { it = listArray[--top]; return true; } } bool topValue(Elem& it) const { if (top==0) return false; else { it = listArray[top-1]; return true; } } int length() const { return top; } }; template class stopqueue//队列的类 { private: Elem* Array; int fence,maxsize; public: stopqueue(int sz) { maxsize=sz; fence=0; Array=new Elem[sz]; } //队列的构建 ~stopqueue() { delete Array; } //队列的销毁 void clear() { fence=0; Array=new Elem[axsize]; } //队列的清空 bool enqueue(const Elem& it) { if(fence<(maxsize)) { Array[fence]=it; fence++; return true; } else return false; } //入队 bool dequeue(Elem& it) { if(fence>0) { it=Array[0]; for(int i=1;i Array[i-1]=Array[i]; fence--; return true; } else return false; } //出队 bool backvalue(Elem&it) { if(fence>0) it=Array[fence-1]; return true; } int length() const { return fence; } }; void main() { stopstack stopqueue int a=0; while(1) { cout<<"请输入车辆到达或者离开:(A：到达 D:离开 E:输入结束)"<<'\n'; car c; char ch; cin>>ch>>c.lisence>>c.arrive; if(ch=='E') break; else if(ch=='A') { if(depot.length()<2) { car l; depot.topValue(l); if(c.arrive>l.arrive) { int num=a=depot.length(); while(num--) { depot.pop(l); temp.push(l); if(c.lisence==l.lisence) { cout<<"车牌重复。请重新输入."<<'\n'; break; } } while(a--) { temp.pop(l); depot.push(l); } if(num==-1) { depot.push(c); cout< } } else { cout<<"时间应比上一时间晚!请重新输入:"<<'\n'; continue; } } else { car l; q.backvalue(l); if(q.length()==2) { cout<<"停车场已满!"<<'\n'; continue; } if(c.arrive>l.arrive) { int num=a=depot.length(); while(num--) { depot.pop(l); temp.push(l); if(c.lisence==l.lisence) { cout<<"停车场已有该车。请重新输入."<<'\n'; break; } } while(a--) { car l; temp.pop(l); depot.push(l); } int n=a=q.length(); while(n--) { car h; q.dequeue(h); te.enqueue(h); if(h.lisence==c.lisence) { cout<<"便道已有该停车。请重新输入."<<'\n'; break; } } while(a--) { car h; te.dequeue(h); q.enqueue(h); } if((num==-1)&&(n==-1)) { q.enqueue(c); cout< } } else { cout<<"时间应比上一时间晚!请重新输入:"<<'\n'; continue; } } } else if(ch=='D') { car f,d; if(depot.length()==0) { depot.topValue(f); if(c.arrive>f.arrive) { while(1) { car k; depot.pop(k); if(c.lisence!=k.lisence) { temp.push(k); a++; } else { cout< } } while(a--) { car k; temp.pop(k); depot.push(k); } } else { cout<<"时间应比上一时间晚!请重新输入:"<<'\n'; continue; } } else if(q.length()>0) { q.backvalue(f); if(c.arrive>f.arrive) { q.dequeue(d); d.arrive=c.arrive; depot.push(d); cout< } else { cout<<"时间应比上一时间晚!请重新输入:"<<'\n'; continue; } } } } } #include using namespace std; class car { public: int lisence; int arrive; }; template class stopstack { private: int size; int top; Elem *listArray; public: stopstack(int sz=0) { size=sz; top=0; listArray = new Elem[sz]; } ~stopstack(){ delete [] listArray; } void clear() { top = 0; } bool push(const Elem& item) { if (top == size) return false; else { listArray[top++] = item; return true; } } bool pop(Elem& it) { if (top == 0) return false; else { it = listArray[--top]; return true; } } bool topValue(Elem& it) const { if (top==0) return false; else { it = listArray[top-1]; return true; } } int length() const { return top; } }; template class stopqueue//队列的类 { private: Elem* Array; int fence,maxsize; public: stopqueue(int sz) { maxsize=sz; fence=0; Array=new Elem[sz]; 数据结构实验报告 ——实验三停车场模拟管理程序的设计与实现 本实验的目的是进一步理解线性表的逻辑结构和存储结构，进一步提高使用理论知识指导解决实际问题的能力。 一、【问题描述】 设停车场只有一个可停放几辆汽车的狭长通道，且只有一个大门可供汽车进出。汽车在停车场内按车辆到达的先后顺序依次排列，若车场内已停满几辆汽车，则后来的汽车只能在门外的便道上等候，一旦停车场内有车开走，则排在便道上的第一辆车即可进入；当停车场内某辆车要离开时，由于停车场是狭长的通道，在它之后开入的车辆必须先退出车场为它让路，待该车辆开出大门，为它让路的车辆再按原次序进入车场。在这里假设汽车不能从便道上开走，试设计这样一个停车场模拟管理程序。为了以下描述的方便，停车场的停车场用“停车位”进行叙述，停车场的便道用“便道”进行叙述。 二、【数据结构设计】 1、为了便于区分每辆汽车并了解每辆车当前所处的位置，需要记录汽车的牌照号码和汽车的当前状态，所以为汽车定义一个新的类型CAR，具体定义如下： typedef struct { char *license //汽车牌照号码，定义为一个字符指针类型 char state; //汽车当前状态，字符s表示停放在停车位上，//字符p表示停放在便道上，每辆车的初始状态用字符i来进行表示 } 2、①由于车位是一个狭长的通道，所以不允许两辆车同时出入停车位，当有车到来要进入停车位的时候也要顺次停放，当某辆车要离开时，比它后到的车要先暂时离开停车位，而且越后到的车就越先离开停车位，显然这和栈的“后进先出”特点相吻合，所以可以使用一个栈来描述停车位。 由于停车位只能停放有限的几辆车，而且为了便于停车场的管理，为每个车位要分配一个固定的编号，不妨设为1、2、3、4、5（可利用数组的下标），分别表示停车位的1车位、2车位、3车位、4车位。5车位，针对这种情况使用一个顺序栈比较方便。 ②当某辆车要离开停车场的时候，比它后进停车位的车要为它让路，而且当它开走之后让路的车还要按照原来的停放次序再次进入停车位的某个车位上，为了完成这项功能，再定义一个辅助栈，停车位中让路的车依次“压入”辅助栈，待提出开走请求的车开走后再从辅助栈的栈顶依次“弹出”到停车位中。对辅助栈也采用顺序栈。 课程设计:停车场 c语言版本的数据结构课程设计,要求用栈模拟停车场,用队列模拟便道,实现停车场的收费管理系统 停车场停满车后车会停在便道上面 下面附上源码,vc:(下编译 #include #define Esc 27 //退出系统 #define Exit 3 //结束对话 #define Stop 1 //停车 #define Drive 2 //取车 int jx=0,jy=32; //全局变量日志打印位置 typedef struct {int hour; int minute; }Time,*PTime; /*时间结点*/ typedef struct /*定义栈元素的类型即车辆信息结点*/ {int num ; /*车牌号*/ Time arrtime; /*到达时刻或离区时刻*/ }CarNode; typedef struct /*定义栈,模拟停车场*/ {CarNode stack[MaxSize]; int top; }SqStackCar; typedef struct node /*定义队列结点的类型*/ {int num; /*车牌号*/ struct node *next; }QueueNode; typedef struct /*定义队列,模拟便道*/ {QueueNode *front,*rear; }LinkQueueCar; /*函数声明*/ PTime get_time(); CarNode getcarInfo(); void qingping(int a); void gotoxy(int x,int y); void printlog(Time t,int n,int io,char ab,int po,double f); void printstop(int a,int num,int x0,int y0); void printleave(int a,int po,int num); /*初始化栈*/ void InitSeqStack(SqStackCar *s) { s->top=-1; } /* push入站函数*/ int push(SqStackCar *s,CarNode x) //数据元素x入指针s所指的栈{ if(s->top==MaxSize-1) return(0); //如果栈满,返回0 else 实验二停车场管理 班级：A0712 学号：12 姓名：冷清淼成绩：__________ 指导教师签名：__________ 一、问题描述 设停车场是一个可停放n辆车的狭长通道，且只有一个大门可供汽车进出。在停车场内，汽车按到达的先后次序，由北向南依次排列（假设大门在最南端）。若停车场内已停满n辆车，则后来的汽车需在门外的便道上等候，当有车开走时，便道上的第一辆车即可开入。当停车场内某辆车要离开时，在它之后进入的车辆必须先退出停车场为它让路，待该辆车开出大门后，其他车辆再按原次序返回车场。每辆车离开停车场时，应按其停留时间的长短交费（在便道上停留的时间不收费）。 设计要求： 1．模拟上述管理过程。要求以顺序栈模拟停车场，以链队列模拟便道。 2．从终端读入汽车到达或离去的数据，每组数据包括三项： （1）是“到达”还是“离开”； （2）汽车牌照号码； （3）“到达”或“离开”的时刻。 3．与每组输入信息相应的输出信息为：如果是到达的车辆，则输出其在停车场中或便道上的位置；如果是离去的车辆，则输出其在停车场中停留的时间和应交的费用。 二、算法说明 1．数据结构说明 （1）用到两个堆栈：一个为车场栈；另一个为临时栈temp typedef struct NODE{ CarNode *stack[MAX+1]; int top; }SeqStackCar; /*模拟车场*/ （2）一个队列结构，存储便道车辆信息： typedef struct Node{ QueueNode *head; QueueNode *rear; }LinkQueueCar; /*模拟便道*/ 2．算法说明 (1) 功能模块说明：停车场管理系统含有三个模块，即：车辆到达、离开、列表显示 停车场系统车辆到达 车辆离开列表显示 3 2 1 图1 （2）以模块为单位分析算法 1、“到达”模块：到达时有两种情况，即车场是否满，未满则直接进入停车场；满时，到便道等待。如图2。 车辆到达 停车场是否满 结束 进入停车场 进入便道 是 否 图2 习题5参考答案 5.1 选择 （1）C（2）B（3）C（4）B（5）C（6）D（7）C（8）C（9）B（10）C （11）B（12）C（13）C（14）C（15）C（16）B 5.2 填空 （1）1 （2）1036；1040 （3）2i （4） 1 ； n ; n-1 ; 2 （5）2k-1；2k-1 （6）ACDBGJKIHFE （7）p->lchild==NULLL （8）Huffman树 （9）其第一个孩子; 下一个兄弟 （10）先序遍历；中序遍历 5.3 叶子结点:C、F、G、L、I、M、K； 非终端结点：A、B、D、E、J； 各结点的度： 结点： A B C D E F G L I J K M 度： 4 3 0 1 2 0 0 0 0 1 0 0 树深：4 5.4 无序树形态如下： 二叉树形态如下： 5.5 二叉链表如下: 三叉链表如下: 5.6 先序遍历序列:ABDEHICFJG 中序遍历序列:DBHEIAFJCG 后序遍历序列:DHIEBJFGCA 5.7 (1) 先序序列和中序序列相同：空树或缺左子树的单支树； (2) 后序序列和中序序列相同：空树或缺右子树的单支树； (3) 先序序列和后序序列相同：空树或只有根结点的二叉树。 5.8 这棵二叉树为: 5.9 先根遍历序列:ABFGLCDIEJMK 后根遍历序列:FGLBCIDMJKEA 层次遍历序列:ABCDEFGLIJKM 5.10 证明：设树中结点总数为n，叶子结点数为n0，则 n=n0 + n1 + …… + n m （1） 再设树中分支数目为B，则 B=n1 + 2n2 + 3n3+ …… + m n m （2） 因为除根结点外，每个结点均对应一个进入它的分支，所以有 n= B + 1 （3） 将（1）和（2）代入（3），得 n0 + n1 + …… + n m = n1 + 2n2 + 3n3+ …… + m n m + 1 从而可得叶子结点数为： n0 = n2 + 2n3+ …… + (m-1)n m + 1 5.11 由5.10结论得，n0 = (k-1)n k + 1 又由 n=n0 + n k，得n k= n-n0，代入上式，得 n0 = (k-1)（n-n0）+ 1 叶子结点数为：n0 = n (k-1) / k 停车场管理系统 1题目要求 设有一个可以停放n 辆汽车的狭长停车场,它只有一个大门可以供车辆进出。车辆按到达停车场时间的早晚依次从停车场最里面向大门口处停放（最先到达的第一辆车放在停车场的最里面）。如果停车场已放满n 辆车,则后来的车辆只能在停车场大门外的便道上等待,一旦停车场内有车开走,则排在便道上的第一辆车就进入停车站。停车站内如有某辆车要开走,在它之后进入停车场的车都必须先退出停车站为它让路,待其开出停车场后,这些车辆再依原来的次序进场。每辆车在离开停车场时,都应根据它在停车场内停留的时间长短交费。如果停留在便道上的车未进停车场就要离去,允许其离去,不收停车费,并且仍然保持在便道上等待的车辆的次序。编制一程序模拟该停车场的管理。 【基本要求】要求程序输出每辆车到达后的停车位置（停车场或便道上）,以及某辆车离开停车场是的停车时间及它应该交的费用。 2需求分析 根据题目要求,因为停车场是一个单条的序列,可以用结构体实现；在程序中,需要知道每辆来车的具体停放位置,应提供提示、查找、标记工作。车辆离开要计时计费。另外,每天开始时,停车场要初始化。 3总体设计 这个系统可以分为：初始化、有车进入、有车离开、退出四个模块。 4详细设计 main()函数体内包含了界面选则部分menu(),并单独 抽出来作为一个独立函数,目的在于系统执行每部分 模块后能够方便返回到系统界面。即main()函数写为 如下： void main()/*主函数*/ { menu();/*菜单函数*/ } 菜单函数： void menu() { int n,w; do { puts("\t\t**************MENU**************\n\n"); puts("\t\t\t 1.初始化"); puts("\t\t\t 2.有车进入"); puts("\t\t\t 3.有车离开"); puts("\t\t\t 4.退出"); puts("\n\n\t\t*********************************\n"); printf("Please choice your number(1-4): [ ]\b\b"); scanf("%d",&n); if(n<1||n>4) /*对选择的数字作判断*/ { w=1; getchar(); } else w=0; }while(w==1); switch(n) { case 1:chushi();break; /*初始化函数*/ case 2:jinru();break; /*车辆进入函数*/ 附录习题参考答案 习题1参考答案 1.1.选择题 (1). A. (2). A. (3). A. (4). B.,C. (5). A. (6). A. (7). C. (8). A. (9). B. (10.) A. 1.2.填空题 (1). 数据关系 (2). 逻辑结构物理结构 (3). 线性数据结构树型结构图结构 (4). 顺序存储链式存储索引存储散列表（Hash）存储 (5). 变量的取值范围操作的类别 (6). 数据元素间的逻辑关系数据元素存储方式或者数据元素的物理关系 (7). 关系网状结构树结构 (8). 空间复杂度和时间复杂度 (9). 空间时间 (10). Ο(n) 1.3 名词解释如下： 数据：数据是信息的载体，是计算机程序加工和处理的对象，包括数值数据和非数值数据。数据项：数据项指不可分割的、具有独立意义的最小数据单位，数据项有时也称为字段或域。数据元素：数据元素是数据的基本单位，在计算机程序中通常作为一个整体进行考虑和处理，一个数据元素可由若干个数据项组成。 数据逻辑结构：数据的逻辑结构就是指数据元素间的关系。 数据存储结构：数据的物理结构表示数据元素的存储方式或者数据元素的物理关系。 数据类型：是指变量的取值范围和所能够进行的操作的总和。 算法：是对特定问题求解步骤的一种描述，是指令的有限序列。 1.4 语句的时间复杂度为： (1) Ο(n2) (2) Ο(n2) (3) Ο(n2) (4) Ο(n-1) (5) Ο(n3) 1.5 参考程序： main() { int X,Y,Z； scanf(“%d, %d, %d”,&X,&Y,Z)； if (X>=Y) if(X>=Z) if (Y>=Z) { printf(“%d, %d, %d”,X,Y,Z);} else { printf(“%d, %d, %d”,X,Z,Y);} 数据结构实验报告 实验题目：停车场管理 学生姓名： 班级： 学号： 问题描述 设有一个停车场，它是利用一个南北向的狭窄通道建成，北端封闭，大门在最南端。最先到达的汽车停放在最北端，后面到达的汽车从北至南依次顺序停放。停车场只能停放n 辆汽车。当停车场停满n辆车后，后面到达的汽车只能在门外的便道上等候。一旦有汽车开走，便道上等候的第一辆车就可以开入停车场停放。当停车场内某辆汽车要离开时，在它之后进入的车辆必须先退出停车场为它让路，待该车开出大门外，其他汽车再按原次序返回车场。每辆停放在车场内的汽车在离开时必须按它停放时间的长短交纳费用。 例题分析 每到达一辆汽车，先检查停车场栈是否已满，若未满则该车进入停车场停放（入栈操作），并将该车的车号和停放时刻记录在停车场栈的相应元素中，同时显示该车在停车场内的停放位置。反之，若停车场已满，则该车排到便道上等候的汽车队列最后（入队列操作），并将该车的车号信息记录在汽车队列的相应结点内，同时显示该车在便道上的停放位置。 若要取一辆汽车，则需依次进行下述操作：将阻挡在它后面的汽车退出（停车场栈的出栈操作），并将这些汽车临时存放在另一个辅助栈中（辅助栈的入栈操作）；开走要取的汽车（停车场栈的出栈操作），并显示该车应交纳的费用；依次从辅助栈中开出汽车（辅助栈出栈操作），开回停车场中（停车场栈的入栈操作）；这时停车场已有一个空车位，便道上等候的第一辆汽车则可以开进停车场内停放（汽车队列的出队列操作和停车场栈的入栈操作）。 程序源代码 #include 停车场管理一 一.要求： 1.设计一个停车场用长度为N的堆栈来模拟。由于停车场内如有某辆车要开走，在它之后进来的车都必须先退出为它让道，待其开出停车场后，这些车再依原来的顺序进入。 2.程序输出每辆车到达后的停车位置，以及某辆车离开停车场时应交纳的费用和它在停车场内停留的时间。 二、程序中所采用的数据结构及存储结构的说明 以栈模拟停车场，以队列模拟车场外的便道，按照从终端读入的输入数据序列进行模拟管理。栈以顺序结构实现，队列以链表实现。 程序中分别采用了“栈”和“队列”作为其存储结构。 “栈”的定义可知，每一次入栈的元素都在原栈顶元素之上成为新的元素，每一次出栈的元素总是当前栈顶元素使次栈元素成为新的栈顶元素，即最后进栈者先出栈。程序中采用的结构是： typedef struct NODE{ CarNode *stack[MAX+1]; int top; }SeqStackCar; /*模拟车库*/ “队列”是限定所有插入操作只能在表的一端进行，而所有的删除操作都只能在表的另一端进行。插入端叫队尾，删除端叫对头。按先进先出规则进行。程序中采用的结构是：typedef struct Node{ QueueNode *head; QueueNode *rear; }LinkQueueCar; /*模拟通道*/ 三、算法的设计思想 由于停车场是一个狭窄通道，而且只有一个大门可供汽车进出，问题要求汽车停车 场内按车辆到达时间的先后顺序，依次由北向南排列。由此很容易联想到数据结构中的堆栈模型，因此可首先设计一个堆栈，以堆栈来模拟停车场，又每个汽车的车牌号都不一样，这样一来可以根据车牌号准确找到汽车位置，所以堆栈里的数据元素我设计成汽车的车牌号。当停车场内某辆车要离开时，在他之后进入的车辆必须先退出车场为它让路，待该辆车开出大门外，其他车辆再按原次序进入停车场。这是个一退一进的过程，而且让道的汽车必须保持原有的先后顺序，因此可再设计一个堆栈，以之来暂时存放为出站汽车暂时让道的汽车车牌号。当停车场满后，继续进来的汽车需要停放在停车场旁边的便道上等候，若停车场有汽车开走，则按排队的先后顺序依次进站，最先进入便道的汽车将会最先进入停车场，这完全是一个先进先出模型，因此可设计一个队列来模拟便道，队列中的数据元素仍然设计成汽车的车牌号。另外，停车场根据汽车在停车场内停放的总时长来收费的，在便道上的时间不计费，因此必须记录车辆进入停车场时的时间，车辆离开停车场时的时间不需要记录，当从终端输入时可直接使用。由于时间不象汽车一样需要让道，我设计了一个顺序表来存放时间。又用顺序表用派生法设计了一个堆栈，恰好满足上面模拟停车场的需要。 四.设计原理、框图 数据结构（C语言版）（第2版） 课后习题答案 李冬梅 目录 第1章绪论............................................. 错误!未定义书签。第2章线性表........................................... 错误!未定义书签。第3章栈和队列......................................... 错误!未定义书签。第4章串、数组和广义表................................. 错误!未定义书签。第5章树和二叉树....................................... 错误!未定义书签。第6章图................................................ 错误!未定义书签。第7章查找............................................. 错误!未定义书签。第8章排序............................................. 错误!未定义书签。 第1章绪论 1．简述下列概念：数据、数据元素、数据项、数据对象、数据结构、逻辑结构、存储结构、抽象数据类型。 答案： 数据：是客观事物的符号表示，指所有能输入到计算机中并被计算机程序处理的符号的总称。如数学计算中用到的整数和实数，文本编辑所用到的字符串，多媒体程序处理的图形、图像、声音、动画等通过特殊编码定义后的数据。 数据元素：是数据的基本单位，在计算机中通常作为一个整体进行考虑和处理。在有些情况下，数据元素也称为元素、结点、记录等。数据元素用于完整地描述一个对象，如一个学生记录，树中棋盘的一个格局（状态）、图中的一个顶点等。 数据项：是组成数据元素的、有独立含义的、不可分割的最小单位。例如，学生基本信息表中的学号、姓名、性别等都是数据项。 数据对象：是性质相同的数据元素的集合，是数据的一个子集。例如：整数数据对象是集合N={0，±1，±2，…}，字母字符数据对象是集合C={‘A’，‘B’，…，‘Z’，‘a’，‘b’，…，‘z’}，学生基本信息表也可是一个数据对象。 数据结构：是相互之间存在一种或多种特定关系的数据元素的集合。换句话说，数据结构是带“结构”的数据元素的集合，“结构”就是指数据元素之间存在的关系。 逻辑结构：从逻辑关系上描述数据，它与数据的存储无关，是独立于计算机的。因此，数据的逻辑结构可以看作是从具体问题抽象出来的数学模型。 存储结构：数据对象在计算机中的存储表示，也称为物理结构。 抽象数据类型：由用户定义的，表示应用问题的数学模型，以及定义在这个模型上的一组操作的总称。具体包括三部分：数据对象、数据对象上关系的集合和对数据对象的基本操作的集合。 2．试举一个数据结构的例子，叙述其逻辑结构和存储结构两方面的含义和相互关系。 答案： 例如有一张学生基本信息表，包括学生的学号、姓名、性别、籍贯、专业等。每个学生基本信息记录对应一个数据元素，学生记录按顺序号排列，形成了学生基本信息记录的线性序列。对于整个表来说，只有一个开始结点(它的前面无记录)和一个终端结点(它的后面无记录)，其他的结点则各有一个也只有一个直接前趋和直接后继。学生记录之间的这种关系就确定了学生表的逻辑结构，即线性结构。 这些学生记录在计算机中的存储表示就是存储结构。如果用连续的存储单元(如用数组表示)来存放这些记录，则称为顺序存储结构；如果存储单元不连续，而是随机存放各个记录，然后用指针进行链接，则称为链式存储结构。 即相同的逻辑结构，可以对应不同的存储结构。 3．简述逻辑结构的四种基本关系并画出它们的关系图。 课程设计报告 课程名称数据结构课程设计 课题名称停车场管理系统 专业信息管理与信息系统 班级 09级1班 学号 200903110112 姓名洪俊斌 指导教师赵锦元、李峰、罗敬 2011年 1 月 9 日 湖南工程学院 课程设计任务书 课程名称数据结构 课题停车场管理系统 专业班级信息管理0901班 学生姓名洪俊斌 学号200903110112 指导老师赵锦元、李峰、罗敬 审批 任务书下达日期2011 年1 月 3 日任务完成日期2011 年1 月20 日 一、设计内容与设计要求 1．设计内容： [问题描述] 设停车场只是一个可停放几辆汽车的狭长通道，且只有一个大门可供汽车进出，还有一个等停的的狭长通道。汽车在停车场内按车辆的先后顺序依次排列，若车站内已停满汽车，则后来的汽车只能在门外的通道上等停，一旦停车场内有车开走，则排在通道上的第一辆车即可进入；当停车场内某辆车要离开时，由于停车场是狭长的通道，在它之后开入的车辆必须先退出车站为它让路，待该车辆开出大门，为它让路的车辆再按原来次序进入车场。在这里假设汽车不能从便道上开走，试设计这样一个停车场模拟管理程序。 [基本功能] （1）车辆成批入站。 当一个停车场刚开始投入运行的时候，会有很多车进来，因此，要设计一个函数来实现车辆批量进站。并要检测车辆的数目是否超过规定的最大容量，给出相关提示信息。 （2）单个车辆入站。 当系统正常投入运行后，会有零散的车辆进进出出，因此，设计一个函数实现单个车辆入站。 （3）车站内信息实时显示。 车站内信息包括两个部分：停车场内停放的车辆以及在外面通道上等停的车辆。 （4）车辆出站。 当停车场内车辆出站后，检查通道上是否有车等停，如果有，则要把排在最前面的车调入停车场内。 数据结构C语言版第2版课后习题答案 本页仅作为文档封面，使用时可以删除 This document is for reference only-rar21year.March 数据结构（C语言版）（第2版） 课后习题答案 李冬梅 目录 第1章绪论 ............................................................................ 错误!未定义书签。第2章线性表......................................................................... 错误!未定义书签。第3章栈和队列 ..................................................................... 错误!未定义书签。第4章串、数组和广义表 ........................................................ 错误!未定义书签。第5章树和二叉树 .................................................................. 错误!未定义书签。第6章图 ................................................................................ 错误!未定义书签。第7章查找 ............................................................................ 错误!未定义书签。第8章排序 ............................................................................ 错误!未定义书签。 I 2015-2016学年第二学期《高级语言程序设计》 课程设计报告 题目：停车场管理系统 专业：计算机科学与技术 班级：15级计科<1>班 ：胡玉玉 指导教师：广宏 成绩： 计算机学院 2016 年 4月 25 日 目录 1. 设计容及要求 (1) 1.1 课程设计容 (1) 1.2 课程设计的要求 (2) 2概要设计 (3) 2.1 设计思路 (3) 2.2 程序基本框架结构图 (4) 3设计过程或程序代码 (5) 3.1 主要程序代码及解释 (5) 4设计结果与分析 (13) 4.1 程序运行结果截图与分析 (13) 5参考文献 (16) 1.设计容及要求 1.1 课程设计容 ①通过本次课程设计，强化上级动手能力，在理论和实践的基础 上巩固《C语言程序设计》课程的学习容。掌握软件设计的基本方法。 ②熟悉C语言的基本容从而掌握C语言的基本知识以及了解C语 言的基本编写及运行。 ③了解程序的分模块编写并对程序的每个模块进行详细的设计并 且能理解一般C语言编写的程序。 ④掌握书写程序设计说明文档的能力。 ⑤熟悉C程序设计的开发环境及C程序的调试过程 1.2 课程设计的要求 ①分析课程设计题目的要求。 ②写出详细设计说明。 ③编写程序代码，调试程序使其能正确运行。 ④设计完成的软件要便于操作和使用。 ⑤设计完成后提交课程设计报告。 2.概要设计 2.1设计思路 停车场是一个可停放n辆汽车的狭长通道，并只有一个大门可供汽车进出，汽车在停车场按车辆到达的先后顺序，依次由北向南排列（大门在最南端，最先到达的第一辆车停放在车场的最北端），如车长已停满n辆汽车，则后来的汽车只能在门外的便道上等候，一旦有车开走，则排在便道上的第一辆车即可开入；当停车场某辆车要离开时，在它后进入的车辆必须先退出车场为它让路，待该辆车开出大门外，其它车辆再按原次序进入车场，每辆停放在车场的车在它离开停车场时必须按它停留的时间长短交纳费用，以栈模拟停车场，以队列模拟车场外的便道，按照从终端读入的输入数据序列进行模拟管理．每一组输入数据包括三个数据项：汽车”到达”或”离去” 信息，汽车牌照以及到达或离去的时刻（到达或离去的时刻也可用计算机控制）．对每一组输入数据进行操作后的输入信息为：如是车辆到达，则输入汽车在停车场。 2.2程序基本框架结构图 不管怎样，生活还是要继续向前走去。有的时候伤害和失败不见得是一件坏事，它会让你变得更好，孤单和失落亦是如此。每件事到最后一定会变成一件好事，只要你能够走到最后。附录习题参考答案 习题1参考答案 1.1.选择题 (1). A. (2). A. (3). A. (4). B. C. (5). A. (6). A. (7). C. (8). A. (9). B. (10.) A. 1.2.填空题 (1). 数据关系 (2). 逻辑结构物理结构 (3). 线性数据结构树型结构图结构 (4). 顺序存储链式存储索引存储散列表（Hash）存储 (5). 变量的取值范围操作的类别 (6). 数据元素间的逻辑关系数据元素存储方式或者数据元素的物理关系 (7). 关系网状结构树结构 (8). 空间复杂度和时间复杂度 (9). 空间时间 (10). Ο(n) 1.3 名词解释如下： 数据：数据是信息的载体 是计算机程序加工和处理的对象 包括数值数据和非数值数据 数据项：数据项指不可分割的、具有独立意义的最小数据单位 数据项有时也称为字段或域 数据元素：数据元素是数据的基本单位 在计算机程序中通常作为一个整体进行考虑和处理 一个数据元素可由若干个数据项组成 数据逻辑结构：数据的逻辑结构就是指数据元素间的关系 数据存储结构：数据的物理结构表示数据元素的存储方式或者数据元素的物理关系 数据类型：是指变量的取值范围和所能够进行的操作的总和 算法：是对特定问题求解步骤的一种描述 是指令的有限序列 1.4 语句的时间复杂度为： (1) Ο(n2) (2) Ο(n2) (3) Ο(n2) (4) Ο(n-1) 附件二【学生用】 西北农林科技大学信息工程学院 数据结构实习报告 题目：停车场管理系统 学号2011013200 姓名阮屹 专业班级电子商务111 指导教师戴涛、杨会君 实践日期2012-7-6至2012-7-15 目录 一、综合训练目的与要求 (1) 二、综合训练任务 (1) 三、总体设计 (1) 四、详细设计说明 (1) 五、调试与测试 (7) 六、实习日志 (13) 七、实习总结 (13) 八、附录：核心代码清单 (14) 一、综合训练目的与要求 正文 综合训练的目的 本综合训练是计算机科学与技术、信息管理与信息系统、软件工程专业重要的实践性环节之一，是在学生学习完《程序设计语言(C)》、《数据结构》课程后进行的一次全面的综合练习。本课综合训练的目的和任务： 1. 巩固和加深学生对C语言、数据结构课程的基本知识的理解和掌握 2. 掌握C语言编程和程序调试的基本技能 3. 利用C语言进行基本的软件设计 4. 掌握书写程序设计说明文档的能力 5. 提高运用C语言、数据结构解决实际问题的能力 综合训练要求 1. 分析综合训练题目的要求 2. 写出详细设计说明 3. 编写程序代码，调试程序使其能正确运行 4. 设计完成的软件要便于操作和使用 4. 设计完成后提交课程设计报告 二、综合训练任务 通过此系统可以实现如下功能： 若是车辆到达，则输入汽车在停车场内或便道上的停车位置以及进站时间，当车子出站时，则显示在停车场内停车时间，并；应当支付的金额 要求：设计合理的存储结构，设计界面，设计程序完成功能； 三、总体设计 该程序是模拟了一个特殊车站，车站是一条直线，只有一个入口，车子要出站则他前边的车子都要为其让路，然后再回来并且覆盖出站车子原来的位置，这明显是一个要用到栈的环境。而当车站满了之后，便在一旁的便道里排队等待，先排队的当然先进车站。这是原题，我做了些许改动，设计了会员系统，会员享受9折优惠并且有会员专用便道，在车站满的情况下优先进入车站。 四、详细设计说明 整体设计如上，那么现在详细分析程序。这个程序每辆车实际在内存中保存了两次，一个是在主函数中的Car c的结构体数组中，一个在栈或队列中，而不是只用栈来储存，这样方便后来的车辆的查找和程序的管理，当然这样也相对好编写程序，思路相对清晰。这也是我本身对数据结构不熟练的结果。程序中用到的结构体： 实习报告 题目：停车场管理姓名：袁韬博学号：16030120021完成日期：2017.10.23 一、需求分析 1.本题目要求建立一个可指定长度的栈，和长度可变化的队列，以当作停车场和便道 的车的存放。 2.本题目要求在停车场的车离开时，便道的车按照先后顺序进入一辆，并开始于此时 记录时间。 3.在本题目之中在便道的停车不计费用，在此题中应判断在停车场还是在便道的信息。 4.本题目要求根据数据的第一位数据判断进入还是离开，根据要求输出信息。 5.程序执行命令为：1.存入车辆时输出停车信息2.车辆离开时输出停车时间和应缴纳 费用 3.输入‘E’时表示结束。 6.测试数据： n=2，m(每小时停车费用)=3，（A,1,5）(A,2,10)(D,1,15)(A,3,20)(A,4,25)(A,5,30) (D,2,35)(D,4,40)(E,0,0)其中A表示为Arrival（到达），D表示为Departure（离 开），E表示为End（结束）。 二、概要设计 1.设定栈的抽象数据类型定义 数据对象：D={a i|a i∈SStop，i=1,2,3,······,n} 数据关系：R={|a i∈D,i=1,2,3,······,n } 基本操作： initStack(&S，d) 操作结果：建立一个长度为d的空栈 Push(&S, &e, &d) 初始条件：栈已存在，长度为d 操作结果：如栈已满返回false，否则将e，压入栈中，返回true Pop(&S,e) 初始条件：栈已存在 操作结果：如栈为空返回false，否则弹栈入e，返回true 2.设定队列的抽象数据类型定义 数据对象：D={a i|a i∈SStop，i=1,2,3,······,n} 数据关系：R={|a i∈D,i=1,2,3,······,n } *SQTypeInit() 操作结果：建立一个空队列 InSQType(*q, &data) 初始条件：队列已存在 操作结果：将data压入队列之中 *OutSQType( *q) 初始条件：队列已存在 操作结果：弹出队列，返回其指针。 3.程序包含6个模块 1）主程序模块：包含栈与队列的对象建立，输入值的判断以及函数的实现 2）栈模块：实现停车场抽象数据类型 3）队列模块：实现便道抽象数据类型 第1章绪论 5．选择题：CCBDCA 6．试分析下面各程序段的时间复杂度。 （1）O（1） （2）O（m*n） （3）O（n2） （4）O（log3n） （5）因为x++共执行了n-1+n-2+……＋1= n(n-1)/2，所以执行时间为O（n2） （6）O(n) 第2章线性表 1．选择题 babadbcabdcddac 2．算法设计题 （6）设计一个算法，通过一趟遍历在单链表中确定值最大的结点。 ElemType Max (LinkList L ){ if(L->next==NULL) return NULL; pmax=L->next; //假定第一个结点中数据具有最大值 p=L->next->next; while(p != NULL ){//如果下一个结点存在 if(p->data > pmax->data) pmax=p; p=p->next; } return pmax->data; （7）设计一个算法，通过遍历一趟，将链表中所有结点的链接方向逆转，仍利用原表的存储空间。 void inverse(LinkList &L) { // 逆置带头结点的单链表 L p=L->next; L->next=NULL; while ( p) { q=p->next; // q指向*p的后继 p->next=L->next; L->next=p; // *p插入在头结点之后 p = q; } } （10）已知长度为n的线性表A采用顺序存储结构，请写一时间复杂度为O(n)、空间复杂度为O(1)的算法，该算法删除线性表中所有值为item的数据元素。 [题目分析] 在顺序存储的线性表上删除元素，通常要涉及到一系列元素的移动（删第i个元素，第i+1至第n个元素要依次前移）。本题要求删除线性表中所有值为item的数据元素，并未要求元素间的相对位置不变。因此可以考虑设头尾两个指针（i=1，j=n），从两端向中间移动，凡遇到值item的数据元素时，直接将右端元素左移至值为item的数据元素位置。 void Delete（ElemType A[ ]，int n） ∥A是有n个元素的一维数组，本算法删除A中所有值为item的元素。 {i=1；j=n；∥设置数组低、高端指针（下标）。 while（i 《计算机软件技术基础》实验报告I—数据结构 实验二：停车场管理问题 一、问题描述 1.实验题目： 设停车场是一个可停放 n 辆汽车的狭长通道，且只有一个大门可供汽车进出。汽车在停车场内按车辆到达时间的先后顺序，依次由北向南排列（大门在最南端，最先到达的第一辆车停放在车场的最北端）。若停车场内已经停满 n辆车，那么后来的车只能在门外的便道上等候。一旦有车开走，则排在便道上的第一辆车即可开入。当停车场内某辆车要离开时，在它之后进入的车辆必须先退出车场为它让路，待该辆车开出大门外，其他车辆再按原次序进入车场。每辆停放在车场的车在它离开停车场时必须按它停留的时间长短缴纳费用。试为停车场编制按上述要求进行管理的模拟程序。 2．基本要求： 以栈模拟停车场，以队列模拟车场外的便道，按照从终端读入数据的序列进行模拟管理。每一组输入数据包括三个数据项：汽车的“到达”（‘A’表示）或“离去”（‘D’表示）信息、汽车标识（牌照号）以及到达或离去的时刻。对每一组输入数据进行操作后的输出信息为：若是车辆到达，则输出汽车在停车场内或者便道上的停车位置；若是车辆离去，则输出汽车在停车场停留的时间和应缴纳的费用（便道上停留的时间不收费）。栈以顺序结构实现，队列以链表结构实现。 3．测试数据： 设n=2,输入数据为：（‘A’，1，5），（‘A’，2，10），（‘D’，1，15），（‘A’，3， 20），（‘A’，4，25），（‘A’，5，30），（‘D’，2，35），（‘D’，4，40），（‘E’，0，0）。每一组输入数据包括三个数据项：汽车“到达”或“离去”信息、汽车牌照号码及到达或离去的时刻，其中，‘A’表示到达；‘D’表示离去，‘E’表示输入结束。其中：（‘A’，1，5）表示1号牌照车在5这个时刻到达，而（‘D’，1，15）表示1号牌照车在15这个时刻离去。 二、需求分析 停车场管理系统c 语言 - 第二学期 《高级语言程序设计》 课程设计报告 题目：停车场管理系统 专业：计算机科学与技术班级：15级计科<1>班 姓名：胡玉玉 指导教师：陈广宏 成绩： 计算机学院 年 4月 25 日 目录 1. 设计内容及要求 (1) 1.1 课程设计内容 (1) 1.2 课程设计的要求 (2) 2 概要设计 (3) 2.1 设计思路 (3) 2.2 程序基本框架结构图 (4) 3 设计过程或程序代码 (5) 3.1 主要程序代码及解释 (5) 4 设计结果与分析 (13) 4.1 程序运行结果截图与分析 (13) 5参考文献 (16) 1.设计内容及要求 1.1 课程设计内容 ①经过本次课程设计，强化上级动手能力，在理论和实践的基 础上巩固《C语言程序设计》课程的学习内容。掌握软件设计的基本方法。 ②熟悉C语言的基本内容从而掌握C语言的基本知识以及了解 C语言的基本编写及运行。 ③了解程序的分模块编写并对程序的每个模块进行详细的设计 而且能理解一般C语言编写的程序。 ④掌握书写程序设计说明文档的能力。 ⑤熟悉C程序设计的开发环境及C程序的调试过程 1.2 课程设计的要求 ①分析课程设计题目的要求。 ②写出详细设计说明。 ③编写程序代码，调试程序使其能正确运行。 ④设计完成的软件要便于操作和使用。 ⑤设计完成后提交课程设计报告。 2.概要设计 2.1设计思路 停车场是一个可停放n辆汽车的狭长通道，并只有一个大门可供汽车进出，汽车在停车场内按车辆到达的先后顺序，依次由北向南排列（大门在最南端，最先到达的第一辆车停放在车场的最北端），如车长内已停满n辆汽车，则后来的汽车只能在门外的便道上等候，一旦有车开走，则排在便道上的第一辆车即可开入； 当停车场内某辆车要离开时，在它后进入的车辆必须先退出车场为它让路，待该辆车开出大门外，其它车辆再按原次序进入车场，每辆停放在车场的车在它离开停车场时必须按它停留的时间长短交纳费用，以栈模拟停车场，以队列模拟车场外的便道，按照从终端读入的输入数据序列进行模拟管理．每一组输入数据包括三个数据项：汽车”到达”或”离去”信息，汽车牌照号码以及到达或离去的时刻（到达或离去的时刻也可用计算机控制）．对每一组输入数据进行操作后的输入信息为：如是车辆到达，则输入汽车在停车场。 2.2程序基本框架结构图停车场数据结构实验报告附代码
数据结构c语言版课程设计停车场管理系统汇编
数据结构课程设计停车场管理系统
数据结构C语言第三版习题5参考答案
停车场管理系统—C语言课程设计.doc
数据结构(C语言版)第三版__清华大学出版社_习题参考答案
C++数据结构停车场管理
C语言课程设计报告停车场管理系统
数据结构C语言版第2版课后习题答案
数据结构课程设计报告停车场管理系统
数据结构C语言版第2版课后习题答案
停车场管理系统-c语言
数据结构(c语言版)第三版清华大学出版社习题参考答案
C语言 停车场管理系统
数据结构 停车场管理
数据结构(c语言版)课后习题答案完整版
数据结构实验报告—停车场问题
停车场管理系统c语言
相关主题
文本预览