数据结构课程设计交通咨询系统设计

信息科学与工程学院课程设计任务书

题目：交通咨询系统设计

学号： 201112220141

姓名：

年级：

专业：计算机应用与技术

课程：数据结构

指导教师：职称：

完成时间：

课程设计任务书及成绩评定

一、需求分析

设计一个交通咨询系统，能让旅客咨询从任一个城市顶点到另一城市顶点之间的最短路径（里程）或最低花费或最少时间等问题。对于不同的咨询要求，可输入城市间的路程或所需时间或所需费用。

本设计共分三部分，一是建立交通网络图的存储结构；二是解决单源最短路径问题；三是实现任两个城市顶点之间的最短路径问题。

1.1.1建立图的存储结构

邻接矩阵是表示图形中顶点之间相邻关系的矩阵。图的邻接矩阵是定义如下的n 阶方阵：

设G=（V ，E ）是一个图，结点集为

{}

n v v v V ,,,21 =。

G 的邻接矩阵,E

,,0E

,,)(,)(????

?>?<∞>∈<==??j i j i j i j i n n j i ij n n ij v v v v v v v v w a a A ）或当（，或）或当（， 当邻接矩阵的行表头、列表头顺序一定时，一个图的邻接矩阵表示是唯一的。

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

1.1.2 单源最短路径

最短路径的提法很多。在这里先讨论单源最短路径问题：即已知有向图（带权），我们希望找出从某个源点S ∈V 到G 中其余各顶点的最短路径。

为了叙述方便，我们把路径上的开始点称为源点，路径的最后一个顶点为终点。那么，如何求得给定有向图的单源最短路径呢？迪杰斯特拉（Dijkstra ）提出按路径长度递增产生诸点的最短路径算法，称之为迪杰斯特拉算法。

迪杰斯特拉算法求最短路径的实现思想是：设G=（V ，E ）是一个有向图，

结点集为，}v ,,v ,{v V n 21?=，cost 是表示G 的邻接矩阵，cost[i][j]表示有向边的权。若不存在有向边，则cost[i][j]的权为无穷大（这里取值为32767）。设S 是一个集合，其中的每个元素表示一个顶点，从源点到这些顶点的最短距离已经求出。设顶点v 1为源点，集合S 的初态只包含一个元素，即顶点v 1。数组dist 记录从源点到其他顶点当前的最短距离，其初值为dist[i]=cost[v 1][i],i=1,2,……,n 。从S 之外的顶点集合V-S 中选出一个顶点w ，使dist[w]的值最小。于是从源点到达w 只通过S 中顶点，把w 加入集合S 中，调整dist 中记录的从源点到V-S 中每个顶点v 的距离：从原来的dist[v]和dist[w]+cost[w][v]中选择较小的值作为新的dist[v]。重复上述过程，直到V-S 为空。

最终结果是：S 记录了从源点到该顶点存在最短路径的顶点集合，数组dist 记录了源点到V 中其余各顶点之间的最短路径，path 是最短路径的路径数组，其中path[i]表示从源点到顶点i 之间的最短路径的前驱顶点。

因此，迪杰斯特拉算法可用自然语言描述如下：

1.1.3 任意一对顶点间最短路径

任意一对顶点间最短路径问题，是对于给定的有向网络图G=（V ，E ），要对G 中任意一对顶点有序对“v,w(v ≠w)”,找出v 到w 的最短路径。

要解决这个问题，我们可以依次把有向网络图中每个顶点作为源点，重复执行前面讨论的迪杰斯特拉算法n 次，即可以求得每对顶点之间的最短路径。

这里还可以用另外一种方法，称作费洛伊德（Floyd ）算法。

费洛伊德（Floyd ）算法算法的基本思想是：假设求从顶点 v i 到v j 的最短路

径。如果从v

i 到v

j

存在一条长度为arcs[i][j]的路径，该路径不一定是最短路

径，还需要进行n次试探。首先考虑路径

i ,v

1

>和

1

,v

j

>是否存在。如果存在，

则比较

i ,v

j

>和< v

i

,v

1

,v

j

>的路径长度，取长度较短者为当前所求得的最短路

径。该路径是中间顶点序号不大于1的最短路径。其次，考虑从v

i 到v

j

是否包

含有顶点v

2为中间顶点的路径

i

,…,v

2

,…,v

j

>，若没有，则说明从v

i

到v

j

的当

前最短路径就是前一步求出的；若有，那么

i ,…,v

2

,…,v

j

>可分解为

i

, (v)

2

>

和

2,…,v

j

>,而这两条路径是前一次找到的中间顶点序号不大于1的最短路径，

将这两条路径长度相加就得到路径

i ,…,v

2

,…,v

j

>的长度。将该长度与前一次

中求出的从v

i 到v

j

的中间顶点序号不大于1的最短路径比较，取其长度较短者

作为当前求得的从v

i 到v

j

的中间顶点序号不大于2的最短路径。依此类推，直

到顶点v

n 加入当前从v

i

到v

j

的最短路径后，选出从v

i

到v

j

的中间顶点序号不大

于n的最短路径为止。由于图G中顶点序号不大于n，所以v

i 到v

j

的中间顶点序

号不大于n的最短路径，已考虑了所有顶点作为中间顶点的可能性，因此，它就

是v

i 到v

j

的最短路径。

1.2 程序流程图

二、详细设计

2.1 建立有向图的存储结构

void CreateMGraph(MGraph * G,int n,int e) {

int i,j,k,w;

for(i=1;i<=n;i++)

G->vexs[i]=(char)i;

for(i=1;i<=n;i++)

for(j=1;j<=n;j++)

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

printf("输入%d条边的i,j及w:\n",e);

for(k=1;k<=e;k++)

{

scanf("%d,%d,%d",&i,&j,&w);

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

}

printf("有向图建立完毕\n");

}

2.2迪杰斯特拉算法

void Dijkstra(MGraph *G,int v1,int n) {

int D2[MVNum],P2[MVNum];

int v,i,w,min;

enum boolean S[MVNum];

for(v=1;v<=n;v++)

{

S[v]=FALSE;

D2[v]=G->arcs[v1][v];

if(D2[v]

P2[v]=v1;

else

P2[v]=0;

}

D2[v1]=0;S[v1]=TRUE;

for(i=2;i

{

min=Maxint;

for(w=1;w<=n;w++)

if(!S[w]&&D2[w]

{

v=w;min=D2[w];

}

S[v]=TRUE;

for(w=1;w<=n;w++)

if(!S[w]&&(D2[v]+G->arcs[v][w]

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

P2[w]=v;

}

}

printf("路径长度路径\n");

for(i=1;i<=n;i++)

{

printf("%5d",D2[i]);

printf("%5d",i);v=P2[i];

while(v!=0)

{

printf("<-%d",v);

v=P2[v];

}

printf("\n");

}

}

2.3 费洛伊德算法

void Floyd(MGraph *G,int n)

{ int i,j,k,v,w;

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++)

{

for(i=1;i<=n;i++)

for(j=1;j<=n;j++)

{

if(D[i][k]+D[k][j]

{

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

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

}

}

}

}

2.4 运行主控程序

void main()

{ MGraph *G;

int m,n,e,v,w,k;

int xz=1;

G=(MGraph *)malloc(sizeof(MGraph));

printf("输入图中顶点个数和边数n,e:");

scanf("%d,%d",&n,&e);

CreateMGraph(G,n,e);

while (xz!=0)

{ printf("******求城市间的最短路径******\n");

printf("1.求一个城市到所有城市的最短路径\n");

printf(“2.求任意的两个城市之间的最短路径\n");

printf(" 请选择：1 或 2,选择 0 退出:");

scanf("%d",&xz);

if(xz==2)

{

Floyd(G,n);

printf("输入起点和终点:v,w:");

scanf("%d,%d",&v,&w);

k=P[v][w];

if(k==0)

printf("顶点 %d 到 %d 无路径!\n",v,w);

else

{ printf("从顶点%d到%d的最短路径是::%d",v,w,v);

while(k!=w)

{

printf("→¨2%d",k);

k=P[k][w];

}

printf("→¨2%d",w);

printf("路径长度:%d\n",D[v][w]);

}

}

else if(xz==1)

{

printf("求单源路径，输入源点 v :");

scanf("%d",&v);

Dijkstra(G,v,n);

}

}

printf("结束求最短路径");

}

三、调试分析

编译: 在第一次编译时出现了很多错误，是因为我对C语言的不熟练，比如调用费洛伊德算法时出现了调用的错误，找了好久，才改正过来，还有就是for 语句的运用，由于本次程序要用很多for循环，我把一次for循环放到了上面for循环中，导致程序不能正确输出结果。最后把调到外面才OK。

四、测试结果

交通咨询系统通过迪杰斯特拉算法得出每一个城市到所有城市的最短路径,然后通过费洛伊德算法得出任意两个城市间最短路径。

本程序的运行环境为DOS操作系统，执行文件为交通咨询.exe。

进入程序后，即显示文本的操作界面：

输入定点数和边数后，依次输入有向边，以及两点间的距离，用逗号间隔开，回车换行，当有向图输入完全时，进入菜单

选择你要进行的模式，求一个城市到所有城市的最短路径输入1，回车进入该模式，输入你所要求的城市代表的顶点数，回车确认。

求任意的两个城市之间的最短路径输入2，回车确认进入该模式，输入两座城市代表的顶点数，以逗号间隔开，回车确认。

运行结果：下面是城市交通图

上海

五、附录

#include

#include

#define MVNum 100 //最大顶点数

#define Maxint 35000

enum boolean{FALSE,TRUE};

typedef char Vertextype;

typedef int Adjmatrix;

typedef struct

{

Vertextype vexs[MVNum]; //顶点数组，类型假定为char型Adjmatrix arcs[MVNum] [MVNum]; // 邻接矩阵，假定为int型} MGraph;

int D1[MVNum], p1[MVNum];

int D[MVNum][MVNum],p[MVNum][MVNum];

//文件名save.c

void CreateMGraph(MGraph *G,int n,int e)

{ //采用邻接矩阵表示法构造有向图G,n,e表示图的当前顶点数和边数 int i,j,k,w;

for(i=1;i<=n;i++) //输入顶点信息

G->vexs[i]=(char)i;

for(i=1;i<=n;i++)

for(j=1;j<=n;j++)

G->arcs[i][j]=Maxint; // 初始化邻接矩阵

printf ("输入%d条边的i,j及w: \n",e);

for(k=1;k<=e;k++)

{ //读入e条边,建立邻接矩阵

scanf("%d,%d,%d",&i,&j,&w);

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

}

printf ("有向图的存储结构建立完毕！ \n");

}

//文件名:dijkstra.c(迪杰斯特拉算法）

void Dijkstra(MGraph *G, int v1,int n)

{ //用Dijkstra算法求有向图G的v1顶点到其他顶点v的最短路径p[v]及其权D[v]

//设G是有向图的邻接矩阵，若边不存在，则G[i][j]=Maxint //S[v]为真当且仅当v属于S，及以求的从v1到v的最短路径

int D2[MVNum], p2[MVNum];

int v,i,w,min;

enum boolean S[MVNum];

for(v=1;v<=n;v++)

{ // 初始化S和D

S[v]=FALSE; //置空最短路径终点集

D2[v]=G->arcs[v1][v]; //置初始的最短路径值

if(D2[v]< Maxint)

p2[v]=v1; //v1是的前趋（双亲）

else

p2[v]=0; //v 无前趋

} // End_for

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

//开始循环，每次求的V1到某个V顶点的最短路径，并加V到S集中 for(i=2;i

{ //其余n-1个顶点

min=Maxint; // 当前所知离v1顶点的最近距离，设初值为∞ for(w=1;w<=n;w++) //对所有顶点检查

if(!S[w] && D2[w]

{ //找离v1最近的顶点w，并将其赋给v，距离赋给min

v=w; //在S集之外的离v1最近的顶点序号

min=D2[w]; //最近的距离

} //W顶点距离V1顶点更近

S[v]=TRUE; //将v并入S集

for(w=1;w<=n;w++) //更新当前最短路径及距离

if(!S[w]&&(D2[v]+G->arcs[v][w]

{ //修改D2[w]和p2[w]， w 属于 V-S

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

p2[w]=v;

} //End_if

} //End_for

printf ("路径长度路径\n");

for(i=1;i<=n;i++)

{ printf ("%5d", D2[i]);

printf ("%5d", i);v=p2[i];

while(v!=0) {

printf ("<-%d", v);

v=p2[v];

}

printf("\n");

}

}

//文件名 floyd.c(费洛伊德算法）

void Floyd(MGraph *G, int n)

{

int i, j, k;

for(i=1;i<=n;i++) //设置路径长度D和路径path初值

for(j=1;j<=n;j++)

{

if(G->arcs[i][j]!=Maxint)

p[i][j]=j; //j是i的后继

else

p[i][j]=0;

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

}

for(k=1;k<=n;k++) {

{ //做K次迭代，每次均试图将顶点K扩充到当前求得的从i到j的最短路径pij上

for(i=1;i<=n;i++)

for(j=1;j<=n;j++)

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

D[i][j]=D[i][k]+D[k][j]; //修改长度

p[i][j]=p[i][k];

}

}

}

}

}

void main()

{ MGraph * G;

int n, e, v, w, k;

int xz=1;

G=(MGraph *)malloc(sizeof(MGraph));

printf("输入图中顶点个数和边数n,e: ");

scanf("%d,%d", &n, &e);

CreateMGraph(G, n, e); //建立图的存储结构

while(xz!=0)

{

printf(" 求城市之间的最断路径 \n");

printf("-------------------------------\n");

printf("1.求一个城市到所有城市的最短路径\n"); printf("2.求任意的两个城市之间的最短路径\n");

printf("--------------------------------\n");

printf(" 请选择：1 或 2，选择0 ：退出： "); scanf("%d",&xz);

if(xz==2)

{

Floyd(G,n); //调用费洛伊德算法

printf("输入起点和终点: v,w:");

scanf("%d,%d",&v,&w );

k=p[v][w]; //k为起点v的后继顶点

if(k==0)

printf("顶点%d 到%d 无路径! \n",v,w);

else