全国铁路运输网最佳经由问题数据结构课程设计1

合集下载

数据结构关于物流配送路径最优问题的课程设计报告

“数据结构”课程设计报告物流配送中的最优路径规划模拟软件学生姓名：指导教师：所在系：电子信息系所学专业：计算机科学与技术年级：2011级计算机（ 2 ）班2013年6月13日摘要：通过对路径寻优问题的探讨分析，合理选取城市物流配送模式，结合物流配送的一般实际情况，确定较好的解决城市物流配送的路径寻优问题的最为关键一步就是解决末级配送中心的最优配送路线问题；然后深入剖析了影响配送的各种因素，建立基于费用成本，时间最少，距离最近为一体的最优配送路径的配送系统数学模型。

关键词：物流配送路径最优数学模型目录目录 (3)第一章需求分析 (4)第二章概要分析 (5)1、最短路径分析 (5)2、最短时间分析 (6)3、最少费用分析 (6)第三章系统代码 (7)第四章系统调试 (20)1、查看城市 (20)2、最短路径查询 (20)3、最短时间查询 (21)4、最少费用查询 (21)5、退出系统 (22)第五章系统分析与运行环境 (23)第六章实验小结 (24)参考文献 (25)随着市场经济的发展和物流技术专业化水平的提高，物流配送业得到了迅猛发展。

配送路径的选择是否合理，对加快配送速度、提高服务质量、降低配送成本及增加经济效益都有较大影响。

配送路径的优化问题是物流配送系统的一个主要问题，物流配送路径的优化就是以最低的运营成本、最快捷的响应速度、最短的配送运输时间，把货物运至用户手中。

物流车装载当日需要配送的货品从仓库出发，按照事先规划好的最优配送路径为每一个客户进行配送。

IT系统在配送之前需要根据客户的配送地址间线路间距、经验路况做分析计算出一条最优配送路径。

本题要求利用c语言设计一套模拟软件，使物流公司可以按照最短路程、最短时间及最少费用的策略生成配送方案，并在软件界面上模拟车辆的行进。

1、最短路径分析图12、最短时间分析图2 3、最少费用分析第三章系统代码/*物流配送路径最优程序模拟*/#include"string.h"#include"stdio.h"#include "math.h"typedef struct ArcCell{int adj;//相邻接的城市序号}ArcCell;//定义边的类型typedef struct vertextype{int number;//城市序号char *city;//城市名称}VertexType;//定义顶点的类型typedef struct{VertexType vex[12];//图中的顶点，即为城市ArcCell arcs[12][12];//图中的边，即为城市的距离ArcCell prices[12][12];//图中的第二边，即为城市的费用ArcCell times[12][12];//图中的第三边，即为城市的时间int vexnum,arcnum,pricenum,timenum;}MGraph;//定义图的类型MGraph G;//把图定义为全局变量int P[12][12];long int D[12];void CreateUDN1(v,p)//造图函数int v,p;{int m,n;G.vexnum=v;G.pricenum=p;for(m=0;m<G.vexnum;++m)G.vex[m].number=m;//下边是城市名G.vex[0].city="芜湖";G.vex[1].city="巢湖";G.vex[2].city="宿州";G.vex[3].city="合肥";G.vex[4].city="铜陵";G.vex[5].city="淮北";G.vex[6].city="亳州";G.vex[7].city="蚌埠";G.vex[8].city="滁州";G.vex[9].city="淮南";G.vex[10].city="阜阳";G.vex[11].city="池州";//这里把所有的边假定为20000，含义是城市间不可到达for(m=0;m<G.vexnum;++m)for(n=0;n<G.vexnum;++n)G.prices[m][n].adj=20000;//下边是可直接到达的城市间的费用，由于两个城市间的费用是相互的，所以要对图中对称的边同时赋值G.prices[0][1].adj=G.prices[1][0].adj=13;G.prices[0][2].adj=G.prices[2][0].adj=54;G.prices[0][3].adj=G.prices[3][0].adj=24;G.prices[0][4].adj=G.prices[4][0].adj=7;G.prices[0][5].adj=G.prices[5][0].adj=36;G.prices[0][6].adj=G.prices[6][0].adj=62;G.prices[0][7].adj=G.prices[7][0].adj=47;G.prices[0][8].adj=G.prices[8][0].adj=29;G.prices[0][9].adj=G.prices[9][0].adj=38;G.prices[0][10].adj=G.prices[10][0].adj=54;G.prices[0][11].adj=G.prices[11][0].adj=23;G.prices[1][2].adj=G.prices[2][1].adj=44;G.prices[1][3].adj=G.prices[3][1].adj=13;G.prices[1][4].adj=G.prices[4][1].adj=14;G.prices[1][5].adj=G.prices[5][1].adj=29;G.prices[1][6].adj=G.prices[6][1].adj=55;G.prices[1][7].adj=G.prices[7][1].adj=30;G.prices[1][8].adj=G.prices[8][1].adj=42;G.prices[1][9].adj=G.prices[9][1].adj=24;G.prices[1][10].adj=G.prices[10][1].adj=44;G.prices[1][11].adj=G.prices[11][1].adj=19;G.prices[2][3].adj=G.prices[3][2].adj=38;G.prices[2][4].adj=G.prices[4][2].adj=42;G.prices[2][5].adj=G.prices[5][2].adj=12;G.prices[2][6].adj=G.prices[6][2].adj=26;G.prices[2][7].adj=G.prices[7][2].adj=15;G.prices[2][8].adj=G.prices[8][2].adj=33;G.prices[2][9].adj=G.prices[9][2].adj=30;G.prices[2][10].adj=G.prices[10][2].adj=15;G.prices[2][11].adj=G.prices[11][2].adj=50;G.prices[3][4].adj=G.prices[4][3].adj=19;G.prices[3][5].adj=G.prices[5][3].adj=42;G.prices[3][6].adj=G.prices[6][3].adj=25;G.prices[3][7].adj=G.prices[7][3].adj=22;G.prices[3][8].adj=G.prices[8][3].adj=64;G.prices[3][9].adj=G.prices[9][3].adj=16;G.prices[3][10].adj=G.prices[10][3].adj=38;G.prices[3][11].adj=G.prices[11][3].adj=24;G.prices[4][5].adj=G.prices[5][4].adj=50; G.prices[4][6].adj=G.prices[6][4].adj=74; G.prices[4][7].adj=G.prices[7][4].adj=22; G.prices[4][8].adj=G.prices[8][4].adj=55; G.prices[4][9].adj=G.prices[9][4].adj=22; G.prices[4][10].adj=G.prices[10][4].adj=37;G.prices[4][11].adj=G.prices[11][4].adj=6; G.prices[5][6].adj=G.prices[6][5].adj=15; G.prices[5][7].adj=G.prices[7][5].adj=22; G.prices[5][8].adj=G.prices[8][5].adj=42; G.prices[5][9].adj=G.prices[9][5].adj=44; G.prices[5][10].adj=G.prices[10][5].adj=25;G.prices[5][11].adj=G.prices[11][5].adj=36;G.prices[6][7].adj=G.prices[7][6].adj=47; G.prices[6][8].adj=G.prices[8][6].adj=65; G.prices[6][9].adj=G.prices[9][6].adj=38; G.prices[6][10].adj=G.prices[10][6].adj=17;G.prices[6][11].adj=G.prices[11][6].adj=42;G.prices[7][8].adj=G.prices[8][7].adj=20; G.prices[7][9].adj=G.prices[9][7].adj=15; G.prices[7][10].adj=G.prices[10][7].adj=33;G.prices[7][11].adj=G.prices[11][7].adj=42;G.prices[8][9].adj=G.prices[9][8].adj=33; G.prices[8][10].adj=G.prices[10][8].adj=47;G.prices[8][11].adj=G.prices[11][8].adj=89;G.prices[9][10].adj=G.prices[10][9].adj=10;G.prices[9][11].adj=G.prices[11][9].adj=54;G.prices[10][11].adj=G.prices[11][10].adj=72; }void CreateUDN2(v,t)//造图函数int v,t;{int m,n;G.vexnum=v;G.pricenum=t;for(m=0;m<G.vexnum;++m)G.vex[m].number=m;//下边是城市名G.vex[0].city="芜湖";G.vex[1].city="巢湖";G.vex[2].city="宿州";G.vex[3].city="合肥";G.vex[4].city="铜陵";G.vex[5].city="淮北";G.vex[6].city="亳州";G.vex[7].city="蚌埠";G.vex[8].city="滁州";G.vex[9].city="淮南";G.vex[10].city="阜阳";G.vex[11].city="池州";//这里把所有的边假定为20000，含义是城市间不可到达for(m=0;m<G.vexnum;++m)for(n=0;n<G.vexnum;++n)G.times[m][n].adj=20000;//下边是可直接到达的城市间的时间，由于两个城市间的时间是相互的，所以要对图中对称的边同时赋值G.times[0][1].adj=G.times[1][0].adj=54;G.times[0][2].adj=G.times[2][0].adj=314;G.times[0][3].adj=G.times[3][0].adj=114;G.times[0][4].adj=G.times[4][0].adj=81;G.times[0][5].adj=G.times[5][0].adj=494;G.times[0][6].adj=G.times[6][0].adj=391;G.times[0][7].adj=G.times[7][0].adj=246;G.times[0][8].adj=G.times[8][0].adj=159;G.times[0][9].adj=G.times[9][0].adj=205;G.times[0][10].adj=G.times[10][0].adj=309;G.times[0][11].adj=G.times[11][0].adj=120;G.times[1][2].adj=G.times[2][1].adj=285;G.times[1][3].adj=G.times[3][1].adj=88;G.times[1][4].adj=G.times[4][1].adj=176;G.times[1][5].adj=G.times[5][1].adj=349;G.times[1][6].adj=G.times[6][1].adj=332;G.times[1][7].adj=G.times[7][1].adj=187;G.times[1][8].adj=G.times[8][1].adj=273;G.times[1][9].adj=G.times[9][1].adj=171;G.times[1][10].adj=G.times[10][1].adj=288;G.times[1][11].adj=G.times[11][1].adj=228;G.times[2][3].adj=G.times[3][2].adj=224;G.times[2][4].adj=G.times[4][2].adj=298;G.times[2][5].adj=G.times[5][2].adj=50;G.times[2][6].adj=G.times[6][2].adj=255;G.times[2][7].adj=G.times[7][2].adj=60;G.times[2][8].adj=G.times[8][2].adj=152;G.times[2][9].adj=G.times[9][2].adj=182;G.times[2][10].adj=G.times[10][2].adj=173;G.times[2][11].adj=G.times[11][2].adj=350;G.times[3][4].adj=G.times[4][3].adj=229;G.times[3][5].adj=G.times[5][3].adj=283;G.times[3][6].adj=G.times[6][3].adj=240;G.times[3][7].adj=G.times[7][3].adj=109;G.times[3][8].adj=G.times[8][3].adj=73;G.times[3][9].adj=G.times[9][3].adj=71;G.times[3][10].adj=G.times[10][3].adj=165;G.times[3][11].adj=G.times[11][3].adj=251;G.times[4][5].adj=G.times[5][4].adj=416; G.times[4][6].adj=G.times[6][4].adj=453; G.times[4][7].adj=G.times[7][4].adj=380; G.times[4][8].adj=G.times[8][4].adj=240; G.times[4][9].adj=G.times[9][4].adj=331; G.times[4][10].adj=G.times[10][4].adj=424;G.times[4][11].adj=G.times[11][4].adj=56; G.times[5][6].adj=G.times[6][5].adj=205; G.times[5][7].adj=G.times[7][5].adj=125; G.times[5][8].adj=G.times[8][5].adj=231; G.times[5][9].adj=G.times[9][5].adj=245; G.times[5][10].adj=G.times[10][5].adj=145;G.times[5][11].adj=G.times[11][5].adj=515;G.times[6][7].adj=G.times[7][6].adj=271; G.times[6][8].adj=G.times[8][6].adj=369; G.times[6][9].adj=G.times[9][6].adj=174; G.times[6][10].adj=G.times[10][6].adj=68; G.times[6][11].adj=G.times[11][6].adj=515;G.times[7][8].adj=G.times[8][7].adj=33;G.times[7][9].adj=G.times[9][7].adj=99;G.times[7][10].adj=G.times[10][7].adj=192;G.times[7][11].adj=G.times[11][7].adj=331;G.times[8][9].adj=G.times[9][8].adj=201; G.times[8][10].adj=G.times[10][8].adj=321;G.times[8][11].adj=G.times[11][8].adj=265;G.times[9][10].adj=G.times[10][9].adj=89; G.times[9][11].adj=G.times[11][9].adj=382;G.times[10][11].adj=G.times[11][10].adj=485; }void CreateUDN(v,a)//造图函数int v,a;{int i,j;G.vexnum=v;G.arcnum=a;for(i=0;i<G.vexnum;++i)G.vex[i].number=i;//下边是城市名G.vex[0].city="芜湖";G.vex[1].city="巢湖";G.vex[2].city="宿州";G.vex[3].city="合肥";G.vex[4].city="铜陵";G.vex[6].city="亳州";G.vex[7].city="蚌埠";G.vex[8].city="滁州";G.vex[9].city="淮南";G.vex[10].city="阜阳";G.vex[11].city="池州";//这里把所有的边假定为20000，含义是城市间不可到达for(i=0;i<G.vexnum;++i)for(j=0;j<G.vexnum;++j)G.arcs[i][j].adj=20000;//下边是可直接到达的城市间的距离，由于两个城市间的距离是相互的，所以要对图中对称的边同时赋值G.arcs[0][1].adj=G.arcs[1][0].adj=77;G.arcs[0][2].adj=G.arcs[2][0].adj=399;G.arcs[0][3].adj=G.arcs[3][0].adj=141;G.arcs[0][4].adj=G.arcs[4][0].adj=78;G.arcs[0][5].adj=G.arcs[5][0].adj=523;G.arcs[0][6].adj=G.arcs[6][0].adj=466;G.arcs[0][7].adj=G.arcs[7][0].adj=309;G.arcs[0][8].adj=G.arcs[8][0].adj=182;G.arcs[0][9].adj=G.arcs[9][0].adj=236;G.arcs[0][10].adj=G.arcs[10][0].adj=362;G.arcs[0][11].adj=G.arcs[11][0].adj=135;G.arcs[1][2].adj=G.arcs[2][1].adj=285;G.arcs[1][3].adj=G.arcs[3][1].adj=64;G.arcs[1][4].adj=G.arcs[4][1].adj=155;G.arcs[1][5].adj=G.arcs[5][1].adj=446;G.arcs[1][6].adj=G.arcs[6][1].adj=389;G.arcs[1][7].adj=G.arcs[7][1].adj=195;G.arcs[1][8].adj=G.arcs[8][1].adj=258;G.arcs[1][9].adj=G.arcs[9][1].adj=159;G.arcs[1][10].adj=G.arcs[10][1].adj=285;G.arcs[1][11].adj=G.arcs[11][1].adj=212;G.arcs[2][3].adj=G.arcs[3][2].adj=221;G.arcs[2][4].adj=G.arcs[4][2].adj=440;G.arcs[2][5].adj=G.arcs[5][2].adj=52;G.arcs[2][6].adj=G.arcs[6][2].adj=289;G.arcs[2][7].adj=G.arcs[7][2].adj=90;G.arcs[2][8].adj=G.arcs[8][2].adj=217;G.arcs[2][9].adj=G.arcs[9][2].adj=176;G.arcs[2][10].adj=G.arcs[10][2].adj=185;G.arcs[2][11].adj=G.arcs[11][2].adj=497;G.arcs[3][4].adj=G.arcs[4][3].adj=219;G.arcs[3][5].adj=G.arcs[5][3].adj=382;G.arcs[3][6].adj=G.arcs[6][3].adj=325;G.arcs[3][8].adj=G.arcs[8][3].adj=213;G.arcs[3][9].adj=G.arcs[9][3].adj=95;G.arcs[3][10].adj=G.arcs[10][3].adj=221;G.arcs[3][11].adj=G.arcs[11][3].adj=276;G.arcs[4][5].adj=G.arcs[5][4].adj=492;G.arcs[4][6].adj=G.arcs[6][4].adj=544;G.arcs[4][7].adj=G.arcs[7][4].adj=350;G.arcs[4][8].adj=G.arcs[8][4].adj=234;G.arcs[4][9].adj=G.arcs[9][4].adj=314;G.arcs[4][10].adj=G.arcs[10][4].adj=440;G.arcs[4][11].adj=G.arcs[11][4].adj=57;G.arcs[5][6].adj=G.arcs[6][5].adj=265;G.arcs[5][7].adj=G.arcs[7][5].adj=142;G.arcs[5][8].adj=G.arcs[8][5].adj=269;G.arcs[5][9].adj=G.arcs[9][5].adj=287;G.arcs[5][10].adj=G.arcs[10][5].adj=161;G.arcs[5][11].adj=G.arcs[11][5].adj=549;G.arcs[6][7].adj=G.arcs[7][6].adj=316;G.arcs[6][8].adj=G.arcs[8][6].adj=443;G.arcs[6][9].adj=G.arcs[9][6].adj=230;G.arcs[6][10].adj=G.arcs[10][6].adj=104;G.arcs[6][11].adj=G.arcs[11][6].adj=601;G.arcs[7][8].adj=G.arcs[8][7].adj=127;G.arcs[7][9].adj=G.arcs[9][7].adj=86;G.arcs[7][10].adj=G.arcs[10][7].adj=212;G.arcs[7][11].adj=G.arcs[11][7].adj=407;G.arcs[8][9].adj=G.arcs[9][8].adj=737;G.arcs[8][10].adj=G.arcs[10][8].adj=399;G.arcs[8][11].adj=G.arcs[11][8].adj=281;G.arcs[9][10].adj=G.arcs[10][9].adj=126;G.arcs[9][11].adj=G.arcs[11][9].adj=299;G.arcs[10][11].adj=G.arcs[11][10].adj=497;}void narrate()//说明函数{int i,k=0;//printf("\n********************欢迎使用最优路径程序！********************\n"); printf("\n城市列表如下:\n\n");for(i=0;i<12;i++){printf("(%2d)%-10s",i,G.vex[i].city);//输出城市列表k=k+1;if(k%4==0)printf("\n");}}int Num;{int v,w,i,t;int final[12];int min;for(v=0;v<12;++v){final[v]=0;D[v]=G.prices[Num][v].adj;for(w=0;w<12;++w)P[v][w]=0;if(D[v]<20000){P[v][Num]=1;P[v][v]=1;}}D[Num]=0;final[Num]=1;for(i=0;i<12;++i){min=20000;for(w=0;w<12;++w)if(!final[w])if(D[w]<min){v=w;min=D[w];}final[v]=1;for(w=0;w<12;++w)if(!final[w]&&((min+G.prices[v][w].adj)<D[w])){D[w]=min+G.prices[v][w].adj;for(t=0;t<12;t++)P[w][t]=P[v][t];P[w][w]=1;}}}void output1(city1,city2)//输出函数int city1;int city2;{int a,b,c,d,q=0;a=city2;if(a!=city1){printf("\n 从%s到%s的最少费用路径是",G.vex[city1].city,G.vex[city2].city); printf("(最少费用为%dRMB.)\n\t",D[a]);printf("%s",G.vex[city1].city);d=city1;for(c=0;c<12;++c){gate:;/*标号，可以作为goto语句跳转的位置*/P[a][city1]=0;for(b=0;b<12;b++)if(G.prices[d][b].adj<20000&&P[a][b]){printf("-->%s",G.vex[b].city);q=q+1;P[a][b]=0;d=b;if(q%8==0)printf("\n");goto gate;}}}}}void ShortestTime(Number)//最短时间函数int Number;{int v,w,i,t;int final[12];int min;for(v=0;v<12;++v){final[v]=0;D[v]=G.times[Number][v].adj; for(w=0;w<12;++w)P[v][w]=0;if(D[v]<20000){P[v][Number]=1;P[v][v]=1;} }D[Number]=0;final[Number]=1;for(i=0;i<12;++i){min=20000;for(w=0;w<12;++w)if(!final[w])if(D[w]<min){v=w;min=D[w];}final[v]=1;for(w=0;w<12;++w)if(!final[w]&&((min+G.times[v][w].adj)<D[w])) {D[w]=min+G.times[v][w].adj;for(t=0;t<12;t++)P[w][t]=P[v][t];P[w][w]=1;}}}void output2(city1,city2)//输出函数int city1;int city2;{int a,b,c,d,q=0;a=city2;if(a!=city1)printf("\n 从%s到%s的最少时间路径是",G.vex[city1].city,G.vex[city2].city); if(D[a]/60==0)printf("(最少时间为%dminutes.)\n\t",D[a]);//if(D[a]/60!=0)elseprintf("(最少时间为%dh %dmin.)\n\t",D[a]/60,D[a]%60);printf("%s",G.vex[city1].city);d=city1;for(c=0;c<12;++c){gate:;/*标号，可以作为goto语句跳转的位置*/P[a][city1]=0;for(b=0;b<12;b++){if(G.times[d][b].adj<20000&&P[a][b]){printf("-->%s",G.vex[b].city);q=q+1;P[a][b]=0;d=b;if(q%8==0)printf("\n");goto gate;}}}}}void ShortestPath(num)//最短路径函数int num;{int v,w,i,t;int final[12];int min;for(v=0;v<12;++v){final[v]=0;D[v]=G.arcs[num][v].adj;for(w=0;w<12;++w)P[v][w]=0;if(D[v]<20000){P[v][num]=1;P[v][v]=1;}}D[num]=0;final[num]=1;for(i=0;i<12;++i){min=20000;for(w=0;w<12;++w)if(!final[w])if(D[w]<min){v=w;min=D[w];}final[v]=1;for(w=0;w<12;++w){D[w]=min+G.arcs[v][w].adj;for(t=0;t<12;t++)P[w][t]=P[v][t];P[w][w]=1;}}}void output(city1,city2)//输出函数int city1;int city2;{int a,b,c,d,q=0;a=city2;if(a!=city1){printf("\n 从%s到%s的最短路径是",G.vex[city1].city,G.vex[city2].city); printf("(最短路径为%dkm.)\n\t",D[a]);printf("%s",G.vex[city1].city);d=city1;for(c=0;c<12;++c){gate:;/*标号，可以作为goto语句跳转的位置*/P[a][city1]=0;for(b=0;b<12;b++){if(G.arcs[d][b].adj<20000&&P[a][b]){printf("-->%s",G.vex[b].city);q=q+1;P[a][b]=0;d=b;if(q%8==0)printf("\n");goto gate;}}}}}int main()/*主函数*/{int v0,v1;int a;int type ;int run = 1;CreateUDN(12,66);CreateUDN1(12,66);CreateUDN2(12,66);printf(" 最优路径解决方法:\n");printf("***************************************\n"" 1.查看城市\n"" 3.按最短时间查询\n"" 4.按最少费用查询\n"" 5.退出系统\n""***************************************\n" ); do{printf("请输入您需要服务的项目：");scanf("%d", &type);switch(type){case 1:narrate();break;case 2:printf("\n\n请选择起点城市(0~11):");scanf("%d",&v0);printf("\n");printf("\n\n请选择终点城市(0~11):");scanf("%d",&v1);printf("\n");ShortestPath(v0); /*计算两个城市之间的最短路径*/output(v0,v1); /*输出结果*/printf("\n");break;case 3:printf("\n\n请选择起点城市(0~11):");scanf("%d",&v0);printf("\n");printf("\n\n请选择终点城市(0~11):");scanf("%d",&v1);printf("\n");ShortestTime(v0); /*计算两个城市之间的最短时间*/ output2(v0,v1); /*输出结果*/printf("\n");break;case 4:printf("\n\n请选择起点城市(0~11):");scanf("%d",&v0);printf("\n");printf("\n\n请选择终点城市(0~11):");scanf("%d",&v1);printf("\n");ShortestPrice(v0); /*计算两个城市之间的最少费用*/ output1(v0,v1); /*输出结果*/printf("\n");break;case 5:getchar();printf("你确定退出吗？(y/n)");a = getchar();switch(a){case 'y':run = 0;break;case 'n':run = 1;break;default:break;}if((a == 'y') || (a == 'n')) break; } break;getchar();}}while(run);return 0;}第四章系统调试1、查看城市图4 查看城市2、最短路径查询图5 最短路径查询3、最短时间查询图6 最短时间查询4、最少费用查询图7 最少费用查询5、退出系统图8 退出系统第五章系统分析与运行环境物流配送路径最优系统专注于商品的发货、运输、到货等作业的计划、控制和反馈过程的信息搜集、汇总、查询和分析，达到提高物流配送效率，降低物流配送成本的目的。

数据结构课程设计—城市道路交通咨询系统【范本模板】

(1）进入程序后，用户可自己设置城市的个数，以及所有城市之间总共的路径，且分别用顶点和边表示城市与路径
（2）用户根据自己设置的城市个数和路径数,具体输入每个路径的起始点以及每条路径的长度。
（3)进入菜单选择界面
（4）选择2,系统为用户进行提供任意城市的交通查询,即查询任意两个城市之间的一条最短路径。
基本思想：设G（V，E)是一个带权有向图，把图中的顶点集合V分成两组,第一组为已经求出的最短路径的顶点集合（用S表示，初始时S中只有一个原点，以后每求得一条最短路径就加入的集合S中，知道全部顶点都加入到集合中)，第二组，为其余未确定最短路径的顶点集合（用U表示），按最短路径长度的递增次序依次把第二组的顶点就如S中。如果两个顶点之间有权值，并且各个路径的权值不同,就把最小的作为顶点与顶点的最短距离.
3．定义一个Floyd函数
void Floyd(MGraph＊G，int n);
2
图2—2
邻接矩阵构造图结构函数
数据类型定义:
typedef struct
{
VertexTypevexs[MAX];
Adjmatrix arcs[MAX][MAX］;
}MGraph；
void CreateMGraph(MGraph *G,int n，int e)//邻接矩阵构成有向图
这次在应用中,我发现了自己的很多不足，在编写城市交通咨询系统的过程中，自己C语言方面的只是掌握太少，很多功能需求只能退而求其次,一次又一次的更改，一次又一次的失败，也终于是在最后也完成了自己的要求，同时我也知道了平时用功学习的重要性。尤其是在日常学习之中，对于单一的只是点也许掌握的还不错，但是自己动手太少,实践经验严重不足，且面临课程设计之时，要求多方面的只是结和编码，对于我而言还是有很大的难度的。如此次对于邻接矩阵的存储于读取，以及最短路径算法的实现，两个及其重要的算法,狄克斯特拉算法和佛洛依德算法，在具体的应用上还是有很多不足。

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

太原工业学院计算机工程系数据结构课程设计设计题目：全国交通网络咨询系统1班级：计算机科学与技术学号：**********名：**指导教师：***年月日目录一、课程设计题目 (1)二、需求分析 (1)三、测试数据 (2)四、概要设计 (2)五、调用关系图 (3)六、程序代码 (3)七、测试结果 (14)八、心得体会及总结 (14)数据结构课程设计一、课程设计题目全国交通网络咨询系统二、需求分析1、实现功能对城市信息(城市名、城市间的里程)进行编辑：具备添加、修改、删除功能；对城市间的交通工具：火车。

对列车时刻表进行编辑：里程、和列车班次的添加、修改、删除；提供两种最优决策：最快到达或最省钱到达。

全程只考虑一种交通工具，可以不考虑回程；咨询以用户和计算机对话方式进行，要注意人机交互的屏幕界面。

由用户选择最优决策原则和交通工具，输入起始站、终点站、出发时间，输出信息：最快需要多长时间才能到达及旅费，或者最少需要多少旅费才能到达及时间，并详细说明依次于何时何地乘坐哪一趟列车何时到达何地。

2、设计思路（1) 数据存储。

城市信息(城市名、代码)、交通信息(城市间的里程、各航班和列车时刻)存储于磁盘文件。

在实验中本想用文本储存数据，但操作不熟悉，而是改用图的邻接矩阵储存原始信息，而后用数组进行添加删改(2) 数据的逻辑结构。

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

(3) 数据的存储结构。

采用邻接表和邻接矩阵都可作为数据的存储结构，这里建议采用邻接矩阵作为数据的存储结构。

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

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

只要能方便的对城市信息和交通信息进行管理即可，但要注意人机界面，具体实现由学生自行设计，也可参考有关程序(届时在网上提供)。

这些工作有不小的工作量。

数据结构课程设计全国交通咨询系统方案

工业应用技术学院课程设计任务书题目全国交通资询系统主要容：设计了一个方便用户查询交通咨询系统。

该系统所做的工作的是模拟全国交通咨询，为旅客提供三种最优决策的交通咨询。

该系统可以进行城市，列车车次和飞机航班的编辑的基本信息输入操作。

程序的输出信息主要是：最快需要多少时间才能到达，或最少需要多少旅费才能到达，或最少需要多少次中转到达，并详细说明依次于何时乘坐哪一趟列车或哪一次班机到何地。

程序的功能包括：提供对城市信息的编辑，提供列车时刻表和飞机航班表的编辑，提供三种最优决策：最快到达、最省钱到达、最少中转次数到达。

基本要求：1、掌握C语言的变量及函数的灵活使用；2、熟练掌握图的深度、广度优先遍历算法思想及其程序实现；3、掌握C语言中文件的基本操作；4、掌握VC++6.0软件的熟练使用。

主要参考资料：[1] 春葆.数据结构程序设计[M].:清华大学,2002,03[2] 王黎,袁永康战略[M].:清华大学,2002,01[3] 谭浩强.C程序设计第二版[M].:清华大学,2003,03[4] 任哲.MFC Windows程序设计[M].:清华大学,2004,06完成期限：2016.12.05—2017.01.05指导教师签名：课程负责人签名：随着高科技的飞速发展，列车、飞机、动车、高铁的出现极大的减少了人们花在旅途上的时间。

对于城市间错综复杂交通网的管理，是一项庞大而复杂的工作。

在此基础上，如何实现交通网智能化的管理达到帮助乘客选择经济高效的交通工具是目前仍处空白。

尤其乘客交通工具的择优选择是一个令人懊恼的工作，一个原因就是各种交通工具的查询十分分散和繁琐。

即使有互联网的帮忙，但是没有一个统一的归类、没有一个精细的算法、系统的软件帮助，人们仍然无法获得最优方式。

为此开发一个交通择优系统是十分必要的。

采用计算机对城市间的交通工具进行系统录入和管理，进一步提高了交通部门针对城市间客运网络的管理效率，实现交通运营网络的系统化、规化和自动化。

全国交通运输网最佳经由问题经典源代码

struct SqStack
{
int *base; // 在栈构造之前和销毁之后，base的值为NULL
int *top; // 栈顶指针
int stacksize; // 当前已分配的存储空间，以元素为单位
}; // 顺序栈
（4）基本操作的实现
goto text;
}
else
{
for(i=0;i<G.vexnum;i++)
{
fprintf(fp,"%s ",G.vex[i]);
}
}
for(m=0;m<3;m++)
for(i=0;i<G.vexnum;i++)
if(strcmp(ch,"11B")==0)
{
i=LocateVex(G,va);
j=LocateVex(G,vb);
G.arcs[0][i][j].adj=w;
strcpy(G.arcs[0][i][j].info,ch);
G.arcs[1][i][j].adj=w;
G.arcs[0][i][j].adj=w;
strcpy(G.arcs[0][i][j].info,ch);
}
else if(strcmp(ch,"01B")==0)
{
i=LocateVex(G,va);
j=LocateVex(G,vb);
{
G.arcs[m][i][j].adj=INFINITY;
strcpy(G.arcs[m][i][j].info,"His");

数据结构课程设计全国交通模拟

数据结构课程设计报告班级：191113学号：20111000611姓名：黄建钊指导老师：朱晓莲日期：2013年3月7．全国交通咨询模拟出于不同目的的旅客对交通工具有不同的要求。

例如，因公出差的旅客希望在旅途中的时间尽可能短，出门旅游的游客则期望旅费尽可能省，而老年旅客则要求中转次数最少。

编制一个全国城市间的交通咨询程序，为旅客提供两种或三种最优决策的交通咨询。

要求：（1）提供对城市信息进行编辑（如添加或删除）的功能。

（2）城市之间有两种交通工具：火车和飞机。

提供对列车时刻表和飞机航班进行编辑（增设或删除）的功能。

（3）提供两种最优决策：最快到达或最省钱到达。

全程只考虑一种交通工具。

（4）旅途中耗费的总时间应该包括中转站的等候时间。

（5）咨询以用户和计算机的对话方式进行。

1.需求分析1、设计最短路径的算法及其需要信息的存储：本设计中最短路径的算法利用迪杰斯特拉算法，存储方法利用邻接矩阵存储。

2、该程序所做的工作的是模拟全国交通咨询，为旅客提供种最优决策的交通咨询。

此程序规定：在程序中输入城市名称时，需输入10个字母以内的字母串；输入列车或飞机编号时需输入一个字符串类型；输入列车或飞机的费用时需输入一个实型数据；输入列车或飞机开始时间和到达时间时均需输入一个整型数据，在选择功能时，应输入与所选功能对应的一个整型数据。

程序的输出信息主要是：最快需要多少时间才能到达，或最少需要多少旅费才能到达，说明在途中经过的城市名称；程序的功能包括：提供对城市信息的编辑，提供列车时刻表和飞机航班表的编辑，提供两种最优决策：最快到达、最省钱到达。

2.设计2.1设计思想本系统整体上分为存储系统和求最短路径两部分，存储系统运用到数组和结构体。

该系统分别存储火车列次，航班，出发点与目的地以及所需要走的路程和所用费用。

最短路径使用迪杰斯特拉算法编程求算得出最近或最便宜路径。

该算法主要分为三步：1、起始点（V0）与其相邻点的权值（即当前最短路径）。

2004《数据结构》课程设计题目及基本要求如下：

2004《数据结构》课程设计题目及基本要求如下：一、试设计一个航空客运定票系统。

基本要求如下：1、每条航线所涉及的信息有：终点站名、航班号、飞机号、飞机周日（星期几）、乘员定额、余票量、订定票的客户名单（包括姓名、订票量、舱位等级1，2或3）以及等候替补的客户名单（包括姓名、所需数量）。

2、系统能实现的操作和功能如下：1）查询航线：根据客户提出的终点站名输出如下信息：航班号、飞机号、星期几飞行，最近一天航班的日期和余票额；2）承办订票业务：根据客户提出的要求（航班号、订票数额）查询该航班票额情况，若有余票，则为客户办理订票手续，输出座位号；若已满员或余票少余订票额，则需重新询问客户要求。

若需要，可登记排队候补；3）承办退票业务：根据客户提出的情况（日期、航班号），为客户办理退票手续，然后查询该航班是否有人排队候补，首先询问排在第一的客户，若所退票额能满足他的要求，则为他办理订票手续，否则依次询问其它排队候补的客户。

3、实现提示：两个客户名单可分别由线性表和队列实现。

为查找方便，已订票客户的线性表应按客户姓名有序，并且，为了插入和删除方便，应以链表作为存储结构。

由于预约人数无法预计，队列也应以链表作为存储结构。

二、校园导游咨询（为来访的客人提供各种信息服务）1、基本要求：1）设计下沙校园平面图，在校园景点选10个左右景点。

以图中顶点表示校园内各景点，存放景点名称、代号、简介等信息；以边表示路径，存放路径长度等有关信息。

2）为来访客人提供图中任意景点相关信息的查询。

3）为来访客人提供任意景点的问路查询，即查询任意两个景点之间的一条最短路径。

2、实现提示：一般情况下，校园的道路是双向通行的，可设计校园平面图是一个无向网。

顶点和边均含有相关信息。

三、停车场管理问题[问题描述]设有一个可以停放n辆汽车的狭长停车场，它只有一个大门可以供车辆进出。

车辆按到达停车场时间的早晚依次从停车场最里面向大门口处停放(最先到达的第一辆车放在停车场的最里面)。

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

数据结构设计报告姓名：专业：指导教师：目录摘要 (3)第1章概述 (4)1.1系统实现的目标 (4)1.2系统实现方案 (4)1.3系统实现环境 (4)1.4具体的开发方法 (4)第2章系统设计 (5)2.1系统功能设计 (5)2.2数据设计 (5)2.3界面的设计 (5)第3章系统实现 (9)参考文献 (15)摘要设计、实现一个全国大城市间的交通咨询程序，为旅客提供三种最优决策方案：一是建立交通网络图的存储结构，二实现两个城市间的最短路经问题。

程序所具有的功能特色本程序主要目的是为了给用户提供路径咨询。

实现了帮助用户了解全国各大城市间往来的最短路径问题，第二，可以提供用户查询各大城市的相关信息。

本程序最大的特点是支持用户自己添加城市信息及城市，或添加城市的路径，既就有可扩展性该程序所做的工作的是模拟全国交通咨询，为旅客提供三种最优决策的交通咨询。

此程序规定：（1）在程序中输入城市名称时，需输入10个字母以内的字母串；输入列车或飞机编号时需输入一个整型数据；输入列车或飞机的费用时需输入一个实型数据；输入列车或飞机开始时间和到达时间时均需输入两个整型数据（以hh：mm的形式）；在选择功能时，应输入与所选功能对应的一个整型数据。

（2）程序的输出信息主要是：最快需要多少时间才能到达，或最少需要多少旅费才能到达，或最少需要多少次中转到达，并详细说明依次于何时乘坐哪一趟列车或哪一次班机到何地。

（3）程序的功能包括：提供对城市信息的编辑，提供列车时刻表和飞机航班表的编辑，提供三种最优决策：最快到达、最省钱到达、最少中转次数到达。

第1章概述1.1 系统实现的目标通过进行课程设计，了解并初步掌握设计、实现较大系统的完整过程，包括：系统分析、编码设计、系统集成、以及调试分析，熟练掌握数据结构的选择、设计、实现以及操作方法，为进一步的应用开发打好基础。

应用所学数据结构知识，独立完成问题分析，结合数据结构理论知识，编写程序求解指定问题。

铁路运输统计与分析课程设计

铁路运输统计与分析课程设计1. 概述铁路运输是我国重要的物流运输方式之一，对于我国经济的发展有着重要的推动作用。

铁路运输的运营效率对于整个物流体系的运作有着至关重要的作用。

因此，对铁路运输的统计与分析，有助于我们更清楚地了解铁路运输的发展规律，寻找效率提升的潜力。

本课程设计的目标是通过对铁路运输数据进行分析，寻找运输效率的优化途径，优化整个物流体系的运作效率。

2. 数据来源与说明本课程设计使用的数据来自铁路局公开的运输数据，数据时间截至2021年12月31日，数据包括以下几个方面：•货物列车总数和总运力；•客车日均出行人数和拥挤程度等；•集装箱运输量和运力等。

本数据是原始数据，因此需要进行清洗和处理，然后再进行分析。

3. 数据清洗和处理3.1 数据预处理•按照运输方式，将原始数据按照货车、客车、集装箱分别保存为三个文件；•剔除无效数据，如缺失值、异常值等；•确保数据的准确性和一致性。

3.2 数据处理•统计不同运输方式的总数和总运量；•计算各种车型之间的比例；•统计货车和客车的出行量和拥挤程度等；•分析各项指标的历史变化趋势，包括运输量、运输距离、运输时间等。

4. 数据分析和展示本课程设计主要从以下几个方面进行数据分析和展示：4.1 运输总量和比例分析通过对不同运输方式的总量和比例进行分析，以便了解各种运输方式在总体运输中的占比情况。

运用可视化图表，如饼状图、柱状图等，表达其分布情况。

4.2 货车和客车运力利用率分析通过对货车和客车的运力利用率进行分析，寻找运输效率的优化途径。

这里要识别哪些列车运行效率低的区间，并制定优化方案。

运用可视化图表，如趋势图、周期图等，呈现出其运输效率，以及变化规律。

4.3 集装箱运输分析集装箱运输在铁路运输中占据极其重要的地位，其运输量和运输质量直接关系到整个物流体系的质量。

因此，通过对集装箱运输量和运输质量的统计和分析，寻找优化方案，提升集装箱运输的质量。

运用可视化图表，如折线图、散点图等，表达出数量和质量之间的关系。

数据结构课程设计---交通旅游图的最短路径问题

数据结构课程设计报告题目交通旅游图的最短路径问题学生姓名*****指导教师*****学院******专业班级******完成时间********摘要数据结构主要是一门研究非数值计算的程序设计问题中的计算机操作对象以及它们之间的关系和操作等的学科。

数据结构在计算机科学与技术中是一门综合性的专业基础课，其研究不仅涉及到计算机硬件的研究范围，而且和计算机软件的研究有着更密切的关系。

不论是编译程序过程还是操作系统都涉及到数据元素在存储器中的分配问题。

在计算机科学与技术中，数据结构不仅是一般程序性的基础，而且也是其他系统程序和大型程序的重要基础。

在交通网络非常发达，交通工具和交通方式不断更新的今天，人们在出差、旅游或做其它出行时，不仅关心节省费用，而且对里程和所需时间等问题也感兴趣。

对于这样一个人们关心的问题，可用一个图结构来表示交通网络系统，利用计算机建立一个交通咨询系统。

图中顶点表示站点之间的交通关系。

这个交通系统可以回答旅客提出的各种问题。

比如任意一个站点到其他站点的最短路径，任意两个站点之间的最短路径问题。

本次设计的交通咨询系统主要是运用C语言来完成交通图的存储、图中顶点的最短路径和任意一对顶点间的最短路径问题。

关键字：数据结构课程设计交通咨询系统目录前言 (1)第一章设计要求 (2)1.1设计内容 (2)1.2设计目的 (3)1.3设计分析 (4)第二章系统功能模块的设计 (5)2.1 系统功能分析与设计 (5)2.1.1系统简介 (5)2.1.2 系统流程图 (5)2.2 各功能模块简介 (6)2.2.1结构体的建立 (6)2.2.2 图的建立与初始化 (6)2.2.3 邻接矩阵的输出 (8)2.2.4 显示函数 (8)2.2.5 最短路径算法 (9)2.2.6主函数 (10)第三章实践结果与调试 (12)3.1运行结果 (12)3.1.1主界面 (12)3.1.2查询站点编号模块 (12)3.1.3邻接矩阵查询模块 (12)3.1.4最短路径查询模块 (13)3.2运行调试及发现问题 (15)3.2.1调试过程 (15)3.2.2发现问题 (15)第四章设计总结与心得 (16)附录：程序源代码 (18)前言乘汽车旅行的人总希望找出到目的地的尽可能短的行程。

数据结构课程设计之全国铁路最佳路径问题

##大学数据结构课程设计报告题目：全国铁路运输网最佳经由问题院(系): 计算机工程学院学生姓名:班级：学号:起迄日期: 2011/6/20至2011/7/01指导教师:2010—2011年度第 2 学期一、需求分析1.问题描述：这是上海铁路局目前仍在使用的行包托运软件中的一部分内部算法。

该题目采用1995年年底我国铁路运输网的真实数据进行编程和运行验证。

铁路运输网络中由铁路线和火车站的两个主要概念，譬如：1号铁路线表示京广线，2号铁路线表示京沪线等。

铁路线对象包括铁路线编号,铁路线名称，起始站编号,终点站编号,该铁路线长度，通行标志(00B客货运禁行,01B货运通行专线，10B客运通行专线，11B客货运通行)。

火车站对象包括所属铁路线编号，车站代码，车站名，车站简称，离该铁路线起点站路程及终点站路程。

2.基本功能（1）查询某站所属的铁路线（2）要求具备新增铁路线的管理功能（3）要求具备新增车站的管理功能（4）针对客运，货运情况能计算任何一个起始车站到任何一个终点站之间的最短路径。

并且要求能够显示出该最短路径的各个火车站的经由顺序3.输入输出初始数据是从views.txt、lines.txt、ways.txt三个文件中读入，在读入数据后，用户可以根据选项选择相应的功能，不同的功能有不同的数据输入/输出，比如：查询的功能是要求输入要查询的站的名称，然后输出是该站的相关信息；查询最短路径的功能则是输入起点站、终点站的名称，，输出则是该的路线距离和经由站等二、概要设计1.设计思路：核心问题:求最短路径(选址的要求就是超市到各单位权值之和最少)数据模型（逻辑结构）:带权有向图 (权值计算: 距离*频度)2.数据结构设计：存储结构:本程序采用的是文件进行数据的存储，所以才用的是顺序存储结构，如要添加数据，直接在文件里面进行操作就行。

如下为抽象数据类型定义的模板及抽象数据类型线性表的定义如下：ADT List{数据对象：D={ai| ai ∈ElemSet,i=1,2,3……，n,n≥0}数据关系：R1={<ai-1,ai>| ai-1,ai ∈D,i=1,2,3,……，n}基本操作：void readviews()初始条件：views.txt已经存在。

(完整word版)数据结构课程设计-全国交通咨询系统

X X 学院计算机系《数据结构》课程设计报告书全国交通咨询模拟系统的设计与实现学生姓名：学号：年级专业及班级：指导老师及职称：讲师专业:计算机科学与技术专业提交日期：2011年6月全国交通咨询模拟系统的设计与实现学生：指导老师：(怀化学院计算机系,怀化418008）摘要：该课程设计主要实现了对全国火车及飞机信息的修改和查询，其中主要包括：管理员对火车、飞机信息的操作，其中又包含对两种交通方式的增加和删除操作.旅客用户对两种交通信息的查询，其中飞机信息和火车信息都包含了对两个站点间最短路径方式的查询、最少花费方式的查询以及城市中所有的交通信息的查询.关键词：全国交通咨询；1前言为了完成数据结构的课程设计,为了巩固自己数据结构的知识,也是为了提高自己的编程能力和逻辑思维能力，我选了这道全国交通咨询模拟系统的设计与实现一题。

在对其需求进行分析之后,按照需求分析，逐步完成其各部分的功能实现.对于总的方面来讲，管理员功能实现并不难，而难点在于用户功能中的算法及数据结构中的知识以及编程的细微方面，下面将详细介绍本课程设计的内容.2需求分析2.1 范围2．1。

2 系统概述1．软件名称：全国交通咨询系统V1.02．软件功能:主要的功能有:管理员增删和修改城市站点信息、飞机路线信息、火车路线信息。

3．用户：查询最小耗费路线、查询最短时间路线、查询城市所有路线.4．开发者:2．1.3 文档概述需求分析采用在面向对象的方法，主要使用结构体struct的方法来进行实际的编程,在文档中主要采E—R图和对功能的简单描述的方法来表述系统的需求。

本需求分析的审查者是老师,所以主要是写给老师看的,用来说明我对这个系统的分析情况。

2．2 引用文件无2．3 需求概述2．3。

1 系统目标本系统的总体目标是通过使用该系统，管理员可以对飞机或者火车的信息的简单管理，也方便外出旅客在不同的需求下(如：最少的花费和最短的路程）,快速浏览到所要的信息。

《数据结构》课程设计2011-2012-2

《数据结构》课程设计2011-2012-2题目一：池塘夜降彩色雨【问题描述】：设计一个程序，演示美丽的“池塘夜雨”景色；色彩缤纷的雨点飘飘洒洒地从天而降，滴滴入水有声，溅起圈圈微澜。

【基本要求】：（1）雨点的空中出现位置、降落过程的可见程度、入水位置、颜色、最大水圈等，都是随机确定的；（2）多个雨点按照各自的随机参数和存在状态，同时演示在屏幕上。

（3）增加“电闪雷鸣”景象。

（4）增加风的效果，展现“风雨飘摇”的情景题目二：哈夫曼编码器【问题描述】：利用哈夫曼树实现编码并译码的系统。

【基本要求】：从终端读入一段字符集，系统自动统计出字符的个数n以及各个字符出现的次数w作为权值，建立哈夫曼树，并将哈夫曼树以凹入表示法的形式显示在屏幕上。

利用已建好的哈夫曼树对字符进行编码，并将该段文字的编码存人一个文件code中，然后输出这段编码。

题目三：算术表达式求值演示【问题描述】：表达式计算是实现程序设计语言的基本问题之一，也是栈的应用的一个典型例子。

设计一个程序，演示中缀表达式变为后缀表达式并对后缀表达式求值的过程。

【基本要求】：以字符序列的方式从终端输入语法正确的、不含变量的整数表达式。

利用中缀表达式变为后缀表达式算法和后缀表达式的求值算法实现对算术四则混合运算表达式的求值，并演示出在求值中运算符栈、操作数栈、输入字符和主要操作的变化过程。

题目四：农夫过河问题【问题描述】：从前，一个农夫带着一只狼，一只羊和一棵白菜过河（注意该狼已经被农夫驯服了，但还是会吃羊）。

他要将所有东西安全的带到河的对岸。

不幸的是河边只有一条小船，只能装下农夫和他的一样东西，并且农夫必须每次都随船过河，因为只有他能撑船。

在无人看管的情况下，狼要吃羊，羊要吃白菜，因此农夫不能在河的某边岸上单独留下狼和羊，也不能单独留下羊和白菜。

那么农夫如何才能使三样东西平安过河呢？【基本要求】：1、输出农夫过河问题求解的详细步骤。

2、分别采用深度优先搜索算法和广度优先搜索算法实现。

全国交通咨询模拟(数据结构Java课程设计)

一、课程设计概述：使用语言：java编译环境：java虚拟机二、课程设计题目一[实验内容]全国交通咨询模拟[问题描述]1、管理员可以添加、修改、删除各交通路线信息。

2、用户查询从某一地点到另一地点的信息，提供查询转车次数最少、花费最少、所用时间最少的相关信息。

[需求分析]1、管理员和用户拥有不同的操作界面。

管理员从键盘输入个交通路线并保存在trainInformation.txt中。

2、对文件trainInformation.txt中的数据进行处理，要求具有如下功能：①、城市信息进行编辑。

②、对列车时刻表进行编辑（增设或删除）的功能。

③、提供三种最优决策：最省钱到达，转车最少。

④、提供各列车详细信息。

3、界面美观[概要设计]class MoneyLeast{}//求出两站点花费最少的路径class TrainContral{}//从文件中读出列车的所有信息或者将列车的信息写入到文件class TrainGraph{}//列车航线交通图class AdmFrame{}//管理员登陆界面class SearchInFrame{}//用户查询信息和显示信息界面[存储结构]class City{//城市存储private String cityName;}class Train {//列车存储private String trainID;private City startCity;private City endCity;private Date startDate;private Date endDate;private int money;}[详细设计]---City----/*** 城市的对象* 城市有城市名* 实现序列化* 重写equals方法和toString方法*/package com.consel;import java.io.Serializable;//实现序列化的接口public class City implements Serializable {private static final long serialVersionUID = 5612649006026227701L;private String cityName;public City(String cityName) {this.cityName = cityName;}public String getCityName() {return cityName;}public void setCityName(String cityName) {this.cityName = cityName;}@Overridepublic String toString() {return cityName;}@Overridepublic boolean equals(Object obj) {if (obj instanceof City) {City temp = (City) obj;if (this.cityName.equals(temp.cityName)) {return true;}}return false;}}----MoneyLeast-----/*** MoneyLeast 查找从花费最少的路径，及乘车路径* 使用的是普里姆算法*/package com.consel;public class MoneyLeast {final static int maxMoney = 10000;int n;int[] s;//s用来存储n个节点的标记int minMoney, u = 0;//t为列车信息图，c为起始城市，数组money是用来存储最少花费的路径，path是用来存储节点的上一节点public void leastMoney(TrainGraph t, City c, int[] money, City[] path) throws Exception {n = t.getNumOfVer();s = new int[n];for (int i = 0; i < n; i++) {money[i] = t.getMoney(c, t.city.get(i));s[i] = 0;if (money[i] < maxMoney) {path[i] = c;} else {path[i] = null;}}s[t.city.indexOf(c)] = 1;for (int i = 0; i < n; i++) {minMoney = maxMoney;for (int j = 0; j < n; j++) {if (s[j] == 0 && money[j] < minMoney) {u = j;minMoney = money[j];}}if (minMoney == maxMoney) {return;}s[u] = 1;City city = t.city.get(u);for (int j = 0; j < n; j++) {if (s[j] == 0 && t.getMoney(city, t.city.get(j)) < maxMoney &&money[u] + t.getMoney(city, t.city.get(j)) < money[j]) {money[j] = money[u] + t.getMoney(city, t.city.get(j));path[j] = city;}}}}}----MoneyTest-----package com.consel;import java.util.Iterator;import java.util.Stack;public class MoneyTest {MoneyLeast ml = new MoneyLeast();TrainGraph tg = new TrainGraph();int[] money;City[] path;public Stack<Train> st = new Stack<Train>();public MoneyTest() {int n = tg.city.size();money = new int[n];path = new City[n];for (int i = 0; i < n; i++) {money[i] = tg.maxMoney;path[i] = null;}}public Stack findMoneyLeast(City c1,City c2) throws Exception{ml.leastMoney(tg, c1,money, path);Stack<City> s = new Stack();s.add(c2);while (!c2.equals(c1)) {City c3 = path[tg.city.indexOf(c2)];s.add(c3);TrainContral ct = new TrainContral();ct.trainRead();Iterator<Train> i = ct.train.iterator();while(i.hasNext()){Train temp = i.next();if(temp.getStartCity().equals(c3) && temp.getEndCity().equals(c2)){st.add(temp);}}c2 = c3;}return s;}}----Train-----/*** Train 序列化，存储列车的信息，包括ID，起始站，终点站，发车时间，到站时间，价格*/package com.consel;import java.util.*;import java.io.Serializable;public class Train implements Serializable {private static final long serialVersionUID = 5612649006026227700L;private String trainID;//列车号private City startCity;//起始站private City endCity;//终点站private Date startDate;//发车时间private Date endDate;//到站时间private int money;//价格public Train(String trainID, City startCity, City endCity, Date startDate, Date endDate, int money) {this.trainID = trainID;this.startCity = startCity;this.endCity = endCity;this.startDate = startDate;this.endDate = endDate;this.money = money;/*** @return the trainID*/public String getTrainID() { return trainID;}/*** @return the money*/public int getMoney() {return money;}/*** @return the startCity*/public City getStartCity() { return startCity;}/*** @return the endCity*/public City getEndCity() { return endCity;}/*** @return the startDate */public Date getStartDate() { return startDate;}/*** @return the endDatepublic Date getEndDate() {return endDate;}}-----TrainContral------/*** TrainContral 从文件trainInformation.txt中读出各列车信息或将各列车信息写入到文件trainInformation.txt中*/package com.consel;import java.io.*;import java.util.*;public class TrainContral {File filename = new File("config/trainInformation.txt");ObjectInputStream ois;ObjectOutputStream oos;public List<Train> train = new ArrayList<Train>();/** 从trainInformation.txt读出所有列车的信息* 并存储于链表train中*/public void trainRead() {try {ois = new ObjectInputStream(new FileInputStream(filename));//文件输入流train = (List<Train>) ois.readObject();} catch (FileNotFoundException ex) {ex.printStackTrace();} catch (IOException ex) {ex.printStackTrace();} catch (ClassNotFoundException ex) {ex.printStackTrace();} finally {try {ois.close();// 关闭文件输入流} catch (Exception exx) {exx.printStackTrace();}}}/*** 将链表t中的所有火车信息写入到trainInformation.txt中* @param t*/public void trainWrite(List<Train> t) {try {oos = new ObjectOutputStream(new FileOutputStream(filename));// 文件输出流oos.writeObject(t);} catch (FileNotFoundException ex) {ex.printStackTrace();} catch (IOException ex) {ex.printStackTrace();} finally {try {oos.flush();//关闭文件缓冲流oos.close();//关闭文件流} catch (Exception exx) {exx.printStackTrace();}}}}------TrainGraph-------/*** TrainGraph 表示所有列车的信息* 查找以一个城市作为起点站，可以到达的另一个城市*/package com.consel;import java.util.*;public class TrainGraph {final static int maxMoney = 10000;List<City> city = new ArrayList<City>();TrainContral tc = new TrainContral();int[][] edges;public List<Train> train;Stack stack1 = new Stack();public Stack<City> stack = new Stack();/*临时保存路径节点的栈*/ public ArrayList<Stack> sers = new ArrayList();/*存储路径的集合*/public int getNumOfVer() {return city.size();}public TrainGraph() {//构造方法tc.trainRead();//从文件中读出所有列车的信息int n = tc.train.size();train = tc.train;Iterator it = train.iterator();/*** 存储交通路线中所有涉及到的城市*/while (it.hasNext()) {Train t = (Train) it.next();City c1 = t.getStartCity();City c2 = t.getEndCity();int x = city.indexOf(c1);int y = city.indexOf(c2);if (x < 0) {}if (y < 0) {city.add(c2);}}edges = new int[city.size()][city.size()];for (int i = 0; i < city.size(); i++) {for (int j = 0; j < city.size(); j++) {edges[i][j] = 0;}}it = tc.train.iterator();while (it.hasNext()) {Train t = (Train) it.next();City c1 = t.getStartCity();City c2 = t.getEndCity();int x = city.indexOf(c1);int y = city.indexOf(c2);edges[x][y] = 1;}}//以c为起始站的第一个终点站public int getFirstNeighbor(City c) throws Exception { int n = city.indexOf(c);if (n >= 0) {return getFirstNeighbor(n);}return - 1;}//查找邻接的城市private int getFirstNeighbor(int v) throws Exception { if (v < 0 || v > city.size()) {throw new Exception("参数错误！");}for (int col = 0; col < city.size(); col++) {if (edges[v][col] > 0) {}}return -1;}//查找下一个邻接城市public int getNextNeighbor(City c1, City c2) throws Exception { int m = city.indexOf(c1);int n = city.indexOf(c2);if (m >= 0 && n >= 0) {return getNextNeighbor(m, n);}return -1;}//查找下一个邻接城市private int getNextNeighbor(int v1, int v2) throws Exception { if (v1 < 0 || v1 > city.size() || v2 < 0 || v2 > city.size()) {throw new Exception("参数错误！");}for (int col = v2 + 1; col < city.size(); col++) {if (edges[v1][col] > 0) {return col;}}return -1;}//返回从c1到c2直达所花费的钱public int getMoney(City c1, City c2) throws Exception { int m = city.indexOf(c1);int n = city.indexOf(c2);if (m < 0 || n < 0) {throw new Exception("城市C1或C2错误！");} else {Iterator<Train> i = train.iterator();boolean flag = false;while (i.hasNext()) {temp = i.next();if (temp.getStartCity().equals(c1) && temp.getEndCity().equals(c2)) { flag = true;break;}}if (flag) {return temp.getMoney();} else {return maxMoney;}}}private boolean isCityInStack(City city) {//判断节点是否在栈中Iterator<City> it = stack.iterator();while (it.hasNext()) {City node1 = it.next();if (city.equals(node1)) {return true;}}return false;}// 存储一条通路private void savePath() {Stack<City> temp = new Stack();Iterator<City> i = stack.iterator();while (i.hasNext()) {City c = i.next();temp.add(c);}sers.add(temp); /*转储*/}// 查找从startCity到endCity的所有路径public void getPaths(City startCity, City endCity) throws Exception {stack.push(startCity);int n = getFirstNeighbor(startCity);if (n >= 0) {City c = city.get(n);getPaths(startCity, endCity, c, startCity);while (c != null) {n = getNextNeighbor(startCity, c);if (n > 0) {c = city.get(n);getPaths(startCity, endCity, c, startCity);} else {c = null;}}}}// 用递归的方法求startCity到endCity的路径currentCity是当前的城市，perCity是currentCity的上一个城市private boolean getPaths(City startCity, City endCity, City currentCity, City perCity) throws Exception {City nCity = null;if (currentCity != null && perCity != null && currentCity.equals(perCity)) { return false;}if (currentCity != null) {stack.push(currentCity);if (currentCity.equals(endCity)) {savePath();stack.pop();return true;} else {int n = getFirstNeighbor(currentCity);if (n >= 0) {nCity = city.get(n);} else {nCity = null;}while (nCity != null) {if (perCity != null && (nCity.equals(startCity) || perCity.equals(nCity) || isCityInStack(nCity))) {n = getNextNeighbor(currentCity, nCity);if (n >= 0) {nCity = city.get(n);} else {nCity = null;}continue;}if (getPaths(startCity, endCity, nCity, currentCity)) {if (!stack.isEmpty()) {stack.pop();}}n = getNextNeighbor(currentCity, nCity);if (n >= 0) {nCity = city.get(n);} else {nCity = null;}}if (!stack.isEmpty()) {stack.pop();}return false;}} else {return false;}}}-----AdmFrame-------/** 管理员登陆界面* 用户名为：Adm* 口令为：123456*/package com.desgin;import java.awt.*;import java.awt.event.*;import javax.swing.*;public class AdmFrame {ImageIcon img = new ImageIcon("config/Adm.gif");JLabel background = new JLabel(img);JFrame admFrame = new JFrame();JLabel user = new JLabel("用户名：");JTextField userInput = new JTextField(20);JLabel passWord = new JLabel("口令：");JPasswordField passWordIn = new JPasswordField(20);JPanel panel = new JPanel();JButton login = new JButton("登陆");JButton exit = new JButton("退出");public AdmFrame() {admFrame.setLayout(null);admFrame.setTitle("Administrator");admFrame.setSize(img.getIconWidth(), img.getIconHeight() + 20);admFrame.setLocationRelativeTo(null);admFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);panel.setLayout(new GridLayout(2, 2, 20, 20));panel.add(user);user.setHorizontalAlignment(JTextField.RIGHT);passWord.setHorizontalAlignment(JTextField.RIGHT);panel.add(userInput);panel.add(passWord);panel.add(passWordIn);panel.setBounds(40, 50, 250, 60);JPanel tempPanel = new JPanel();tempPanel.add(login);tempPanel.add(exit);tempPanel.setBounds(130, 130, 200, 40);admFrame.add(panel);admFrame.add(tempPanel);admFrame.add(background);background.setBounds(0, 0, img.getIconWidth(), img.getIconHeight());admFrame.setVisible(true);admFrame.setResizable(false);exit.addActionListener(new ActionListener() {public void actionPerformed(ActionEvent e) {System.exit(0);}});login.addActionListener(new ActionListener() {public void actionPerformed(ActionEvent e) {if (userInput.getText().trim().equals("") || passWordIn.getText().trim().equals("")) {JOptionPane.showMessageDialog(null, "请输入用户名或口令！","Warning", JOptionPane.WARNING_MESSAGE);} else if (userInput.getText().equals("Adm") && passWordIn.getText().equals("123456")) {admFrame.dispose();AdmMainWindow amw = new AdmMainWindow();amw.setVisible(true);} else {JOptionPane.showMessageDialog(null, "用户名或口令错误，请重新输入！","用户名或口令错误", JOptionPane.ERROR_MESSAGE);}}});}public static void main(String[] args) {AdmFrame af = new AdmFrame();}}-----AdmMFListener-------/** 管理员登陆后的界面监听器* 对添加、修改、删除作出相应的变化*/package com.desgin;import com.consel.*;import com.consel.TrainContral;import java.awt.event.*;import java.util.*;import javax.swing.JOptionPane;public class AdmMFListener extends MouseAdapter {AdmMainWindow amw;public AdmMFListener(AdmMainWindow amw) {this.amw = amw;}/** 鼠标点击事件监听*/@Overridepublic void mouseClicked(MouseEvent e) {if (e.getSource() == amw.add) {ChangeDialog cd = new ChangeDialog(amw, "添加", true);cd.setVisible(true);}if (e.getSource() == amw.change) {int selectedRow = amw.table.getSelectedRow();if (selectedRow > -1) {ChangeDialog cd = new ChangeDialog(amw, "添加", true,(String) amw.table.getValueAt(selectedRow, 0));cd.setVisible(true);} else {JOptionPane.showMessageDialog(null, "请选中要修改对象","Warnnig", JOptionPane.WARNING_MESSAGE);}}if (e.getSource() == amw.exit) {amw.dispose();}if (e.getSource() == amw.delete) {int selectedRow = amw.table.getSelectedRow();if (selectedRow > -1) {TrainContral tc = new TrainContral();tc.trainRead();Iterator<Train> i = tc.train.iterator();while (i.hasNext()) {Train temp = i.next();if (temp.getTrainID().equals(amw.table.getValueAt(selectedRow, 0))) {i.remove();tc.trainWrite(tc.train);break;}}amw.table.setModel(new AdmTable());} else {JOptionPane.showMessageDialog(null, "请选中要删除对象","Warnnig", JOptionPane.WARNING_MESSAGE);}}}}------AdmMainWindow-------/*** 管理员管理列车信息的主界面* 显示所有列车的相关信息*/package com.desgin;import javax.swing.*;public class AdmMainWindow extends JFrame {JTable table;JScrollPane jsp;AdmTable model = new AdmTable();JButton change = new JButton("修改");JButton add = new JButton("添加");JButton delete = new JButton("删除");JButton exit = new JButton("退出");AdmMFListener amfl;public AdmMainWindow() {this.setTitle("Administrator");this.setSize(400, 300);this.setLocationRelativeTo(null);this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);amfl = new AdmMFListener(this);table = new JTable(model);jsp = new JScrollPane(table);JPanel panel = new JPanel();panel.add(add);add.addMouseListener(amfl);panel.add(change);change.addMouseListener(amfl);panel.add(delete);delete.addMouseListener(amfl);panel.add(exit);exit.addMouseListener(amfl);this.add(jsp, "Center");this.add(new JLabel(" "), "North");this.add(panel, "South");}}-----AdmTable------/** Table的一个模式* 从文件中读取列车的信息，添加到table中* 显示在主界面中*/package com.desgin;import com.consel.*;import java.text.SimpleDateFormat;import java.util.*;import javax.swing.table.*;public class AdmTable extends AbstractTableModel {TrainContral tc = new TrainContral();Vector rowData, columnNames;List<Train> train;SimpleDateFormat formatter = new SimpleDateFormat("HH:mm");public AdmTable() {tc.trainRead();train = tc.train;init(train);}private void init(List<Train> train) {columnNames = new Vector();columnNames.add("列车号");columnNames.add("出发地");columnNames.add("到达地");columnNames.add("发车时间");columnNames.add("到站时间");columnNames.add("票价");rowData = new Vector();boolean flag = true;Iterator i = train.iterator();while (i.hasNext()) {Train c = (Train) i.next();Vector hang = new Vector();hang.add(c.getTrainID());hang.add(c.getStartCity());hang.add(c.getEndCity());hang.add(formatter.format(c.getStartDate()));hang.add(formatter.format(c.getEndDate()));hang.add(c.getMoney() + "元");rowData.add(hang);}}// 返回行数public int getRowCount() {return this.rowData.size();}//返回列数public int getColumnCount() {return this.columnNames.size();}//返回rowIndex，column处的值public Object getValueAt(int rowIndex, int column) { return ((Vector) this.rowData.get(rowIndex)).get(column); }//返回表头@Overridepublic String getColumnName(int arg0) {return (String) this.columnNames.get(arg0);}}----ChangeDialog-----/** 管理员修改或者添加航线的信息的UI界面*/package com.desgin;import com.consel.*;import java.awt.*;import java.awt.event.*;import java.util.*;import java.util.Iterator;import javax.swing.*;public class ChangeDialog extends JDialog implements ActionListener {JTextField t1 = new JTextField(15);JTextField t2 = new JTextField(15);JTextField t3 = new JTextField(15);JTextField t41 = new JTextField(5);JTextField t42 = new JTextField(5);JTextField t51 = new JTextField(5);JTextField t52 = new JTextField(5);JTextField t6 = new JTextField(15);AdmMainWindow amw;JButton save = new JButton("保存");JButton exit = new JButton("取消");//添加时的构造方法public ChangeDialog(AdmMainWindow amw, String s, boolean b) { super(amw, s, b);this.amw = amw;this.setSize(300, 275);this.setResizable(false);JPanel p1 = new JPanel();p1.setLayout(new GridLayout(7, 1, 8, 8));p1.add(new JLabel("列车号: ", SwingConstants.CENTER));p1.add(t1);p1.add(new JLabel("出发地: ", SwingConstants.CENTER));p1.add(t2);p1.add(new JLabel("到达地: ", SwingConstants.CENTER));p1.add(t3);p1.add(new JLabel("发车时间: ", SwingConstants.CENTER));JPanel panel1 = new JPanel();panel1.add(t41);panel1.add(new JLabel(":"));panel1.add(t42);p1.add(panel1);p1.add(new JLabel("到站时间: ", SwingConstants.CENTER));JPanel panel2 = new JPanel();panel2.add(t51);panel2.add(new JLabel(":"));panel2.add(t52);p1.add(panel2);p1.add(new JLabel("票价: ", SwingConstants.CENTER));p1.add(t6);p1.add(new JLabel("", SwingConstants.CENTER));JPanel pane2 = new JPanel();pane2.add(save);pane2.add(exit);p1.add(pane2);this.add(p1);save.addActionListener(this);exit.addActionListener(this);}//修改时的构造方法public ChangeDialog(AdmMainWindow amw, String s, boolean b, String x) { super(amw, s, b);this.amw = amw;this.setSize(300, 275);this.setResizable(false);JPanel p1 = new JPanel();p1.setLayout(new GridLayout(7, 1, 8, 8));TrainContral tc = new TrainContral();tc.trainRead();Iterator<Train> i = tc.train.iterator();Train temp = null;while (i.hasNext()) {temp = i.next();if (temp.getTrainID().equals(x)) {break;}}p1.add(new JLabel("列车号: ", SwingConstants.CENTER)); p1.add(t1);p1.add(new JLabel("出发地: ", SwingConstants.CENTER)); p1.add(t2);p1.add(new JLabel("到达地: ", SwingConstants.CENTER)); p1.add(t3);p1.add(new JLabel("发车时间: ", SwingConstants.CENTER)); JPanel panel1 = new JPanel();panel1.add(t41);panel1.add(new JLabel(":"));panel1.add(t42);p1.add(panel1);p1.add(new JLabel("到站时间: ", SwingConstants.CENTER)); JPanel panel2 = new JPanel();panel2.add(t51);panel2.add(new JLabel(":"));panel2.add(t52);p1.add(panel2);p1.add(new JLabel("票价: ", SwingConstants.CENTER));p1.add(t6);p1.add(new JLabel("", SwingConstants.CENTER));JPanel pane2 = new JPanel();pane2.add(save);pane2.add(exit);p1.add(pane2);this.add(p1);save.addActionListener(this);exit.addActionListener(this);t1.setText(temp.getTrainID());t2.setText(temp.getStartCity().toString());t3.setText(temp.getEndCity().toString());t41.setText(temp.getStartDate().getHours() + "");t42.setText(temp.getStartDate().getMinutes() + "");t51.setText(temp.getEndDate().getHours() + "");t52.setText(temp.getEndDate().getMinutes() + "");t6.setText(temp.getMoney() + "");}//监听器，对保存、退出按钮进行监听public void actionPerformed(ActionEvent e) {if (e.getSource() == exit) {this.dispose();}if (e.getSource() == save) {TrainContral tc = new TrainContral();tc.trainRead();Date d1 = new Date();d1.setHours(Integer.parseInt(t41.getText().trim()));d1.setHours(Integer.parseInt(t42.getText().trim()));Date d2 = new Date();d2.setHours(Integer.parseInt(t51.getText().trim()));d2.setHours(Integer.parseInt(t52.getText().trim()));Train t = new Train(t1.getText().trim(),new City(t2.getText().trim()),new City(t3.getText().trim()),d1,d2,Integer.parseInt(t6.getText().trim()));Iterator<Train> i = tc.train.iterator();while(i.hasNext()){Train temp = i.next();if(t.getStartCity().equals(temp.getStartCity()) && t.getEndCity().equals(temp.getEndCity())){i.remove();}}tc.train.add(t);tc.trainWrite(tc.train);this.dispose();amw.table.setModel(new AdmTable());}}}-----MainWindow----/** 用户界面测试*/package com.desgin;public class MainWindow {UserFrame uf = new UserFrame();public static void main(String[] args) {MainWindow m = new MainWindow();m.uf.jf.setVisible(true);}}-----MoreDialog-------/** 显示详细信息*/package com.desgin;import com.consel.*;import java.awt.Color;import java.awt.event.*;import java.text.SimpleDateFormat;import java.util.*;import javax.swing.*;public class MoreDialog extends JDialog {SearchInFrame sif;JButton back = new JButton("返回");TrainGraph tg = new TrainGraph();JTable table;Vector colName = new Vector();Vector rowData = new Vector();SimpleDateFormat formatter = new SimpleDateFormat("HH:mm");JButton exit = new JButton("退出");public MoreDialog(SearchInFrame sif, String string, boolean b) { super(sif.mainFrame, string, b);this.sif = sif;this.setSize(300, 275);this.setLocationRelativeTo(null);//设置窗口居中int rowCount = sif.infTable.getSelectedRow();String str = (String) sif.infTable.getValueAt(rowCount, 1);colName.add("列车号");colName.add("起始站");colName.add("终点站");colName.add("发车时间");colName.add("到站时间");colName.add("票价");try {TrainGraph tg = new TrainGraph();tg.getPaths(new City(sif.start), new City(sif.end));Iterator<Stack> iter = tg.sers.iterator();Stack<City> temp = new Stack();while (iter.hasNext()) {if (!temp.isEmpty()) {temp.removeAllElements();}Stack stack = iter.next();Vector hang = new Vector();String s = "";while (!stack.isEmpty()) {City c = (City) stack.pop();if (!(c.getCityName().equals(sif.start) || c.getCityName().equals(sif.end))) {s = c.getCityName() + " " + s;}temp.push(c);}if (s.equals("")) {s += "无";}if (s.equals(str)) {break;}}City eCity = null;City sCity = null;if (!temp.isEmpty()) {sCity = temp.pop();}while (!temp.isEmpty()) {eCity = temp.pop();Iterator<Train> i = tg.train.iterator();while (i.hasNext()) {Train t = i.next();if (t.getStartCity().equals(sCity) && t.getEndCity().equals(eCity)) {Vector hang = new Vector();hang.add(t.getTrainID());hang.add(t.getStartCity());hang.add(t.getEndCity());hang.add(formatter.format(t.getStartDate()));hang.add(formatter.format(t.getEndDate()));hang.add(t.getMoney() + "元");rowData.add(hang);}}sCity = eCity;}} catch (Exception ex) {ex.printStackTrace();}table = new JTable(rowData, colName);JScrollPane jsp = new JScrollPane(table);this.add(jsp);exit.setBackground(Color.lightGray);exit.setBounds(0, 0, 10, 10);exit.addMouseListener(new MouseAdapter() {@Overridepublic void mousePressed(MouseEvent e) {System.exit(0);}});this.add(exit, "South");table.addMouseListener(new MouseAdapter() {@Overridepublic void mouseClicked(MouseEvent e) {int selectedRow = table.getSelectedRow();if (selectedRow > 0) {table.setSelectionForeground(Color.RED);}}});}}------MyMonitor-----/** 用户界面的监听器* 查询、退出的相关操作*/package com.desgin;import java.awt.event.*;import javax.swing.JOptionPane;public class MyMonitor extends MouseAdapter {UserFrame uf;public MyMonitor(UserFrame uf) {super();this.uf = uf;}@Overridepublic void mousePressed(MouseEvent e) {if (e.getSource() == uf.exit) {System.exit(0);}if (e.getSource() == uf.search) {if (uf.start.getText().trim().equals("") || uf.end.getText().trim().equals("")) { JOptionPane.showMessageDialog(null, "请正确输入起始站和终点站!","Warnnig", JOptionPane.WARNING_MESSAGE);} else {uf.sif = new SearchInFrame(uf.start.getText().trim(),uf.end.getText().trim());uf.sif.mainFrame.setVisible(true);uf.jf.dispose();}}}}----MyTable-----/** 用户界面显示在table中的列车信息的模板*/package com.desgin;import com.consel.*;import java.util.*;import javax.swing.table.*;public class MyTable extends AbstractTableModel {TrainContral tc = new TrainContral();Vector rowData, columnNames;String startCity, endCity;SearchInFrame sf;int n;List<Train> train;//构造方法public MyTable(String startCity, String endCity, SearchInFrame sf, int n) { this.sf = sf;this.startCity = startCity;this.endCity = endCity;tc.trainRead();train = tc.train;this.n = n;init(train);}public void init(List<Train> train) {columnNames = new Vector();columnNames.add("出发地");columnNames.add("中转站");columnNames.add("到达地");。

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

数据结构课程设计报告题目：全国交通咨询模拟一．需求分析1．程序设计任务：从中国地图平面图中选取部分城市,抽象为程序所需要图(de)结点,并以城市间(de)列车路线和飞机路线,作为图结点中(de)弧信息,设计一个全国交通咨询模拟系统.利用该系统实现两种最优决策：最快到达或最省钱到达.2. 明确规定：(1)输入形式和输入值(de)范围：每条飞机弧或者火车弧涉及(de)信息量很多,包括：起始城市、目(de)城市、出发时间、到达时间、班次以及费用.作为管理员要输入(de)信息包括以上信息,而作为用户或者客户,要输入(de)信息有起始城市和目(de)城市,并选择何种最优决策.(2)输出形式：按用户提供(de)最优决策(de)不同而输出不同(de)信息,其中输出(de)所搭飞机或火车(de)班次及其起始地点和终点、起始时间和出发时间还有相关(de)最优信息,比如最快经多少时间到达、最省钱多少钱到达和最少经多少中转站到达.(3)程序所能达到(de)功能a.该系统有供用户选择(de)菜单和交互性.可以对城市、列车车次和飞机航班进行编辑,添加或删除.b.建立一个全国交通咨询系统,该系统具备自动查找任意两城市间铁路、飞机交通(de)最短路径和最少花费及中转次数最少等功能.c.初始化交通系统有两种方式,键盘和文档.二．设计概要1.算法设计(1)、总体设计(1) 数据存储:城市信息(城市名、代码)、交通信息(城市间(de)里程、各航班和列车时刻)存储于磁盘文件.建议把城市信息存于文件前面,交通信息存于文件(de)后面,用fread和fwrite函数操作.(2) 数据(de)逻辑结构:根据设计任务(de)描述,其城市之间(de)旅游交通问题是典型(de)图结构,可看作为有向图,图(de)顶点是城市,边是城市之间所耗费(de)时间（要包括中转站(de)等候时间）或旅费.(3) 数据(de)存储结构:采用邻接表和邻接矩阵都可作为数据(de)存储结构,但当邻接边不多时,宜采用邻接表,以提高空间(de)存储效率.这里采用邻接表作为数据(de)存储结构.(4) 用不同(de)功能模块对城市信息和交通信息进行编辑.添加、修改、删除功能可用菜单方式或命令提示方式.只要能方便(de)对城市信息和交通信息进行管理即可,但要注意人机界面.(5) 最优决策功能模块(fast or province).①读入城市信息和交通信息,用邻接表生成含权网络,表头数组中(de)元素存放城市名及对方城市到达该元素所代表城市(de)所有信息；表头数组中(de)元素所对应(de)单链表存放与该元素所代表(de)城市有交通联系(de)城市(代码、里程、航班、列车车次).②根据具体最优决策(de)要求,用Dijkstra算法求出出发城市到其它各城市(de)最优值(最短时间或最小(de)费用),搜索过程中所经过城市(de)局部最优信息都保存在邻接表(de)表头数组中.其目(de)城市所代表(de)元素中就保存了所需(de)最优决策结果.这过程中,要用队列或栈保存局部最优决策值(局部最短(de)时间或最省(de)费用)变小(de)城市,其相应(de)初始值可为∞,并在表头数组对应(de)城市元素中保存响应(de)信息.开始时,栈(队列)中只有出发地城市,随着对栈(队列)顶(首)城市有交通联系(de)城市求得决策值(最短时间或最小(de)费用),若该值是局部最优值且该城市不在栈(队列)中,则进栈(队列),直至栈(队列)为空,本题采用队列实现.③输出结果：从目(de)城市出发,搜索到出发城市,所经过(de)城市均入栈(队列),再逐一出栈栈(队列)中(de)城市,输出保存在表头数组中对应城市(de)信息(对方城市(de)出发信息,里程、时间、费用等)及最终结果.即输出依次于何时何地乘坐几点(de)飞机或火车于何时到达何地；最终所需(de)最快需要多长时间才能到达及旅费,或者最少需要多少旅费才能到达及时间.(6) 主程序可以有系统界面、菜单；也可用命令提示方式；选择功能模块执行,要求在程序运行过程中可以反复操作.(2).详细设计思想：本题所要求(de)交通系统是一个有向带权图结构,考虑到要求该系统有动态增加飞机和列车航班(de)功能,因而采用邻接表(de)形式存储：对每个顶点建立一个单链表,单链表中(de)子结点表示以该顶点连接(de)弧,单链表中子结点(de)顺序可以按权值递增(de)顺序排列,表头结点按顺序存储.题目中提到要提供三种策略,最快到达,最省钱到达和最少中转次数策略,前两种策略采用迪杰斯特拉算法思想,其中最快到达(de)权值为到达两城市所需(de)最短时间,最省钱到达(de)权值为到达两城市所需(de)费用,后一种采用广度优先算法(de)思想,只需求(de)两城市所在(de)层数,就可以求(de)到达两城市所需(de)最少中转次数.迪杰斯特拉（Dijkstra）算法(de)基本思想是：设置两个顶点(de)集合S和T＝V－S,集合S中存放已找到最短路径(de)顶点,集合T存放当前还未找到最短路径(de)顶点.初始状态时,集合S中只包含源点v0,然后不断从集合T中选取到顶点v0路径长度最短(de)顶点u加入到集合S中,集合S 每加入一个新(de)顶点u,都要修改顶点v0到集合T中剩余顶点(de)最短路径长度值,集合T中各顶点新(de)最短路径长度值为原来(de)最短路径长度值与顶点u(de)最短路径长度值加上u到该顶点(de)路径长度值中(de)较小值.此过程不断重复,直到集合T(de)顶点全部加入到S中为止.下面讨论基于邻接表(de)存储结构求两点间最短路径(de)方法：根据迪杰斯特拉(Dijkstra)算法所依据(de)原理：若按长度递增(de)次序生成从源点V0到其它顶点(de)最短路径,则当前正在生成(de)最短路径上除终点以外,其余顶点(de)最短路径均已生成（将源点(de)最短路径看作是已生成(de)源点到其自身(de)长度为0(de)路径）.按照这一思想,构造以下算法：设S=S’=U={},建立数组PATH[n],用来存储V0到各终点(de)最短路径,初值均置为空集.建立数组BOOL F[n],F[i]表示序号为i(de)表头结点(de)单链表中所有子结点已或未全部找到,初值置为FALSE.建立数组float dist[n],dist[i]表示序号为i(de)表头结点到V0(de)最短权值（这里是时间或费用）,显然dist[V0]=0,其他顶点(de)dist初值置为∞.建立数组BOOL IS[n],IS[i]表示序号为i(de)顶点是否在S 中,初值均置为FALSE.(1)VX=V0；最短(de)最短路径为PATH[0]=[V0] (2)S=S+VX ；（集合(de)并计算） IS[VX]=TRUE ； S ’=S ’+VX ；(3)对S ’中(de)所有顶点： {do{ 由邻接表中该表头结点开始依次找单链表(de)下一子结点(沿链域指针依次访问)；While （“命令” = “退出”）{接受命令（用户输入要实现功能）；进入各个处理命令函数；} }2. 函数和过程(de)调用关系图四．调试分析：⑴调试过程中遇到(de)问题是如何解决(de)以及对设计与实现(de)回顾讨论和分析：在调试(de)过程中碰到了一下问题：a. 引用形参应用不当；b. 文件操作中遇到读入错误或找不到文件；解决方案：a. 对引用形参了解(de)不是很透彻,导致错误,通过查阅相关书籍如C++ Primer 和请教编程能力较高(de)人,最终解决问题.b. 通过参考谭浩强编着(de)C程序设计中(de)文件操作,文件格式和相关文件路径(de)设置,最终解决问题.⑵算法(de)时空分析（包括基本操作和其他算法(de)时间复杂度和空间复杂度(de)分析）和改进设想：⑶经验和体会：通过本次课程设计,我学到了一种程序设计方法,就是结构化程序设计方法,在程序设计过程中,我尝试按如下方法进行结构化程序设计：(1)自顶向下；(2)逐步细化；(3)模块化设计(4)结构化编码.这种设计方法(de)过程是将问题求解由抽象逐步具体化(de)过程,而且,用这种方法便于验证算法(de)正确性.本次课程设计所使用(de)是较为复杂(de)抽象数据类型——图,而且在弧(de)基础上增加了许多信息,如添加了时间,费用等等,这无疑给编程加大了难度,同时也是相当(de)具有挑战性.在编程(de)过程中,我用到了全局数组,我将数组放在工程(de)头文件里面,编译(de)时候报错,说是多重定义.最终放弃了创建工程,而选择了单个文件进行编译和运行,结果顺利通过.同时,在文件操作方面我也曾遇到问题,就是在程序对文件进行读取(de)时候报错,无法读取文件,最后查询有关C(de)工具书,原来是文件路径问题,借助工具书最终解决了文件操作方面(de)问题.总之,这次课程设计是对这一个学期以来对数据结构学习成果(de)一个验证,同时也是理论与实践很好(de)结合,既对学过(de)数据结构进行了巩固,也对我(de)编程能力奠定了坚实(de)基础.五．用户使用说明：1)打开并运行程序,按任意键进入操作主界面,按提示进行相关操作；2)按“1”进入管理员界面,按“2”进入用户咨询界面,按“3”显示交通系统,按“4”则退出.3)进入管理员界面可键入“1”初始化交通系统,并选择文档初始化方式(如果是第一次使用该系统建议使用文档初始化交通系统,免得自己进行繁冗(de)初始化操作).其余可按提示进行相关操作,不难掌握.4)进入用户咨询界面,可根据用户需要进行相关(de)选择,或是选择“1”(最少旅行费用)；或是选择“2”(最少旅行时间),又或者是选择“3”(最少旅行中转次数)等.5)进入显示交通系统界面,根据用户选择则可显示城市、飞机航班、列车车次等信息.或者返回上一级菜单.六．附录——源程序define MAX_VERTEX_NUM 18define NULL 0define MAX_ARC_SIZE 100define MAX_ROUTE_NUM 5include<>include<>include<>include<>define False 0define True 1define INFINITY 10000typedef 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请输入城市名称(de)信息:\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("请输入飞机航班(de)信息:\n");printf("飞机航班编号:");scanf("%d",&code);getchar();printf("起始城市:");gets(vt);printf("目(de)城市:");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("请输入列车车次(de)信息:\n"); printf("列车车次编号:");scanf("%d",&code);getchar();printf("起始城市:");gets(vt);printf("目(de)城市:");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请输入新增城市(de)名称:"); 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);}elsereturn;}}void DeleteVertex(ALGraph G){int i,j,k,n;char v[10],c;ArcNode p,q,m;printf("\n请输入删除(de)城市:");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;}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;}}}}G->vexnum--;save(G);}elsereturn;}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请输入新增飞机航班(de)信息:\n");printf("飞机航班编号:");scanf("%d",&code);getchar();printf("起始城市:");gets(vt);printf("目(de)城市:");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){。

数据结构课程设计1 (1)

1.一元稀疏多项式计算器(不选)[问题描述]设计一个一元稀疏多项式简单计算器。

[基本要求]输入并建立多项式；输出多项式，输出形式为整数序列：n, c1, e1, c2, e2,……, cn, en ，其中n是多项式的项数，ci, ei分别是第i项的系数和指数，序列按指数降序排序；多项式a和b相加，建立多项式a+b;多项式a和b相减，建立多项式a-b;[测试数据](2x+5x8-3.1x11)+(7-5x8+11x9)=(-3.1x11+11x9+2x+7)(6x-3-x+4.4x2-1.2x9)-(-6x-3+5.4x2-x2+7.8x15)=(-7.8x15-1.2x9-x+12x-3)(1+x+x2+x3+x4+x5)+(-x3-x4)=(x5+x2+x+1)(x+x3)+(-x-x3)=0(x+x2+x3)+0=(x3+x2+x)[实现提示]用带头结点的单链表存储多项式，多项式的项数存放在头结点中。

2.背包问题的求解（一人）[问题描述]假设有一个能装入总体积为T的背包和n件体积分别为w1, w2, …,wn的物品，能否从n件物品中挑选若干件恰好装满背包，即使w1+w2+…+wn=T，要求找出所有满足上述条件的解。

例如：当T=10，各件物品的体积为{1，8，4，3，5，2}时，可找到下列4组解：（1，4，3，2）、（1，4，5）、（8，2）、（3，5，2）[实现提示]可利用回溯法的设计思想来解决背包问题。

首先，将物品排成一列，然后顺序选取物品转入背包，假设已选取了前i件物品之后背包还没有装满，则继续选取第i+1件物品，若该件物品“太大”不能装入，则弃之而继续选取下一件，直至背包装满为止。

但如果在剩余的物品中找不到合适的物品以填满背包，则说明“刚刚”装入背包的那件物品“不合适”，应将它取出“弃之一边”，继续再从“它之后”的物品中选取，如此重复，直至求得满足条件的解，或者无解。

由于回溯求解的规则是“后进先出”因此自然要用到栈。

数据结构课程设计参考题目(一)

数据结构课程设计参考题目(一)数据结构是计算机科学中的一门基础课程，它主要研究数据的组织、存储、管理和操作等方面的问题。

随着计算机技术的发展，数据结构逐渐成为各个领域必不可少的一门课程。

而数据结构课程设计参考题目是该课程的一项重要内容，它能够帮助学生更好地掌握课程知识，提高对数据结构的理解和应用能力。

以下是几个数据结构课程设计参考题目。

1.链表操作设计一个链表类，使得它能够实现插入、删除、查找和遍历链表的操作。

要求采用单向链表或双向链表实现，并考虑链表的循环操作。

同时，要求能够对链表进行排序操作。

2.栈与队列操作设计一个栈和队列类，使得它们能够实现入栈、出栈、入队和出队的操作。

要求采用数组或链表实现，并可用于表达式转换和括号匹配等相关问题。

3.堆排序算法实现堆排序算法，要求能够对整型数列进行排序，并输出其排序后的结果。

要求堆的构建、删除和调整操作均可用最大堆或最小堆实现。

同时，要求能够对算法的时间复杂度进行分析，并与快速排序等算法进行比较。

4.哈希表实现设计一个哈希表类，使其能够实现插入、删除和查找等操作。

要求采用链地址法或开放地址法实现，同时需要考虑哈希函数和扩容等问题。

要求能够对哈希冲突的解决方法进行比较和分析。

5.树与图的遍历实现二叉树、B树或B+树的遍历操作，要求能够实现先序、中序和后序遍历，并能够循环遍历或递归遍历。

同时，要求能够对树的平衡性进行探究和讨论。

另外，树的遍历也是图的遍历的基础，可以通过深度优先搜索或广度优先搜索实现图的遍历。

以上是一些常见的数据结构课程设计参考题目，它们可以锻炼学生的编程能力、算法分析能力和数据处理能力，同时也可以增强学生对数据结构知识的理解和掌握。

全国铁路运输网最佳经由问题

#include<fstream>#include<iostream>#include<string>#include<stdio.h>#include<iomanip>#define SIZE_view 50#define SIZE_line 100#define SIZE_way 300#define MAXNODE 30 //定义最多的顶点数#define MAXCOST 1000//自己写的头文件//#include<addview.h>// //using namespace std;struct view_info /*城市信息结构*/{int id;char name[20];int code;char shortname[20];char LName[100];// 经过此车站的铁路线名称} views[SIZE_view];struct line_info //铁路线信息结构{int Lid;char LName[20];int start_id; //始发站idint end_id; //终点站idint dist; //铁路线长度int sign;//通行标志}lines[SIZE_line];struct way_info //铁路度的信息结构{int station1;int station2;int dist;}ways[SIZE_way];struct path_info //用于最短路径的查询{int count;int path[SIZE_view];};int view_count,line_count,way_count;//用来存储文件中有多少条记录void readviews(){int i;ifstream infile("views.txt",ios::in); //打开文件infile >>view_count ; //把文件中的记录赋值给view_countif(!infile) //打开文件失败{cerr<<"open error!"<<endl;exit(1);}//infile>>view_count; // 先读入文件个数for(i=0;i<view_count;i++){infile>>views[i].id>>views[i].name>>views[i].code>>views[i].shortname>>views[i].LName;}//view_count=i;//给出原文件中车站的个数infile.close();cout<<" "<<"id"<<" "<<"name"<<" "<<"code"<<" "<<"shortname"<<" "<<"LName"<<endl;for(i=0;i<view_count;i++)cout<<" "<<views[i].id<<" "<<views[i].name<<" "<<views[i].code<<" "<<views[i].shortname<<" "<<views[i].LName<<endl; }void readways() //读文件ways.txt{int i;ifstream infile("ways.txt",ios::in); //打开文件infile>>way_count; ////把文件中的记录赋值给way_countif(!infile) //打开文件失败{cerr<<"open error!"<<endl;exit(1);}for(i=0;i<way_count;i++)infile>>ways[i].station1>>ways[i].station2>>ways[i].dist;infile.close();//测试用，输出路段的信息cout<<" "<<"station1"<<" "<<"station2"<<" "<<"dist"<<endl;for(i=0;i<way_count;i++)cout<<" "<<ways[i].station1<<" "<<ways[i].station2<<" "<<ways[i].dist<<endl ;}void readlines() //读文件lines.txt{int i;ifstream infile("lines.txt",ios::in); //打开文件infile>>line_count; //把文件中的记录赋值给line_countif(!infile) //打开文件失败{cerr<<"open error!"<<endl;exit(1);}for(i=0;i<line_count;i++)infile>>lines[i].Lid>>lines[i].LName>>lines[i].start_id>>lines[i].end_id>>lines[i].dist>>lines[i].s ign;infile.close();/*cout<<" "<<"Lid"<<" "<<"LName"<<" "<<"start_id"<<" "<<"end_id"<<" "<<"dist"<<" "<<"sign"<<endl;for(i=0;i<view_count;i++)cout<<" "<<lines[i].Lid<<" "<<lines[i].LName<<" "<<lines[i].start_id<<" "<<lines[i].end_id<<" "<<lines[i].dist<<" "<<lines[i].sign<<endl;*/ //这里是输出文件中的信息}void search () //查询车站信息（所在的铁路线）{cout<<"please enter the station name:";char sta_name[20];cin>>sta_name; //输入要查询的名字cout<<endl;ifstream infile("views.txt ",ios::in); //读文件infile >>view_count ; //读出文件记录的个数if(!infile) //打开文件失败{cerr<<"open error!"<<endl;exit(1);}int i,mark;for(i=0;i<view_count;i++)infile>>views[i].id>>views[i].name>>views[i].code>>views[i].shortname>>views[i].LName;infile.close();for(i=0;i< view_count;i++){if(strcmp(sta_name,views [i].name)==0) //找到车站{cout<<"the station's informations is:\n"<<endl;cout<<" "<<"id"<<" "<<"name"<<" "<<"code"<<" "<<"shortname"<<" "<<"LName"<<endl;cout<<" "<<views[i].id<<" "<< views[i].name<<" "<< views [i].code<<" "<< views [i].shortname<<" "<< views [i].LName <<endl;break;}mark=i;}if(mark==( view_count -1)) //若没有找到，输出提示{cout<<"sorry,the station is not in here"<<endl;}}void addview(){cout<<"please enter the new view's informations:"<<endl; //输入新车站信息cout<<"id:";cin>>views[view_count].id;cout<<"name:";cin>>views[view_count].name;cout<<"code:";cin>>views[view_count].code;cout<<"shortname:";cin>>views[view_count].shortname;cout<<"LName:";cin>>views[view_count].LName;ofstream outfile("views.txt",ios::app); //打开views文件,并且写入数据outfile<<view_count<<endl;if(!outfile) //文件打开失败{cerr<<"open error!"<<endl;exit(1);}outfile<<views[view_count].id<<" "<<views[view_count].name<<" "<<views[view_count].code<<" " <<views[view_count].shortname<<" "<<views[view_count].LName<<endl;//在文件末尾添加view_count=view_count+1;outfile.close(); //关闭文件cout<<"successfully! the new station is added"<<endl;cout<<"now station number is:"<<view_count<<endl;}void addway(){cout<<"please enter the new way's informations:"<<endl; //输入新车站信息cout<<"station1:";cin>>ways[way_count].station1; // station1的idcout<<"station2:";cin>>ways[way_count].station2; //station2的idcout<<"dist:";cin>>ways[way_count].dist; //路段的长度ofstream outfile("ways.txt",ios::app); //打开way.txt文件outfile<<way_count<<endl;if(!outfile) //文件打开失败{cerr<<"open error!"<<endl;exit(1);}outfile<<ways[way_count].station1<<" "<<ways[way_count].station2<<" "<<ways[way_count].dist;//在文件末尾添加outfile.close(); //关闭文件cout<<"successfully! the new station is added"<<endl;way_count=way_count+1;cout<<"now station number is:"<<view_count<<endl;}void addline(){cout<<"please enter the new line's informations:"<<endl; //输入新铁路线信息cout<<"Lid:";cin>>lines[line_count].Lid;cout<<"LName:";cin>>lines[line_count].LName;cout<<"start_id:";cin>>lines[line_count].start_id;cout<<"end_id:";cin>>lines[line_count].end_id;cout<<"dist:";cin>>lines[line_count].dist;cout<<"sign:";cin>>lines[line_count].sign;ofstream outfile("lines.txt",ios::app); //打开文件outfile <<line_count << endl;if(!outfile) //文件打开失败{cerr<<"open error!"<<endl;exit(1);}outfile<<lines[line_count].Lid<<" "<<lines[line_count].LName<<" "<<lines[line_count].start_id<<" " <<lines[line_count].end_id<<" "<<lines[line_count].dist<<lines[line_count].sign<<endl;//在文件末尾添加outfile.close(); //关闭文件cout<<"successfully! the new line is added"<<endl;line_count=line_count+1;cout<<"now line number is:"<<line_count<<endl;}//-----------------------------------------------------------------------------------void floyed() //弗洛伊德（Floyed）算法{int i, j, k, m, start_num, end_num; //i,j用来表示起始点和终点int dist_list[SIZE_view][SIZE_view]; //定义了一个数组view_count=view_count+1;struct path_info path_list[SIZE_view][SIZE_view]; //定义了一个path_info结构的变量，包含着count和path[]用来存储经过的路径for(i=1;i<=view_count;i++) //这里开始读文件，先让所有的线都为最大值for(j=1;j<=view_count;j++)dist_list[i][j]=MAXCOST;for(int t=0;t<=way_count;t++){i=ways[t].station1;j=ways[t].station2;dist_list[i][j]=ways[t].dist;//把文件中的数据赋值给dist_list[i][j]=ways[t].dist;形式}for (i =0; i< view_count; i++){for (j= 0; j<view_count; j++){if (i == j){dist_list[i][j] = 0;continue;}dist_list[i][j] = -1;path_list[i][j].count = 0;for (k = 0; k< way_count; k++) //{if (ways[k].station1 == i && ways[k].station2 == j) //把起始点和终点分别给予i，j{dist_list[i][j] = ways[k].dist;path_list[i][j].count = 2;path_list[i][j].path[0] = i;path_list[i][j].path[1] = j;break;}}}}for (k = 0; k<= view_count-1; k++){for (i = 0; i < view_count; i++)for (j = 0; j< view_count; j++){if (i == k || j == k || i == j)continue;if (dist_list[i][k] == -1 || dist_list[k][j] == -1)continue;if ( (dist_list[i][j] == -1) ||((dist_list[i][j] != -1) &&(dist_list[i][k] + dist_list[k][j] < dist_list[i][j]))){dist_list[i][j] = dist_list[i][k] + dist_list[k][j];// shortest[i][j]=shortest[i][k]+shortest[k][j];path_list[i][j].count = path_list[i][k].count + path_list[k][j].count - 1;// path[i][j]=k;for (m = 0; m < path_list[i][k].count; m++)path_list[i][j].path[m] = path_list[i][k].path[m];for (m = 0; m < path_list[k][j].count; m++)path_list[i][j].path[m+path_list[i][k].count] = path_list[k][j].path[m+1];}}}cout<<" Floyed table:\n";cout<<" All views in the school:\n";for (i = 0; i < view_count-1; i++)cout<<" "<<i+1<<":"<<views[i].name<<endl;cout<<" Please input the start number: ";cin>>start_num;cout<<" Please input the end number: ";cin>>end_num;cout<<endl<<endl;cout<<"From"<<views[start_num-1].name<<"to"<<views[end_num-1].name;if (dist_list[start_num][end_num] == -1)cout<<"no way."<<endl;else{cout<<"distance is "<<dist_list[start_num][end_num]<<", and path is :";//dist_list[][]用来表示两点间的长度k = path_list[start_num][end_num].path[0]-1; //path_list[][]用来保存路径path[m]在这里表明是通过的那个车站的cout<<views[k].name;for (m = 1; m < path_list[start_num][end_num].count; m++){k = path_list[start_num][end_num].path[m]-1; //这里应该也是int型，k是经过的路径的idcout<<"->"<<views[k].name;}}cout<<endl<<endl;}void main(){readviews();readlines() ;readways();while(1){int menu;cout<<endl<<endl<<endl<<endl;cout<<" 全国铁路运输网最佳经由系统"<<endl;cout<<"**********************************************************"<<endl;cout<<" 1:增加车站信息"<<endl;cout<<" 2:增加铁路线信息"<<endl;cout<<" 3:查询车站信息"<<endl;cout<<" 4:查询最短路径"<<endl;cout<<" 5:退出界面"<<endl;cout<<"**********************************************************"<<endl;cout<<"输入要进行的操作的代码（1--5):"<<endl;cin>>menu;while(menu<1||menu>5){cout<<"error!please enter again:";cin>>menu;}switch(menu){case 1:while(1){addview();while (1){addway();cout<<"do you want to continue (y/n) "<<endl;char con ;cin>>con;if(con=='y')addway();elsebreak;}cout<<"do you want to continue (y/n) "<<endl;char con ;cin>>con;if(con=='y')addview();elsebreak;}break;case 2:while(1){addline();cout<<"do you want to continue (y/n) "<<endl;char con ;cin>>con;if(con=='y')addline();elsebreak;}break;case 3:while(1){search ();cout<<"do you want to continue (y/n) "<<endl;char con ;cin>>con;if(con=='y')search ();elsebreak;}break;case 4:while(1){floyed();cout<<"do you want to continue (y/n) "<<endl;char con ;cin>>con;if(con=='y')floyed();elsebreak;}break;case 5:{cout<<"谢谢使用，再见！"<<endl;exit(1);}}}}。