课程设计实验报告含全部.docx

课程设计实验报告含全部.docx

《课程设计实验报告含全部.docx》由会员分享，可在线阅读，更多相关《课程设计实验报告含全部.docx（84页珍藏版）》请在冰豆网上搜索。

课程设计实验报告含全部

程序设计课程设计报告

学院：

软件学院

专业：

软件工程

班级：

1217班

学号：

******xxxx******xxxx

201200xxxx201200xxxx

姓名：

xxxx、xxxx

xxxx、xxxx

指导教师：

***

时间：

2014年6月

一.交通咨询系统

1.问题描述

2.设计需求及分析

3.设计功能的实现

3.1算法思想描述

3.2概要设计

3.3详细设计

4.实例测试及运行结果

5.实现提示

二.停车场管理系统

1.问题描述

2.设计需求及分析

3.设计功能的实现

4.实例测试及运行结果

5.实现提示

三.学生管理系统

1.问题描述

2.设计需求及分析

3.设计功能的实现

4.实例测试及运行结果

5.实现提示

1.交通咨询系统

专业：

软件工程班级：

软件12xx姓名：

xxx学号：

******xxxx完成日期：

2014.6.26

1．问题描述

设计一个交通咨询系统,能让旅客咨询从任一个城市定点到另一个城市定点之间的最短路径或最低花费或最少时间等问题。

对于不同的咨询要求、可输入城市间的路程或所需时间或所需花费。

设计要求：

1.建立交通网络网的存储结构。

2.总体设计要画流程图。

3.提供程序测试方案。

4.界面友好。

2．设计需求及分析

根据要求，需要在系统中建立无向图。

系统应该有高度灵活性，可以由用户根据当前交通网络图输入初始数据，并且可以更改。

系统根据用户的输入建立无向图的结构，并通过狄克斯特拉算法和弗洛伊德算法实现要求，并提供两种功能供用户选择。

3．设计功能的实现

3.1算法思想描述

首先总体的思想步骤是：

（图1-1）

狄克斯特拉算法的具体流程图如下：

（图1-2）

弗洛伊德算法的具体流程图如下：

（图1-3）

3.2概要设计

系统应该分为三个部分，一是建立交通网络图的存储结构；二是解决单源最短路径问题；最后再实现两个城市顶点之间的最短路径问题。

1、建立图的存储结构：

无向图

首先定义交通图的存储结构。

邻接矩阵是表示图形中顶点之间相邻关系的矩阵。

设G=（V，E）是具有n个顶点的图，则G的邻接矩阵是具有如下定义的n阶方阵。

A[i，j]=

一个图的邻接矩阵表示是唯一的。

图的邻接矩阵表示，除了需要用一个二维数组存储顶点之间相邻关系的邻接矩阵外，通常还需要使用一个具有n个元素的一维数组来存储顶点信息，其中下标为i的元素存储顶点vi的信息

2、单源最短路径：

狄克斯特拉算法

初始化S和D，置空最短路径终点集，置初始的最短路径值；

S[v1]=TRUE；D[v1]=0；//S集初始时只有源点，源点到源点的距离为0；

while（S集中顶点数

{

开始循环，每次求得v1到某个v顶点的最短路径，并加v到S集中；

S[v]=TRUE；

更新当前最短路径及距离；

}

3、任意一对顶点间最短路径：

弗洛伊德算法

假设

为从

到

的只以

集合中的节点为中间节点的最短路径的长度。

1.若最短路径经过点k，则

；

2.若最短路径不经过点k，则

。

因此，最短路径

。

3.3详细设计

程序源代码如下：

#include

#include

#defineNum300//定义常量Num

#defineMaxint32767

enumboolean{FALSE,TRUE};//定义布尔类型

typedefcharVertexType;

typedefintAdjmatrix;

typedefstruct

{

VertexTypevexs[Num];

Adjmatrixarcs[Num][Num];

}MGraph;

intD1[Num],P1[Num];

intD[Num][Num],P[Num][Num];

voidCreateMGraph（MGraph*G,intn,inte）;//构建城市的无向图的声明

voidDijkstra（MGraph*G,intv1,intn）;//狄克斯特拉算法的声明

voidFloyd（MGraph*G,intn）;//弗洛伊德算法的声明

voidmain（）

{MGraph*G;//定义无向图G

intn,e,v,w,k;

intm=1;

G=（MGraph*）malloc（sizeof（MGraph））;

printf（"欢迎使用【交通咨询系统】！

本系统约定：

\n1.记一个城市为一个点，点用从1开始按顺序的编号表示，两个城市的连线为一条边；\n2.程序要求输入的文本都是按回车进行确认；\n3.程序输入输出均不带单位，单位默认为“公里”。

\n\n"）;

printf（"系统需要知道地图的结构，请输入顶点个数和边数，用“,”号隔开：

\n"）;

scanf（"%d,%d",&n,&e）;

CreateMGraph（G,n,e）;//调用CreateMGraph有向图函数

while（m!

=0）{

printf（"===============================================================================\n"）;

printf（"请输入数字：

\n"）;

printf（"0:

退出\n"）;

printf（"1:

求一个城市到其他所有城市的最短路径\n"）;

printf（"2:

求任意的两个城市之间的最短路径\n"）;

scanf（"%d",&m）;

if（m==2）{

Floyd（G,n）;

printf（"请输入起点和终点，用“,”号隔开：

\n"）;

scanf（"%d,%d",&v,&w）;

k=P[v][w];

if（k==0）

printf（"\n输出的结果：

\n顶点%d到%d无路径!

\n",v,w）;

else

{

printf（"\n输出的结果：

\n从顶点%d到%d的最短路径是:

%d",v,w,v）;

while（k!

=w）{

printf（"→%d",k）;

k=P[k][w];

}

printf（"→%d",w）;

printf（"\n路径长度:

%d\n",D[v][w]）;

}

}

else

if（m==1）{

printf（"请输入起点编号：

\n"）;

scanf（"%d",&v）;

Dijkstra（G,v,n）;

}

}

printf（"程序已结束！

谢谢您的使用！

\n"）;

}

voidCreateMGraph（MGraph*G,intn,inte）//构建城市的无向图

{

inti,j,k,w;

for（i=1;i<=n;i++）//以任意城市i出发为起点

G->vexs[i]=（char）i;

for（i=1;i<=n;i++）

for（j=1;j<=n;j++）//任意城市j为终点

{

G->arcs[i][j]=Maxint;//距离初始化

if（i==j）

G->arcs[i][j]=0;

}

printf（"\n请输入%d条边的两端点序号和长度，用“,”号隔开\n例如：

1号城市到2号城市的长度为3，则输入1,2,3）:

\n",e）;

for（k=1;k<=e;k++）

{

scanf（"%d,%d,%d",&i,&j,&w）;

G->arcs[i][j]=w;//建立城市之间的距离

G->arcs[j][i]=w;

}

printf（"\n地图的结构建立成功！

\n"）;

}

voidDijkstra（MGraph*G,intv1,intn）//狄克斯特拉算法求一个城市到任意一个城市的距离

{

intD2[Num],P2[Num];

intv,i,w,min;

enumbooleanS[Num];

for（v=1;v<=n;v++）

{

S[v]=FALSE;//s[]置空

D2[v]=G->arcs[v1][v];//距离初始化

if（D2[v]

P2[v]=v1;

else

P2[v]=0;

}

P2[v1]=0;S[v1]=TRUE;//源点V1放入s中

for（i=2;i

min=Maxint;//Maxint置最小长度初值

for（w=1;w<=n;w++）//选不在S中且有最小顶点w

if（!

S[w]&&D2[w]

{v=w;min=D2[w];}

S[v]=TRUE;

for（w=1;w<=n;w++）//顶点w加入s中

if（!

S[w]&&（D2[v]+G->arcs[v][w]

{

D2[w]=D2[v]+G->arcs[v][w];

P2[w]=v;

}

}

printf（"\n输出的结果：

\n"）;

printf（"路径长度路径\n"）;//输出最短路径

for（i=1;i<=n;i++）{

printf（"%5d",D2[i]）;

printf（"%10d",i）;v=P2[i];

while（v!

=0）{

printf（"←%d",v）;

v=P2[v];

}

printf（"\n"）;

}

}

voidFloyd（MGraph*G,intn）//用弗洛伊德算法求任意两顶点最短距离

{

inti,j,k;//定义三个变量

for（i=1;i<=n;i++）

for（j=1;j<=n;j++）

{

if（G->arcs[i][j]!

=Maxint）//距离初始化

P[i][j]=j;//路径初始化

else

P[i][j]=0;

D[i][j]=G->arcs[i][j];

}

for（k=1;k<=n;k++）//以k为源点循环求出所有顶点的最短路径

{

for（i=1;i<=n;i++）//i为已知最短路径的顶点

for（j=1;j<=n;j++）//j为未知最短路径的顶点

{if（D[i][k]+D[k][j]

D[i][j]=D[i][k]+D[k][j];

P[i][j]=P[i][k];

}

}

}

}

4．实例测试及运行结果

假如某交通网络上有4个城市（序号为1,2,3,4），4个城市之中有5条道路（不同长度），交通网络图如下图所示：

（图1-4）

打开本系统，界面如图：

（图1-5）

输入4,5之后按下键盘上的回车键：

（图1-6）

根据交通网络图输入线路数据后按回车：

（图1-7）

选择1回车后，再输入城市2，求得出的结果如下：

（图1-8）

选择2后，要计算1到3的最短距离和路径，输入1,3，得到结果，并与输入3,1的输出结果作对比如下：

（图1-9）

5．实现提示

在我对作品完成了最后的调试和运行之后，紧张的一个星期的课程设计终于暂时告一段落。

这个课程设计的课题虽然总体来说难度不大，可以找到很多例子供参考。

但是课程设计是个锻炼自己的极好机会，缺失的知识现在得补上！

并且设计的过程是发现自身知识空点的最好的机会，以往不会遇到的情况，在实践练习中一一浮出水面，面对着它们，虽然短短两个星期，但是也经历了很多挫折，有过气馁，但是真正的迈过去以后才感觉到畅快和欣喜，所以遇到的问题，我想到的放弃念头很快被打消，坚持到了作品完成。

课程设计具的实践意义，正如军事锻炼是对我们精神意志的磨练，它是对我们的一次考核和知识补充，对未来工作的演习。

2.停车场管理系统

专业：

软件工程班级：

软件12xx姓名：

xxx学号：

201200xxxx完成日期：

2014.6.26

1.问题描述

设停车场是一个可停放n辆汽车的狭长通道，且只有一个大门可供汽车进出。

汽车在停车场内按车辆到达时间的先后顺序，依次由北向南排列（大门在最南端，最先到达的第一辆车停放在停车场的最北端）,若停车场内已停满n辆汽车，则后来的汽车只能在门外的便道上等候，一旦有车开走，则排在便道上的第一辆车即可开入；当停车场内某辆车要离开时，在它之后进入的车辆必须先退出车场为它让路，待该辆车开出大门外，其他车辆再按原次序进入车场，每辆停放在车场的车在它离开停车场时必须按它停留的时间长短交纳费用。

2.设计需求及分析

说明本程序中用到的所有抽象数据类型的定义、主程序的流程以及各程序模块之间的层次（调用）关系。

实现设计中定义的所有数据类型，对每个操作写出伪码算法；对主程序和其他模块也写出伪码算法（伪码算法的详细程度为按照伪码算法可以在计算机键盘直接输入高级程序设计语言程序）；画出函数的调用关系图。

3.设计功能的实现（用C或C++描述）

以栈模拟停车场，以队列模拟车场外的便道，按照从终端读入的输入数据序列进行模拟管理。

每一组输入数据包括三个数据项：

汽车“到达”或“离去”信息、汽车牌照号码以及到达或离去的时刻。

对每一组输入数据进行操作后的输出信息为：

若是车辆到达，则输出汽车在停车场内或便道上的停车位置；若是车辆离去，则输出汽车在停车场内停留的时间和应交纳的费用（在便道上停留的时间不收费）。

栈以顺序结构实现，队列以链表结构实现。

#include"tcc.h"

#include

#include

#include

#include

#defineMAX10

#defineprice0.05

typedefstructtime

{

inthour;

intmin;

}time;

typedefstructcarnode

{

charnum[10];

timereach;

timeleave;

}carnode;

typedefstructcarstack

{

carnode*stack[MAX+1];

inttop;

}carstack;

typedefstructqnode

{

carnode*data;

structqnode*next;

}qnode;

typedefstructnode

{

qnode*head;

qnode*rear;

}linkqueue;

voidinitstack（carstack*s）

{

inti;

s->top=0;

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

s->stack[s->top]=NULL;

}

intinitqueue（linkqueue*Q）

{

Q->head=（qnode*）malloc（sizeof（qnode））;

if（Q->head!

=NULL）

{

Q->head->next=NULL;

Q->rear=Q->head;

return1;

}

else

return-1;

}

intarrival（carstack*enter,linkqueue*w）//车μ辆?

到?

达?

{

carnode*p;

qnode*t;

p=（carnode*）malloc（sizeof（carnode））;

printf（"\n请?

您ú输?

入?

车μ牌?

号?

：

阰"）;

scanf（"%s",&p->num）;

if（enter->top

{

enter->top++;

printf（"\n该?

车μ停?

在ú的?

位?

置?

：

阰%d号?

",enter->top）;

printf（"\n请?

您ú输?

入?

车μ到?

达?

的?

时骸?

间?

：

阰"）;

scanf（"%d:

%d",&（p->reach.hour）,&（p->reach.min））;

enter->stack[enter->top]=p;

return1;

}

else

{

printf（"对?

不?

起e，?

停?

车μ场?

已?

满ú请?

您ú停?

在ú便?

道台?

上"）;

t=（qnode*）malloc（sizeof（qnode））;

t->data=p;

t->next=NULL;

w->rear->next=t;

w->rear=t;

return1;

}

}

voidprint（carnode*p,introom）//汽?

车μ离?

站?

时骸?

缴é费?

显?

示?

{

printf（"\n车μ辆?

离?

开a的?

时骸?

间?

：

阰"）;

scanf（"%d:

%d",&p->leave.hour,&p->leave.min）;

printf（"\n离?

开a车μ辆?

的?

车μ牌?

号?

为a:

%s",p->num）;

printf（"\n其?

到?

达?

时骸?

间?

为a：

阰%02d:

%02d",p->reach.hour,p->reach.min）;

printf（"\n其?

离?

开a时骸?

间?

为a：

阰%02d:

%02d",p->leave.hour,p->leave.min）;

printf（"\n应畖缴é费?

用?

为a：

阰%.2f元a",（（p->leave.hour-p->reach.hour）*60+（p->leave.min-p->reach.min））*price）;

free（p）;

}

voidleave（carstack*enter,carstack*temp,linkqueue*w）//车μ辆?

离?

开a

{

introom;

carnode*p,*t;

qnode*q;

if（enter->top>0）//有瓺车μ

{

while

（1）

{

printf（"\n请?

您ú输?

入?

车μ在ú停?

车μ场?

上?

的?

位?

置?

:

"）;

scanf（"%d",&（room））;

if（room>=1&&room<=enter->top）

break;

}

}

while（enter->top>room）//位?

置?

不?

在ú栈?

顶￥的?

汽?

车μ出?

栈?

{

temp->top++;

temp->stack[temp->top]=enter->stack[enter->top];

enter->stack[enter->top]=NULL;

enter->top--;

}

p=enter->stack[enter->top];

enter->stack[enter->top]=NULL;

enter->top--;

while（temp->top>=1）//当獭?

暂Y时骸?

存?

储洹?

汽?

车μ的?

栈?

结á构1中D有瓺汽?

车μ时骸?

{

enter->top++;

enter->stack[enter->top]=temp->stack[temp->top];

temp->stack[temp->top]=NULL;

temp->top--;

}

print（p,room）;

//判D断?

便?

道台?

上?

是?

否?

有瓺车μ及°停?

车μ场?

上?

是?

否?

已?

满ú

if（（w->head!

=w->rear）&&enter->top

有瓺空?

位?

且ò便?

道台?

上?

有瓺车μ时骸?

{

q=w->head->next;

t=q->data;

enter->top++;

printf（"\n请?

便?

道台?

上?

的?

%s号?

车μ进?

入?

第台?

d位?

置?

。

￡",t->num,enter->top）;

printf（"\n请?

输?

入?

现?

在ú的?

时骸?

间?

：

阰"）;

scanf（"%d:

%d",&（t->reach.hour）,&（t->reach.min））;

w->head->next=q->next;

if（q==w->rear）

{

w->rear=w->head;

enter->stack[enter->top]=t;

free（q）;

}

else

printf（"\n便?

道台?

里?

没?

有瓺车μ！

?

"）;

}

else

printf（"\n目?

前°停?

车μ场?

里?

没?

有瓺停?

放?

的?

车μ"）;

}

//显?

示?

停?

车μ场?

的?

信?

息￠

voidlist1（carstack*s）

{

inti;

if（s->top>0）

{

printf（"\n停?

车μ场?

：

阰"）;

printf（"\n停?

车μ位?

置?

\t到?

达?

时骸?

间?

\t车μ牌?

号?

\n"）;

for（i=1;i<=s->top;i++）

{

printf（"%d\t",i）;

printf（"%02d:

%02d",s->stack[i]->reach.hour,s->stack[i]->reach.min）;

printf（"\t%s",s->stack[i]->num）;

}

}

else

printf（"\n对?

不?

起e，?

暂Y无T停?

车μ场?

里?

的?

信?

息￠！

?

"）;

}

//显?

示?

便?

道台?

上?

的?

voidlist2（linkqueue*w）

{

qnode*p;

p=w->head->next;

if（w->head!

=w->rear）

{

printf（"\n等台?

待鋣车μ辆?

的?

号?

码?

为a：

阰"）;

printf（"\n**********************************"）;

while（p!

=NULL）

{

puts（p->data->num）;

p=p->next;

}

printf（"\n**********************************"）;

}

else

printf（"\n便?

道台?

里?

没?

有瓺车μ！

?

"）;

}

voidlist（carstacks,linkqueuew）

{

intflag,tag;

flag=1;

while（flag）

{

printf（"\n请?

选?

择?

：

阰"）;

printf（"\n\t\t1、￠停?

车μ场?

信?

息￠\n\t\t2、￠便?

道台?

信?

息￠\n\t\t3、￠返う?

回?

主÷菜?

单蹋n"）;

while

（1）

{