交通咨询模拟数据结构课程设计

数据结构课程设计报告
题目：全国交通咨询模拟
一．需求分析
1．程序设计任务：
从中国地图平面图中选取部分城市，抽象为程序所需要图的结点，并以城市间的列车路线和飞机路线，作为图结点中的弧信息，设计一个全国交通咨询模拟系统。

利用该系统实现两种最优决策：最快到达或最省钱到达。

2. 明确规定：
(1)输入形式和输入值的范围：
每条飞机弧或者火车弧涉及的信息量很多，包括：起始城市、目的城市、出发时间、到达时间、班次以及费用。

作为管理员要输入的信息包括以上信息，而作为用户或者客户，要输入的信息有起始城市和目的城市，并选择何种最优决策。

(2)输出形式：
按用户提供的最优决策的不同而输出不同的信息，其中输出的所搭飞机或火车的班次及其起始地点和终点、起始时间和出发时间还有相关的最优信息，比如最快经多少时间到达、最省钱多少钱到达和最少经多少中转站到达。

(3)程序所能达到的功能
a.该系统有供用户选择的菜单和交互性。

可以对城市、列车车次和飞机航班进行编辑，添加或删除。

b.建立一个全国交通咨询系统，该系统具备自动查找任意两城市间铁路、飞机交通的最短路径和最少花费及中转次数最少等功能。

c.初始化交通系统有两种方式，键盘和文档。

二．设计概要
1. 算法设计
(1)、总体设计
(1) 数据存储:城市信息(城市名、代码)、交通信息(城市间的里程、各航班和列车时刻)存储于磁盘文件。

建议把城市信息存于文件前面，交通信息存于文件的后面，用fread和fwrite函数操作。

(2) 数据的逻辑结构:根据设计任务的描述，其城市之间的旅游交通问题是典型的图结构，可看作为有向图，图的顶点是城市，边是城市之间所耗费的时间（要包括中转站的等候时间）或旅费。

(3) 数据的存储结构:采用邻接表和邻接矩阵都可作为数据的存储结构，但当邻接边不多时，宜采用邻接表，以提高空间的存储效率。

这里采用邻接表作为数据的存储结构。

(4) 用不同的功能模块对城市信息和交通信息进行编辑。

添加、修改、删除功能可用菜单方式或命令提示方式。

只要能方便的对城市信息和交通信息进行管
理即可，但要注意人机界面。

(5) 最优决策功能模块(fast or province)。

①读入城市信息和交通信息，用邻接表生成含权网络，表头数组中的元素存放城市名及对方城市到达该元素所代表城市的所有信息；表头数组中的元素所对应的单链表存放与该元素所代表的城市有交通联系的城市(代码、里程、航班、列车车次)。

②根据具体最优决策的要求，用Dijkstra算法求出出发城市到其它各城市的最优值(最短时间或最小的费用)，搜索过程中所经过城市的局部最优信息都保存在邻接表的表头数组中。

其目的城市所代表的元素中就保存了所需的最优决策结果。

这过程中，要用队列或栈保存局部最优决策值(局部最短的时间或最省的费用)变小的城市，其相应的初始值可为∞，并在表头数组对应的城市元素中保存响应的信息。

开始时，栈(队列)中只有出发地城市，随着对栈(队列)顶(首)城市有交通联系的城市求得决策值(最短时间或最小的费用)，若该值是局部最优值且该城市不在栈(队列)中，则进栈(队列)，直至栈(队列)为空，本题采用队列实现。

③输出结果：从目的城市出发，搜索到出发城市，所经过的城市均入栈(队列)，再逐一出栈栈(队列)中的城市，输出保存在表头数组中对应城市的信息(对方城市的出发信息，里程、时间、费用等)及最终结果。

即输出依次于何时何地乘坐几点的飞机或火车于何时到达何地；最终所需的最快需要多长时间才能到达及旅费，或者最少需要多少旅费才能到达及时间。

(6) 主程序可以有系统界面、菜单；也可用命令提示方式；选择功能模块执行，要求在程序运行过程中可以反复操作。

(2).详细设计思想：
本题所要求的交通系统是一个有向带权图结构，考虑到要求该系统有动态增加飞机和列车航班的功能，因而采用邻接表的形式存储：对每个顶点建立一个单链表，单链表中的子结点表示以该顶点连接的弧，单链表中子结点的顺序可以按权值递增的顺序排列，表头结点按顺序存储。

题目中提到要提供三种策略，最快到达，最省钱到达和最少中转次数策略，前两种策略采用迪杰斯特拉算法思想，其中最快到达的权值为到达两城市所需的最短时间，最省钱到达的权值为到达两城市所需的费用，后一种采用广度优先算法的思想，只需求的两城市所在的层数，就可以求的到达两城市所需的最少中转次数。

迪杰斯特拉（Dijkstra）算法的基本思想是：
设置两个顶点的集合S和T＝V－S，集合S中存放已找到最短路径的顶点，集合T存放当前还未找到最短路径的顶点。

初始状态时，集合S中只包含源点v0，然后不断从集合T中选取到顶点v0路径长度最短的顶点u加入到集合S中，集合S每加入一个新的顶点u，都要修改顶点v0到集合T中剩余顶点的最短路径长度值，集合T中各顶点新的最短路径长度值为原来的最短路径长度值与顶点u的最短路径长度值加上u到该顶点的路径长度值中的较小值。

此过程不断重复，直到集合T的顶点全部加入到S中为止。

下面讨论基于邻接表的存储结构求两点间最短路径的方法：
根据迪杰斯特拉(Dijkstra)算法所依据的原理：若按长度递增的次序生成从源点V0到其它顶点的最短路径，则当前正在生成的最短路径上除终点以外，其余顶点的最短路径均已生成（将源点的最短路径看作是已生成的源点到其自身的长度为0的路径）。

按照这一思想，构造以下算法：
设S=S’=U={}，建立数组PATH[n]，用来存储V0到各终点的最短路径，初值均置为空集。

建立数组BOOL F[n]，F[i]表示序号为i的表头结点的单链表中所有子结点已或未全部找到，初值置为FALSE。

建立数组float dist[n]，dist[i]表示序号为i的表头结点到V0的最短权值（这里是时间或费用），显然dist[V0]=0,其他顶点的dist初值置为∞。

建立数组BOOL IS[n]，IS[i]表示序号为i的顶点是否在S中，初值均置为FALSE。

(1)VX=V0；最短的最短路径为PATH[0]=[V0]
(2)S=S+VX；（集合的并计算）
IS[VX]=TRUE；
S’=S’+VX ；
(3)对S’中的所有顶点：
{
do{ 由邻接表中该表头结点开始依次找单链表的下一子结点(沿链域指针依次
}
a. 对引用形参了解的不是很透彻，导致错误，通过查阅相关书籍如《C++ Primer》和请教编程能力较高的人，最终解决问题。

b. 通过参考谭浩强编着的《C程序设计》中的文件操作，文件格式和相关文件路径的设置，最终解决问题。

⑵算法的时空分析（包括基本操作和其他算法的时间复杂度和空间复杂度的分
：
通过本次课程设计，我学到了一种程序设计方法，就是结构化程序设计方法，在程序设计过程中，我尝试按如下方法进行结构化程序设计：
(1)自顶向下；(2)逐步细化；(3)模块化设计(4)结构化编码。

这种设计方法的过程是将问题求解由抽象逐步具体化的过程，而且，用这种方法便于验证算法的正确性。

本次课程设计所使用的是较为复杂的抽象数据类型——图，而且在弧的基础上增加了许多信息，如添加了时间，费用等等，这无疑给编程加大了难度，同时也是相当的具有挑战性。

在编程的过程中，我用到了全局数组，我将数组放在工程的头文件里面，编译的时候报错，说是多重定义。

最终放弃了创建工程，而选择了单个文件进行编译和运行，结果顺利通过。

同时，在文件操作方面我也曾遇到问题，就是在程序对文件进行读取的时候报错，无法读取文件，最后查询有关C的工具书，原来是文件路径问题，借助工具书最终解决了文件操作方面的问题。

总之，这次课程设计是对这一个学期以来对数据结构学习成果的一个验证，同时也是理论与实践很好的结合，既对学过的数据结构进行了巩固，也对我的编程能力奠定了坚实的基础。

五．用户使用说明：
1)打开并运行程序，按任意键进入操作主界面，按提示进行相关操作；
2)按“1”进入管理员界面，按“2”进入用户咨询界面，按“3”显示交通系
统，按“4”则退出。

3)进入管理员界面可键入“1”初始化交通系统，并选择文档初始化方式(如果
是第一次使用该系统建议使用文档初始化交通系统，免得自己进行繁冗的初始化操作)。

其余可按提示进行相关操作，不难掌握。

4)进入用户咨询界面，可根据用户需要进行相关的选择，或是选择“1”(最少
旅行费用)；或是选择“2”(最少旅行时间)，又或者是选择“3”(最少旅行中转次数)等。

5)进入显示交通系统界面，根据用户选择则可显示城市、飞机航班、列车车次
等信息。

或者返回上一级菜单。

六．附录——源程序
#define MAX_VERTEX_NUM 18
#define NULL 0
#define MAX_ARC_SIZE 100
#define MAX_ROUTE_NUM 5
#include<>
#include<>
#include<>
#include<>
#define False 0
#define True 1
#define INFINITY 10000
typedef struct
{
int number;
float expenditure;
int begintime[2];
int arrivetime[2];
}Vehide;
typedef struct
{
Vehide stata[MAX_ROUTE_NUM];
int last;
}infolist;
typedef struct ArcNode
{
int adjvex;
struct ArcNode *nextarc;
infolist info;
}ArcNode;
typedef struct VNode
{
char cityname[10];
ArcNode *planefirstarc,*trainfirstarc; }VNode,AdjList[MAX_VERTEX_NUM]; typedef struct
{
AdjList vertices;
int vexnum,planearcnum,trainarcnum; }ALGraph;
typedef struct Node
{
int adjvex;
int route;
struct Node *next;
}Node;
typedef struct QNode
{
int adjvex;
struct QNode *next;
}QNode;
typedef struct
{
QNode *front;
QNode *rear;
}LinkQueue;
typedef struct TimeNode
{
int adjvex;
int route;
int begintime[2];
int arrivetime[2];
struct TimeNode *child[MAX_ROUTE_NUM];
}TimeNode,*TimeTree;
struct arc
{
int co;
char vt[10];
char vh[10];
int bt[2];
int at[2];
float mo;
}a[MAX_ARC_SIZE];
char city[MAX_VERTEX_NUM][10];
int TTime[2];
int time[2];
int time1[2];
int time2[2];
int c[MAX_VERTEX_NUM];
int d[MAX_VERTEX_NUM];
void Administer(ALGraph *G);
void cityedit(ALGraph *G);
void CopyTimeTree(TimeTree p,TimeTree q);
void createcityfile();
void CreateGraph(ALGraph *G);
void createplanefile();
void CreateTimeTree(TimeTree p,int i,int j,LinkQueue *Q,infolist (*arcs)[MAX_VERTEX_NUM]);
void createtrainfile();
int DeleteplaneArc(ALGraph *G);
void DeleteQueue(LinkQueue *Q,int *x);
int DeletetrainArc(ALGraph *G);
void DeleteVertex(ALGraph *G);
void DemandDispose(int n,ALGraph G);
void DestoryTimeTree(TimeTree p);
void EnterplaneArc(ALGraph *G);
void EnterQueue(LinkQueue *Q,int x);
void EntertrainArc(ALGraph *G);
void EnterVertex(ALGraph *G);
void ExpenditureDispose(int k,infolist (*arcs)[MAX_VERTEX_NUM],ALGraph G,int v0,int v1,float *M,int *final);
void flightedit(ALGraph *G);
void initgraph(ALGraph *G);
void InitQueue(LinkQueue *Q);
int IsEmpty(LinkQueue *Q);
int LocateVertex(ALGraph *G,char *v);
void MinExpenditure(infolist arcs,float *expenditure,int *route);
void MinTime(infolist arcs,int *time,int *route);
void PrintGraph(ALGraph *G);
int save(ALGraph *G);
void TimeDispose(int k,infolist (*arcs)[MAX_VERTEX_NUM],ALGraph G,int v0,int v1,int (*T)[2],int *final);
void TimeTreeDispose(Node *head,infolist (*arcs)[MAX_VERTEX_NUM]);
void trainedit(ALGraph *G);
void TransferDispose(int k,infolist (*arcs)[MAX_VERTEX_NUM],ALGraph G,int v0,int v1); void UserDemand(ALGraph G);
void VisitTimeTree(TimeTree p);
int main()
{ALGraph G;
int i;
printf("\n\n\n\n\n\n\n************************************************************** ******************\n");
printf("************************************************************************* *******\n");
printf("*~*~*~*~*~ 学院：信息科学与技术学院~*~*~*~*~*\n");
printf("*~*~*~*~*~ 专业：通信工程~*~*~*~*~*\n");
printf("*~*~*~*~*~ 姓名：~*~*~*~*~*\n");
printf("*~*~*~*~*~ 学号：0 ~*~*~*~*~*\n");
printf("************************************************************************* *******\n");
printf("************************************************************************* *******\n");
printf("请按任何键以继续……");
getchar();
system("cls");
printf("\n\n\n\n\n\n\n 请选择程序功能:\n");
printf(" *************************************\n");
printf(" ** 1=管理员管理**\n");
printf(" ** 2=用户咨询**\n");
printf(" ** 3=显示交通系统**\n");
printf(" ** 4=退出**\n");
printf(" *************************************\n");
printf(" 选择");
scanf("%d",&i);
getchar();
while(i!=4)
{
switch(i)
{
case 1:Administer(&G);
break;
case 2:UserDemand(G);
break;
case 3:PrintGraph(&G);
break;
}
system("cls");
printf("\n\n\n\n\n\n\n\n 请选择程序功能:\n" );
printf(" *************************************\n");
printf(" ** 1=管理员管理**\n");
printf(" ** 2=用户咨询**\n");
printf(" ** 3=显示交通系统**\n");
printf(" ** 4=退出**\n");
printf(" *************************************\n");
printf(" 选择");
scanf("%d",&i);
getchar();
}
return 1;
}
void Administer(ALGraph *G)
{
int i;
system("cls");
printf("\n\n\n\n\n\n\n\n 请选择管理项目:\n");
printf(" *************************************\n");
printf(" ** 1=初始化交通系统**\n");
printf(" ** 2=城市编辑**\n");
printf(" ** 3=飞机航班编辑**\n");
printf(" ** 4=列车车次编辑**\n");
printf(" ** 5=返回上一级菜单**\n");
printf(" *************************************\n");
printf(" 选择");
scanf("%d",&i);
getchar();
while(i!=5)
{
switch(i)
{
case 1:initgraph(G);
break;
case 2:cityedit(G);
break;
case 3:flightedit(G);
break;
case 4:trainedit(G);
break;
}
system("cls");
printf("\n\n\n\n\n\n\n\n\n 请选择管理项目:\n");
printf(" *************************************\n");
printf(" ** 1=初始化交通系统**\n");
printf(" ** 2=城市编辑**\n");
printf(" ** 3=飞机航班编辑**\n");
printf(" ** 4=列车车次编辑**\n");
printf(" ** 5=返回上一级菜单**\n");
printf(" *************************************\n");
printf(" 选择");
scanf("%d",&i);
getchar();
}
}
void initgraph(ALGraph *G)
{
int i;
system("cls");
printf("\n\n\n\n\n\n\n\n\n 请选择初始化方式:\n");
printf(" **************************************\n");
printf(" ** 1=键盘**\n");
printf(" ** 2=文档**\n");
printf(" **************************************\n");
printf(" 选择");
scanf("%d",&i);
getchar();
switch(i)
{
case 1:createcityfile();
createplanefile();
createtrainfile();
CreateGraph(G);
break;
case 2:CreateGraph(G);
break;
}
}
void createcityfile()
{
int i=0;
int j;
char flag='y';
FILE *fp;
printf("\n请输入城市名称的信息:\n");
while(flag=='y'||flag=='Y')
{
printf("城市名称:");
gets(city[i]);
i++;
printf("继续输入(Y/N)");
scanf("%c",&flag);
getchar();
}
printf("\n");
if((fp=fopen("","wb"))==NULL)
{
printf("无法打开文件!\n");
return;
}
for(j=0;j<i;j++)
fprintf(fp,"%10s",city[j]);
fclose(fp);
}
void createplanefile()
{
int code,bt[2],at[2];
float money;
int i;
int count;
char vt[10],vh[10],flag;
FILE *fp;
flag='y';
count=0;
while(flag=='Y'||flag=='y')
{
printf("请输入飞机航班的信息:\n");
printf("飞机航班编号:");
scanf("%d",&code);
getchar();
printf("起始城市:");
gets(vt);
printf("目的城市:");
gets(vh);
printf("航班费用:");
scanf("%f",&money);
getchar();
printf("起飞时间:");
scanf("%d:%d",&bt[0],&bt[1]);
getchar();
while(bt[0]<0||bt[0]>=24||bt[1]<0||bt[1]>=60)
{
printf("\n时间输入有误，请重新输入\n");
scanf("%d:%d",&bt[0],&bt[1]);
getchar();
}
printf("到达时间:");
scanf("%d:%d",&at[0],&at[1]);
getchar();
while(at[0]<0||at[0]>=24||at[1]<0||at[1]>=60)
{
printf("\n时间输入有误，请重新输入\n");
scanf("%d:%d",&at[0],&at[1]);
getchar();
}
a[count].co=code;
strcpy(a[count].vt,vt);
strcpy(a[count].vh,vh);
a[count].bt[0]=bt[0];
a[count].bt[1]=bt[1];
a[count].at[0]=at[0];
a[count].at[1]=at[1];
a[count].mo=money;
count++;
printf("继续输入(Y/N)");
scanf("%c",&flag);
getchar();
printf("\n");
}
if((fp=fopen("","wb"))==NULL)
printf("\n无法打开文件!\n");
fprintf(fp,"%d",count);
for(i=0;i<count;i++)
if(fwrite(&a[i],sizeof(struct arc),1,fp)!=1)
printf("\n文件写入错误!\n");
fclose(fp);
}
void createtrainfile()
{
int code,bt[2],at[2];
float money;
int i;
int count;
char vt[10],vh[10],flag;
FILE *fp;
flag='y';
count=0;
while(flag=='y'||flag=='Y')
{
printf("请输入列车车次的信息:\n");
printf("列车车次编号:");
scanf("%d",&code);
getchar();
printf("起始城市:");
gets(vt);
printf("目的城市:");
gets(vh);
printf("车次费用:");
scanf("%f",&money);
getchar();
printf("发车时间:");
scanf("%d:%d",&bt[0],&bt[1]);
getchar();
while(bt[0]<0||bt[0]>=24||bt[1]<0||bt[1]>=60)
{
printf("\n时间输入有误，请重新输入\n");
scanf("%d:%d",&bt[0],&bt[1]);
getchar();
}
printf("到达时间:");
scanf("%d:%d",&at[0],&at[1]);
getchar();
while(at[0]<0||at[0]>=24||at[1]<0||at[1]>=60)
{
printf("\n时间输入有误，请重新输入\n");
scanf("%d:%d",&at[0],&at[1]);
getchar();
}
a[count].co=code;
strcpy(a[count].vt,vt);
strcpy(a[count].vh,vh);
a[count].bt[0]=bt[0];
a[count].bt[1]=bt[1];
a[count].at[0]=at[0];
a[count].at[1]=at[1];
a[count].mo=money;
count++;
printf("继续输入(Y/N)");
scanf("%c",&flag);
getchar();
printf("\n");
}
if((fp=fopen("","wb"))==NULL)
printf("\n无法打开文件!\n");
fprintf(fp,"%d",count);
for(i=0;i<count;i++)
if(fwrite(&a[i],sizeof(struct arc),1,fp)!=1)
printf("\n文件写入错误!\n");
fclose(fp);
}
int LocateVertex(ALGraph *G,char *v)
{
int j,k;
j=-1;
for(k=0;k<G->vexnum;k++)
if(strcmp(G->vertices[k].cityname,v)==0)
j=k;
break;
}
return(j);
}
void CreateGraph(ALGraph *G)
{
int i,j,k;
int arc_num;
int count1,count2;
int m,t;
ArcNode *p,*q;
FILE *fp;
i=0;
if((fp=fopen("","rb"))==NULL)
{
printf("\n无法打开文件!\n");
return;
}
while(!feof(fp))
{
fscanf(fp,"%10s",city[i]);
i++;
}
fclose(fp);
j=0;
while(j<i)
{
strcpy(G->vertices[j].cityname,city[j]);
G->vertices[j].planefirstarc=NULL;
G->vertices[j].trainfirstarc=NULL;
j++;
}
G->vexnum=i;
if((fp=fopen("","rb"))==NULL)
printf("\n无法打开文件!\n");
k=0;
fscanf(fp,"%d",&count1);
while(k<count1)
{
if(fread(&a[k],sizeof(struct arc),1,fp)!=1)
printf("\n文件读入错误!\n");
k++;
fclose(fp);
k=0;
arc_num=0;
while(k<count1)
{
i=LocateVertex(G,a[k].vt);
j=LocateVertex(G,a[k].vh);
q=G->vertices[i].planefirstarc;
m=0;
while(q!=NULL)
{
if(q->adjvex==j)
{
t=q->+1;
q->[t].number=a[k].co;
q->[t].expenditure=a[k].mo;
q->[t].begintime[0]=a[k].bt[0];
q->[t].begintime[1]=a[k].bt[1];
q->[t].arrivetime[0]=a[k].at[0];
q->[t].arrivetime[1]=a[k].at[1];
q->=t;
m=1;
break;
}
q=q->nextarc;
}
if(m==0)
{
p=(ArcNode*)malloc(sizeof(ArcNode));
p->adjvex=j;
p->[0].number=a[k].co;
p->[0].expenditure=a[k].mo;
p->[0].begintime[0]=a[k].bt[0];
p->[0].begintime[1]=a[k].bt[1];
p->[0].arrivetime[0]=a[k].at[0];
p->[0].arrivetime[1]=a[k].at[1];
p->=0;
p->nextarc=G->vertices[i].planefirstarc;
G->vertices[i].planefirstarc=p;
arc_num++;
}
k++;
}
G->planearcnum=arc_num;
if((fp=fopen("","rb"))==NULL)
{
printf("\n无法打开文件!\n");
return;
}
k=0;
fscanf(fp,"%d",&count2);
while(k<count2)
{
if(fread(&a[k],sizeof(struct arc),1,fp)!=1)
printf("\n文件读入错误!\n");
k++;
}
fclose(fp);
k=0;
arc_num=0;
while(k<count2)
{
i=LocateVertex(G,a[k].vt);
j=LocateVertex(G,a[k].vh);
q=G->vertices[i].trainfirstarc;
m=0;
while(q!=NULL)
{
if(q->adjvex==j)
{
t=q->+1;
q->[t].number=a[k].co;
q->[t].expenditure=a[k].mo;
q->[t].begintime[0]=a[k].bt[0];
q->[t].begintime[1]=a[k].bt[1];
q->[t].arrivetime[0]=a[k].at[0];
q->[t].arrivetime[1]=a[k].at[1];
q->=t;
m=1;
break;
}
q=q->nextarc;
}
if(m==0)
{
p=(ArcNode*)malloc(sizeof(ArcNode));
p->adjvex=j;
p->[0].number=a[k].co;
p->[0].expenditure=a[k].mo;
p->[0].begintime[0]=a[k].bt[0];
p->[0].begintime[1]=a[k].bt[1];
p->[0].arrivetime[0]=a[k].at[0];
p->[0].arrivetime[1]=a[k].at[1];
p->=0;
p->nextarc=G->vertices[i].trainfirstarc;
G->vertices[i].trainfirstarc=p;
arc_num++;
}
k++;
}
G->trainarcnum=arc_num;
}
int save(ALGraph *G)
{
int i,j,k,t;
ArcNode *q;
FILE *fp;
j=0;
while(j<G->vexnum)
{
strcpy(city[j],G->vertices[j].cityname);
j++;
}
i=0;
if((fp=fopen("","wb"))==NULL)
printf("\n错误,无法打开文件!\n");
while(i<G->vexnum)
{
fprintf(fp,"%10s",city[i]);
i++;
}
fclose(fp);
k=0;
for(i=0;i<G->vexnum;i++)
{
q=G->vertices[i].planefirstarc;
while(q!=NULL)
{
for(t=0;t<=q->;t++)
{
strcpy(a[k].vt,G->vertices[i].cityname);
strcpy(a[k].vh,G->vertices[q->adjvex].cityname);
a[k].co=q->[t].number;
a[k].mo=q->[t].expenditure;
a[k].bt[0]=q->[t].begintime[0];
a[k].bt[1]=q->[t].begintime[1];
a[k].at[0]=q->[t].arrivetime[0];
a[k].at[1]=q->[t].arrivetime[1];
k++;
}
q=q->nextarc;
}
}
if((fp=fopen("","wb"))==NULL)
{
printf("\n无法打开文件!\n");
return 0;
}
i=0;
fprintf(fp,"%d",k);
while(i<k)
{
if(fwrite(&a[i],sizeof(struct arc),1,fp)!=1)
printf("\n文件写入错误!\n");
i++;
}
fclose(fp);
k=0;
for(i=0;i<G->vexnum;i++)
{
q=G->vertices[i].trainfirstarc;
while(q!=NULL)
{
for(t=0;t<=q->;t++)
{
strcpy(a[k].vt,G->vertices[i].cityname);
strcpy(a[k].vh,G->vertices[q->adjvex].cityname);
a[k].co=q->[t].number;
a[k].mo=q->[t].expenditure;
a[k].bt[0]=q->[t].begintime[0];
a[k].bt[1]=q->[t].begintime[1];
a[k].at[0]=q->[t].arrivetime[0];
a[k].at[1]=q->[t].arrivetime[1];
k++;
}
q=q->nextarc;
}
}
if((fp=fopen("","wb"))==NULL)
{
printf("\n无法打开文件!\n");
return 0;
}
i=0;
fprintf(fp,"%d",k);
while(i<k)
{
if(fwrite(&a[i],sizeof(struct arc),1,fp)!=1)
printf("\n文件写入错误!\n");
i++;
}
fclose(fp);
return 1;
}
void cityedit(ALGraph *G)
{
int i;
printf("\n请选择城市编辑项目:\n");
printf("1=增加城市\n2=删除城市\n");
printf("选择");
scanf("%d",&i);
getchar();
if(i==1)
EnterVertex(G);
if(i==2)
DeleteVertex(G);
}
void EnterVertex(ALGraph *G)
{
char v[10],c;
int i;
printf("\n请输入新增城市的名称:");
gets(v);
i=LocateVertex(G,v);
if(i>=0&&i<G->vexnum)
{
printf("\n错误！此城市已存在\n");
return;
}
else
{
printf("\n确认(Y/N)");
c=getchar();
getchar();
if(c=='Y'||c=='y')
{
i=G->vexnum;
strcpy(G->vertices[i].cityname,v);
G->vertices[i].planefirstarc=NULL;
G->vertices[i].trainfirstarc=NULL;
G->vexnum=i+1;
save(G);
}
else
return;
}
}
void DeleteVertex(ALGraph *G)
{
int i,j,k,n;
char v[10],c;
ArcNode *p,*q,*m;
printf("\n请输入删除的城市:");
gets(v);
printf("\n确认(Y/N)");
c=getchar();
getchar();
if(c=='Y'||c=='y')
{
n=0;
while(n<G->vexnum&&strcmp(G->vertices[n].cityname,v)!=0) n++;
if(n==G->vexnum)
printf("\n错误！无法找到此城市!\n");
else
{
i=LocateVertex(G,v);
p=G->vertices[i].planefirstarc;
while(p!=NULL)
{
q=p;
p=p->nextarc;
free(q);
}
p=G->vertices[i].trainfirstarc;
while(p!=NULL)
{
q=p;
p=p->nextarc;
free(q);
}
for(j=i;j<G->vexnum-1;j++)
{
strcpy(G->vertices[j].cityname,G->vertices[j+1].cityname);
G->vertices[j].planefirstarc=G->vertices[j+1].planefirstarc;
G->vertices[j].trainfirstarc=G->vertices[j+1].trainfirstarc; }
G->vertices[j].planefirstarc=NULL;
G->vertices[j].trainfirstarc=NULL;
for(k=0;k<G->vexnum-1;k++)
{
p=G->vertices[k].planefirstarc;
while(p!=NULL)
{
if(p->adjvex>i)
{
p->adjvex=p->adjvex-1;
q=p;
p=p->nextarc;
}
else if(p->adjvex==i)
{
if(p==G->vertices[k].planefirstarc)
{
m=p;
G->vertices[k].planefirstarc=p->nextarc;
p=p->nextarc;
free(m);
}
else
{
q->nextarc=p->nextarc;
m=p;
p=p->nextarc;
free(q);
}
}
else
{
q=p;
p=p->nextarc;
}
}
}
for(k=0;k<G->vexnum-1;k++)
{
p=G->vertices[k].trainfirstarc;
while(p!=NULL)
{
if(p->adjvex>i)
{
p->adjvex=p->adjvex-1;
q=p;
p=p->nextarc;
}
else if(p->adjvex==i)
{
if(p==G->vertices[k].trainfirstarc)
{
m=p;
G->vertices[k].trainfirstarc=p->nextarc;
p=p->nextarc;
free(m);
}
else
{
q->nextarc=p->nextarc;
m=p;
p=p->nextarc;
free(q);
}
}
else
{
q=p;
p=p->nextarc;
}
}
}
}
G->vexnum--;
save(G);
}
else
return;
}
void flightedit(ALGraph *G)
{
int i;
printf("\n请选择飞机航班编辑项目:\n");
printf("1=新增航班\n2=删除航班\n");
printf("选择");
scanf("%d",&i);
getchar();
if(i==1)
EnterplaneArc(G);
if(i==2)
DeleteplaneArc(G);
}
void trainedit(ALGraph *G)
{
int i;
printf("\n请选择列车车次编辑项目:\n");
printf("1=新增车次\n2=删除车次\n");
printf("选择");
scanf("%d",&i);
getchar();
if(i==1)
EntertrainArc(G);
if(i==2)
DeletetrainArc(G);
}
void EnterplaneArc(ALGraph *G)
{
int i,j,bt[2],at[2];
int code;
float money;
int m,t;
char vt[10],vh[10],c;
ArcNode *p,*q;
printf("\n请输入新增飞机航班的信息:\n");
printf("飞机航班编号:");
scanf("%d",&code);
getchar();
printf("起始城市:");
printf("目的城市:");
gets(vh);
printf("航班费用:");
scanf("%f",&money);
getchar();
printf("起飞时间:");
scanf("%d:%d",&bt[0],&bt[1]);
getchar();
while(bt[0]<0||bt[0]>=24||bt[1]<0||bt[1]>=60)
{
printf("\n时间输入有误，请重新输入\n");
scanf("%d:%d",&bt[0],&bt[1]);
getchar();
}
printf("到达时间:");
scanf("%d:%d",&at[0],&at[1]);
getchar();
while(at[0]<0||at[0]>=24||at[1]<0||at[1]>=60)
{
printf("\n时间输入有误，请重新输入\n");
scanf("%d:%d",&at[0],&at[1]);
getchar();
}
printf("\n确认(Y/N)");
c=getchar();
getchar();
if(c=='Y'||c=='y')
{
i=LocateVertex(G,vt);
j=LocateVertex(G,vh);
if(i==-1)
{
printf("\n错误！无法找到起始城市\n");
return;
}
if(j==-1)
{
printf("\n错误！无法找到到达城市\n");
return;
}
q=G->vertices[i].planefirstarc;
m=0;
while(q!=NULL)
if(q->adjvex==j)
{
t=q->+1;
q->[t].number=code;
q->[t].expenditure=money;
q->[t].begintime[0]=bt[0];
q->[t].begintime[1]=bt[1];
q->[t].arrivetime[0]=at[0];
q->[t].arrivetime[1]=at[1];
q->=t;
m=1;
break;
}
q=q->nextarc;
}
if(m==0)
{
p=(ArcNode*)malloc(sizeof(ArcNode));
p->adjvex=j;
p->[0].number=code;
p->[0].expenditure=money;
p->[0].begintime[0]=bt[0];
p->[0].begintime[1]=bt[1];
p->[0].arrivetime[0]=at[0];
p->[0].arrivetime[1]=at[1];
p->=0;
p->nextarc=G->vertices[i].planefirstarc;
G->vertices[i].planefirstarc=p;
G->planearcnum++;
}
save(G);
}
else
return;
}
void EntertrainArc(ALGraph *G)
{
int i,j,bt[2],at[2];
int code;
float money;
int m,t;
char vt[10],vh[10],c;
ArcNode *p,*q;
printf("\n请输入新增列车车次的信息:\n"); printf("列车车次编号:");
scanf("%d",&code);
getchar();
printf("起始城市:");
gets(vt);
printf("目的城市:");
gets(vh);
printf("车次费用:");
scanf("%f",&money);
getchar();
printf("发车时间:");
scanf("%d:%d",&bt[0],&bt[1]);
getchar();
while(bt[0]<0||bt[0]>=24||bt[1]<0||bt[1]>=60)
{
printf("\n时间输入有误，请重新输入\n");
scanf("%d:%d",&bt[0],&bt[1]);
getchar();
}
printf("到达时间:");
scanf("%d:%d",&at[0],&at[1]);
getchar();
while(at[0]<0||at[0]>=24||at[1]<0||at[1]>=60)
{
printf("\n时间输入有误，请重新输入\n");
scanf("%d:%d",&at[0],&at[1]);
getchar();
}
printf("\n确认(Y/N)");
c=getchar();
getchar();
if(c=='Y'||c=='y')
{
i=LocateVertex(G,vt);
j=LocateVertex(G,vh);
if(i==-1)
{
printf("\n错误！无法找到起始城市\n");
return;
}
if(j==-1)
{
printf("\n错误！无法找到到达城市\n");
return;
}
q=G->vertices[i].trainfirstarc;
m=0;
while(q!=NULL)
{
if(q->adjvex==j)
{
t=q->+1;
q->[t].number=code;
q->[t].expenditure=money;
q->[t].begintime[0]=bt[0];
q->[t].begintime[1]=bt[1];
q->[t].arrivetime[0]=at[0];
q->[t].arrivetime[1]=at[1];
q->=t;
m=1;
break;
}
q=q->nextarc;
}
if(m==0)
{
p=(ArcNode*)malloc(sizeof(ArcNode));
p->adjvex=j;。