校园导游系统程序--课程设计-报告【范本模板】

1、需求分析
设计一个校园导游系统程序，为来访的客人提供各种服务的信息查询。

（1）。

设计工商学院校园无向图,所含的景点不少于10个.以图中顶点表示校内各景点，存放景点名称、代号、简介等信息;以边表示路径，存放路径长度等相关信息。

（2）。

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

(3）。

为来访客人提供图中任意景点的问路查询,即查询任意两个景点之间的一条最短的简单路径。

2、设计思路
校园旅游模型是由景点和景点之间的路径组成的，所以这完全可以用数据结构中的图来模拟.用图的结点代表景点，用图的边代表景点之间的路径.所以首先应设计一个图类.结点值代表景点信息,边的权值代表景点间的距离。

结点值及边的权值用顺序表存储，所以需要设计一个顺序表类。

本系统需要查询景点信息和求一个景点到另一个景点的最短路径长度及路线，为方便操作，所以给每个景点一个代码，用结构体类型实现。

计算路径长度和最短路线时可用弗洛伊德(Floyd）算法实现。

最后用switch选择语句选择执行浏览景点信息或查询最短路径。

3 算法设计
3。

1 概要设计
3。

1。

1 程序中包含的模块
(1）主程序模块
主函数：void main(void）
void cmd(void) cmd修改显示框大小，字体背景颜色，初始化景点，景点
信息打印菜单,
MGraph InitGraph（void）; //初始化图。

MGraph * CreatUDN(MGraph ＊G)；//初始化图形接受用户输入
void Menu（void）；//菜单函数
void Browser(MGraph *G)；//浏览函数
void ShortestPath_DIJ（MGraph *G);
void Floyd（MGraph ＊G)；//查询图中任意两个景点间的所有路径
void Search（MGraph ＊G）；//查找函数
int LocateVex(MGraph ＊G，char＊v）; // 迪杰斯特拉算法计算起点各顶点
间短路径，
void print（MGraph ＊G）；//输出函数
（2）查询模块
景点信息查询:void introduce()
最短路径查询:要查找的两景点的最短距离：用floyd算法求两个景点的最短路径：
（3）打印模块：void print(MGraph ＊G）；
3。

1.2模块间的调用关系
主函数main（)调用void cmd（void）调用menu 并且用switch设置开关语句。

3.2 详细设计
3。

2.1定义符号变量
＃define INFINITY 1000 /＊穷*/
#define MAX_VERTEX_NUM 40/＊定义全局变量＊/
创建两个类存储景点信息和存储景点道路和长度
typedef struct ArCell //邻接矩阵
｛
int adj; //存储路径长度
}ArCell，AdjMatrix［MAX_VERTEX_NUM][MAX_VERTEX_NUM］；
typedef struct //图顶点表示主要景点存放景点编号、名称、简介等信息
｛
char name［20］;
int num；
char introduction[60］；//简介
}infotype;
typedef struct//图中的边表示景点间的道路，存放路径长度等信息。

{
infotype vexs[MAX_VERTEX_NUM］;//顶点信息域
AdjMatrix arcs;
int vexnum，/*顶点数＊/ arcnum；//边个数
｝MGraph;
MGraph b；
3.2。

2自定义函数原型说明
给出函数声明
void cmd（void)；
MGraph InitGraph(void);
void Menu(void);
void Browser（MGraph *G）；
void ShortestPath_DIJ（MGraph ＊G);
void Floyd(MGraph ＊G）；
void Search(MGraph ＊G);
int LocateVex（MGraph *G,char＊v)；MGraph ＊CreatUDN（MGraph ＊G）；void print(MGraph *G)；
3。

2。

3定义各顶点之间的距离:
for(i=0;i〈G.vexnum;i++）
for（j=0；j<G.vexnum；j++）
G.arcs［i］［j］.adj=INFINITY;
G。

arcs[0][1］。

adj=80;/*路径度*/
G.arcs［0］［2］.adj=180;
G。

arcs[0］[6].adj=200;
G。

arcs［1]［11］.adj=120;
G。

arcs[1］[2］.adj=100;
G。

arcs[2][5]。

adj=50；
G.arcs[3][4]。

adj=60；
G.arcs[4］［9].adj=140；
G。

arcs［5］[9].adj=250；
G。

arcs［5][7］.adj=150；
G.arcs[6][7］。

adj=190;
G.arcs［6］［9］.adj=150;
G.arcs[8][7］。

adj=130；
G.arcs[8]［6].adj=50；
G.arcs[10]［12］.adj=100；
G。

arcs[9]［10］。

adj=150;
G。

arcs[3］[4].adj=190；
G.arcs[5］[13].adj=150；
G.arcs［14]［7].adj=350;
G.arcs［2]［3]。

adj=190；
G.arcs［2][9]。

adj=150;
G。

arcs[2][11］.adj=120；
G.arcs[0］[8]。

adj=120;
G。

arcs[1]［2]。

adj=50；
G.arcs［10］［12].adj=170；
G.arcs［12][15］。

adj=160；
for（i=0;i〈G.vexnum;i++）
for（j=0；j〈G。

vexnum；j++）
G。

arcs［j］[i］。

adj=G。

arcs[i]［j]。

adj；
return G;
3。

2.4界面菜单设计：菜单选择
void Menu（)
｛
printf(”\n 武汉工商学院院导游图\n”）；
printf（”┏━━━━━━━━━━━━━━━━━━━━┓\n")；printf(”┃1。

浏览校园全景┃\n"）；printf（" ┃ 2.查看所有游览路线┃\n"）; printf（”┃3。

确定两景点之间最短距离┃\n"）; printf（" ┃4。

查看景点信息┃\n”)；printf（" ┃5。

退出导游系统┃\n")；printf(" ┗━━━━━━━━━━━━━━━━━━━━┛\n”); printf（"Option-:");
}
Menu（）；
scanf("%d”，＆i）；
while（i!=5)
{
switch（i)
｛
case 1:system("cls”）；Browser（&b）;Menu（);break；
case 2:system（”cls”)；ShortestPath_DIJ（&b)；Menu（);break;
case 3：system（”cls”）；Floyd(&b）;Menu()；break;
case 4：system("cls")；Search(&b）；Menu();break；
case 5:exit（1）；break;
default:break;
｝
3。

2.6介绍景点：
void Browser（MGraph ＊G)
｛
int v;
printf（"┏━━┳━━━━━━━━━━┳━━━━━━━━━┓\n"）；
printf（"┃编号┃景点名称┃简介┃\n"）；
printf(”┗━━┻━━━━━━━━━━┻━━━━━━━━━┛\n”)；
for（v=0;v〈G->vexnum；v++)printf（"┃％—4d┃%—20s┃％—60s \n”,G-〉vexs［v］.num，G—〉vexs［v]。

name，G->vexs[v］.introduction）；
printf(”┗━━┻━━━━━━━━━━┻━━━━━━━━━┛\n”)；
}
3。

2.7要查找的两个景点的最短距离:
用floyd算法求两个景点的最短路径
void Floyd(MGraph ＊G）// 查询图中任意两个景点间的所有路径。

｛int v，u,i，w，k，j，flag=1,p[20]［20][20］，D［20]［20］；
for（v=0；v〈G->vexnum;v++)
for(w=0；w<G—>vexnum；w++)
｛D［v］[w]=G—〉arcs［v］［w].adj;
for（u=0；u〈G—>vexnum;u++）
p[v]［w][u］=0；
if(D[v］［w]<INFINITY)
｛p［v］［w]［v］=1；p[v]［w]［w］=1；}
｝
for(u=0；u<G-〉vexnum;u++）
for(v=0;v〈G—>vexnum;v++)
for(w=0;w<G->vexnum；w++)
if（D［v］［u]+D［u］［w]〈D[v]［w])
｛D[v］[w］=D[v］［u］+D[u]［w]；
for(i=0；i〈G—>vexnum；i++)
p［v]［w]［i］=p［v］［u][i］｜|p[u］[w]［i］; ｝
while（flag）
｛printf（”请输入出发地编号：")；
scanf（”％d”,&k）；
if(k<0｜｜k〉G-〉vexnum）
{ printf("景点编号存!\n请输入出发地编号:");
scanf（"％d"，&k); }
printf（"请输入目的地编号:"）;
scanf(”％d",＆j);
if（j<0||j〉G—>vexnum)
｛printf（”景点编号存！\n请输入目的地编号:”)；
scanf（”%d”，＆j)；}
if（k〉=0＆＆k〈G-〉vexnum＆＆j>=0＆＆j<G—〉vexnum）
flag=0; ｝
printf（"%s”，G—>vexs［k].name）；
for（u=0;u〈G—〉vexnum;u++）
if（p［k］［j]［u］&&k！=u&&j！=u）
printf（"——>%s"，G—〉vexs[u].name）；
printf（”-->%s”,G—〉vexs［j]。

name);
printf（" 总路线%dm\n"，D［k]［j］）；}
3。

2.8查看所有游览路线
迪杰斯特拉算法计算单源最短路径，引进一个辅助向量D，它的每个分量D表示当前所找
到的从始点v0到每个终点vi的最短路径的长度。

若从v到vi有弧，则D为弧上的权值；否则置D为∞。

4 测试分析
4.1 主程序界面
主程序从void main（)开始运行void cmd（void）cmd修改显示框大小，字体背景颜色,初始化景点,景点信息的赋值初始化无向邻接图b=InitGraph（）；调用menu菜单函数打印菜单，提示用户输入选择功能.
图4-1。

主程序界面
4.2 浏览景点信息
输出浏览比较简单就是把原来的景点信息利用for循环输出,int v=0;v小于最多的景点个数输出景点信息.依次输出.
图4-2 浏览景点信息
4.3查看所有游览线路
查看所有路线是使用void ShortestPath_DIJ(MGraph ＊G)// 迪杰斯特拉算法计算起点各顶点间短路径,然后利用for循环输出计算的结果。

输入景点不正确时会输出景点不存在请重新输入景点编号。

图4—3:查看所有游览路线
4。

4 确定两景点之间最短距离
利用void Floyd（MGraph *G)//函数利用循环嵌套查询图中存在的任意两个景点间的最短路径再利用循环输出，如果景点不存在将会输出景点不存在请输入出发地（目的地）编号.
图4—4：确定两景点之间最短距离
4。

5 查看景点信息
利用void Search(MGraph ＊G)//函数,查看景点信息查找景点编号，当输入景点编号不在范围时输出“景点编号不存在请重新输入编号:”输入正确时输出景点信息。

图4-5：查看景点信息
5系统功能及实现
5.1 主程序界面
定义一个I，然后，调用InitGraph（)函数初始化图,再调用menu（）函数,再输入选择,利用switch开关语句,用户选择,需要的功能，实现想要的。

.
Int i
1.浏览校园全景
i=?
2.
查
看
所
有
路
线
3.
两
景
点
最
短
距
离
4.
查
看
景
点
信
息
5.
退
出
导
游
系
统
12345
图5-1。

主程序界面
5.2 浏览景点信息
定义v；用for循环for(v=0；i<G。

vexnum;v++）当条件成立的时候执行printf语句,直到循环不成立的时候输出结束,
图5-2 浏览景点信息
5。

3查找所有游览线路
查找路径利用,迪杰斯特拉算法，第1重循环for(x=0;x<G->vexnum；x++)//第1重循环条件成立时执行p[w］［x］=p[v］[x]；不成立时结束循环。

图5—：3—1：查找所有游览路线
第2重循环for（w=0；w〈G—>vexnum;w++)循环条件成立的时候执行if(！final[w］＆＆
（min+G—〉arcs[v］［w］。

adj〈D[w]））
{ D［w］=min+G—〉arcs［v]［w]。

adj;第一重循环p［w][w］=1; } 循环不成立时循环结束
图5—：3—2：查找所有游览路线
第3重循环定义一个w ,利用for循环for(w=0；w<G—>vexnum;w++）当循环体成立时if（！final[w]）if(D[w］<min)｛ v=w;min=D[w］;}
final［v］=1; 第2重for循环} 循环条件不成立循环终止结束跳出到第四重循环执行i++.
图5—:3-3：查找所有游览路线
第4重for循环定义I，利用for（i=0；i〈G->vexnum;i++)循环条件成立的时候执行{ min=INFINITY；以及第3重for循环里面的代码直到循环条件不成立，循环结束然后利用for输出查找结果如图5-3—4
Int i
i++
for(i=1;i<G->vexnum;)//第4重for循环
Y
{ min=INFINITY;
第3重for循环 }
N
结束
图5-3-4：查看所有游览路线(第4重循环)
这是查看所有路线功能里的输出循环，定义v ,i整型变量然后利用for(v=0；v<G->vexnum;v++)
判断if(v0！=v)如果成立执行｛ printf（"％s”,G—〉vexs[v0]。

name）; ｝然后执行
第二重 for(w=0;w<G—〉vexnum;w++）
｛ if（p［v］[w]＆&w!=v0）｛ printf（"-—>%s”,G-〉vexs[w]。

name）；｝t++； }
if(t〉G-〉vexnum＆＆v0！=v)printf(”总路线%dm\n\n”,D［v]）; 第1重循环结束后跳到第1重v++直到外重循环循环条件不成立循环结束
图5-3—5:查看所有游览路线
5。

4 确定两景点之间最短距离
利用多个for循环嵌套，计算出路径,计算出路径长度,当最外重循环不成立时循环结束。

利用for循环输出
图5-4—2:确定两景点之间最短距离
6总结
经过近两周的课程设计，总的来说收获还是很大的！
首先代码能力明显提高,有了想法基本都能顺利表达出来;再者就是数据结构的选择使用能力也有了很大的提高！虽说平时的试验课我们也有用各种数据做题，但那些都是很明确的知道该做什么操作,存什么，我们的发挥空间不大一般照做就行,然而这次实习我们却在自主的选择判断，这本身就是一个很大的提高！还有就是算法方面的学习有了初步进阶，如最短路径，这样比较简单的图论算法能比较熟练的写出来.但是还是有很多的只是不了解！
收获真的很多,但是最大的收获可能就是对编程的兴趣吧，在一次次的改错，一次次的完成想要的效果后，越写越有感觉！当然还收获了无知，更确切的说是自知，原来我们现在什么也不算，还有很多有用的只是等着我们去学习!
7 参考文献
[1] 谭浩强.C程序设计（第四版）［M]. 北京：清华大学出版社，2010:293—326.
［2] 苏小红，孙志岗，陈惠鹏.C语言大学实用教程（第三版）［M］。

北京：电子工业出版社，2012：240—280.
［3］林锐.高质量C++/C编程指南［M］.北京:清华大学出版社2001。

7：245-278。

[4］陈朔鹰,陈英。

C语言程序设计习题集（第二版）［M].北京：人民邮电出版社，2003。

2:320-360.
［5] 谭浩强.C语言程序设计题解与上机指导[M]。

北京：清华大学出版社，2000.11：12-60.
［6］塞奇威克。

算法:C语言实现［M]. 北京：机械工业出版社,2009：213—225。

[7] 里斯.深入理解C指针［M]。

北京：人民邮电出版社,2014：103—122。

[8] 陈正冲。

C语言深度解剖（第2版）［M］。

北京:北京航空航天大学出版社，2012:34—42.
［9］贾宗璞.C语言程序设计［M].江苏:中国矿业大学出版社,2007。

6：112—135。

［10]周海燕，赵重敏，齐华山。

C语言程序设计[M］. 北京:科学出版社,2001:165—187.
8附录
＃define INFINITY 100000000 /＊穷＊/
＃define MAX_VERTEX_NUM 40
#define MAX 40
＃include〈stdlib。

h>
#include<stdio。

h>
#include〈conio。

h〉
#include〈string。

h>
typedef struct ArCell
{
int adj; //路径度
}ArCell，AdjMatrix［MAX_VERTEX_NUM]［MAX_VERTEX_NUM］;//邻接矩阵typedef struct //图顶点表示主要景点存放景点编号、名称、简介等信息
｛
char name[20］；
int num;
char introduction[60];//简介
｝infotype;
typedef struct//图中的边表示景点间的道路,存放路径长度等信息。

｛
infotype vexs[MAX_VERTEX_NUM];//顶点信息域
AdjMatrix arcs;
int vexnum,/＊顶点数＊/ arcnum；//边个数
}MGraph；
MGraph b;
void cmd（void）;
MGraph InitGraph（void);
void Menu(void);
void Browser（MGraph *G）;
void ShortestPath_DIJ(MGraph ＊G）;
void Floyd(MGraph *G）;
void Search(MGraph *G);
int LocateVex(MGraph ＊G，char*v）；
MGraph ＊CreatUDN（MGraph *G)；
void print（MGraph *G）；
/***＊＊＊*＊**＊**＊＊＊*＊＊**＊***＊**＊＊***＊＊*＊******＊＊＊****＊**＊/ void main(void)
{
system（"color 0f”);
system（"mode con：cols=150 lines=140”）；
cmd();
}
/*＊＊＊*＊**＊*＊**＊*＊＊＊＊＊*＊*＊＊*＊＊＊＊＊***＊＊**＊***＊*＊**＊＊＊*＊**/
void cmd（void）
｛
int i；
b=InitGraph()；
Menu();
scanf（”％d”，＆i);
while（i！=5）
｛
switch（i）
{
case 1:system（"cls")；Browser（＆b); Menu（);break;//1。

浏览校园全景
case 2:system（"cls"）; ShortestPath_DIJ（＆b)；Menu();break;//2.查看所有游览路线case 3：system("cls"）; Floyd(&b)；Menu（); break；//3。

确定两景点之间最短距离case 4：system（"cls"）；Search（&b）; Menu（）;break;//4。

查看景点信息
case 5：exit（1）;break；
default:break；
}
printf（”请重新输入(1—5)：”）;
scanf（”%d"，＆i)；
}
｝
MGraph InitGraph(void）//初始化
｛
MGraph G；
int i,j;
G。

vexnum=16；
G.arcnum=40;
for（i=0；i〈G。

vexnum；i++)
G.vexs［i]。

num=i；
strcpy(G。

vexs[0].name,”唐人街”）;
strcpy(G.vexs［0］.introduction，”学校门口小吃街”）；
strcpy(G。

vexs［1].name，”校大门"）;
strcpy（G.vexs［1］。

introduction,"学校大门是学校的门面”）;
strcpy(G.vexs[2]。

name,”校综合楼")；
strcpy（G。

vexs［2]。

introduction,”全体教师办公场所楼高12层各种设施齐全”)；
strcpy(G。

vexs［3]。

name,”体育馆足球场"）；
strcpy（G。

vexs[3］。

introduction，"体育馆一楼为室内羽毛球乒乓球馆,室外为塑胶跑道，晚上散步”）;
strcpy(G。

vexs［4］.name，"医务室");
strcpy(G.vexs[4］.introduction,"体育馆一楼为医用费用较贵。

”）；
strcpy（G。

vexs［5]。

name,"外语楼”)；
strcpy(G.vexs［5].introduction，”校第二教学楼,共7层环形环境优美，适宜学习"）;
strcpy(G.vexs［6].name,”5 号宿舍楼”)；
strcpy(G。

vexs[6]。

introduction,"多个学院女生宿舍楼位于弘德楼旁边”）;
strcpy(G。

vexs[7]。

name，"湖边小树林”)；
strcpy(G.vexs［7］。

introduction，”绿树荫阴,适宜休息晨读还有小情侣约会”)；
strcpy(G。

vexs[8]。

name,”弘德楼”)；
strcpy（G。

vexs［8]。

introduction,”全校最高建筑物弘德楼一楼与二楼是学生第一食堂"）;
strcpy(G.vexs[9］。

name，"图书馆”)；
strcpy(G.vexs[9］.introduction，”藏书145万册,设施优良一楼有咖啡厅环境优雅2楼设有电子阅览室”)；
strcpy(G。

vexs［10］.name，"静思湖");
strcpy（G.vexs［10].introduction,"校内湖,环境好内有荷花湖上还造了回心转意桥夏天荷花漂亮”)；
strcpy(G。

vexs[11］。

name,"第三教学楼”);
strcpy(G。

vexs［11］.introduction,"校第三教楼为实验楼,环境好内设物理化学实验室和电脑机房”）;
strcpy（G.vexs[12]。

name,”学生第二食堂"）；
strcpy(G.vexs［12].introduction,"环境比较好，饭菜还可以")；
strcpy(G。

vexs［13]。

name，"1 2 3 4 号宿舍楼”）；
strcpy(G。

vexs［13].introduction，"1 3 号是学院女生宿舍楼,2 4号是男生宿舍楼”）;
strcpy（G。

vexs［14］。

name,"6 号宿舍楼"）；
strcpy(G.vexs[14］.introduction，"6 栋是学校的鸳鸯楼就是男生半栋女生半栋楼"）;
strcpy（G。

vexs［15].name，”黄家湖”)；
strcpy（G。

vexs[15］。

introduction,”位于学校足球场旁边生态湖,可以在那钓鱼"）；
for(i=0;i<G.vexnum；i++)
for（j=0；j<G.vexnum；j++)
G.arcs[i］［j].adj=INFINITY;
G.arcs［0]［1］.adj=80;/*路径度＊/
G。

arcs[1］［11］。

adj=110；
G。

arcs[1］[2］.adj=50;
G.arcs[1]［5］.adj=90;
G。

arcs［2][11］.adj=65;
G.arcs[2]［5］。

adj=90;
G.arcs［2]［10].adj=85;
G。

arcs［2］［9］.adj=90;
G.arcs［2]［3］.adj=150;
G。

arcs[5][9]。

adj=80;
G。

arcs［5］[3］。

adj=70；
G.arcs［5］［13].adj=40;
G。

arcs[13]［8］.adj=50;
G。

arcs［13]［3]。

adj=100;
G.arcs[13][5]。

adj=80；
G.arcs［8］［6］。

adj=55;
G。

arcs[8］［7］。

adj=50；
G。

arcs［6][4]。

adj=55；
G。

arcs[9］［10].adj=45；
G.arcs［9］［3]。

adj=65;
G.arcs［10][14].adj=120；
G。

arcs［10][12].adj=150；
G.arcs[12］[14］。

adj=170;
G.arcs[10][12］.adj=170;
G.arcs［12][15］.adj=160;
G.arcs［9]［10］.adj=150;
G.arcs[10］[12］.adj=100；
G.arcs［12］［15］。

adj=160;
G。

arcs［14］［7］.adj=150；
for(i=0；i<G.vexnum；i++）
for(j=0;j〈G.vexnum;j++）
G。

arcs［j][i］.adj=G.arcs［i][j]。

adj；
return G；
}//InitGraph end
void Menu(）//菜单
{
printf（”\n 武汉工商学院院导游图\n”); printf(”┏━━━━━━━━━━━━━━━━━━━━┓\n");
printf（”┃1。

浏览校园全景┃\n");
printf(”┃ 2.查看所有游览路线┃
printf(”┃ 3.确定两景点之间最短距离┃\n”）；
printf(”┃4。

查看景点信息┃\n”）;
printf(”┃5。

退出导游系统┃\n”）；
printf(" ┗━━━━━━━━━━━━━━━━━━━━┛\n")；
printf（"Option—："）；
}
void Browser（MGraph *G)//浏览
{
int v;
printf（”┏━━┳━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n”）；
printf(”┃编号┃景点名称┃简介┃\n"）;
printf(”┗━━┻━━━━━━━━━━┻━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛\n”)；
for(v=0；v<G-〉vexnum；v++)
printf("┃％—4d┃％—20s┃％-60s \n",G->vexs[v]。

num,G->vexs[v]。

name，G—〉vexs[v].introduction）；
printf（”┗━━┻━━━━━━━━━━┻━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛\n")；
｝
void ShortestPath_DIJ(MGraph * G)// 迪杰斯特拉算法计算起点各顶点间短路径查找所有路线
｛
int v，w，i,min,t=0，x，flag=1,v0;
int final[20］，D[20], p［20］[20］;
while（flag)
｛
printf(”请输入起始景点编号:")；
scanf（”％d”,&v0)；
if(v0<0｜｜v0>G->vexnum)
｛
printf("景点编号存！请重新输入景点编号:"）；
scanf（”％d”,＆v0);
｝
if（v0>=0＆＆v0<G->vexnum)
flag=0;
}
for（v=0；v〈G-〉vexnum；v++)
final［v]=0;
D［v]=G—〉arcs[v0］[v］。

adj;//存储起始v0—末尾v之间权值
for(w=0;w〈G->vexnum;w++）
p[v][w］=0；
if（D［v]〈INFINITY）
{
p[v][v0］=1；p[v][v］=1;
}
｝
D［v0]=0;final［v0］=1；
for（i=1;i〈G—〉vexnum；i++）
{
min=INFINITY;
for（w=0；w〈G->vexnum；w++)
if（！final［w])
if（D[w]〈min)｛v=w；min=D[w];}
final[v］=1;
for(w=0；w〈G—>vexnum;w++)
if(!final［w］&＆(min+G->arcs[v]［w].adj<D[w]）)
{
D［w]=min+G-〉arcs［v］[w]。

adj;
for(x=0;x<G->vexnum；x++)
p[w][x]=p［v]［x];
p［w］［w]=1;
｝
}
for(v=0；v<G->vexnum；v++)
｛
if(v0！=v) printf（"%s”，G—>vexs[v0］.name);
for（w=0;w<G-〉vexnum；w++)
{
if（p［v]［w]＆&w!=v0)
printf（”-—〉%s”,G—〉vexs[w]。

name）;
t++；
｝
if（t>G->vexnum&＆v0!=v)printf（" 总路线%dm\n\n”,D［v]); ｝
｝//ShortestPath_DIJ end
void Floyd(MGraph ＊G)// 查询图中任意两个景点间的最短路径。

｛
int v,u,i,w,k，j，flag=1，p［20］[20]［20],D[20］［20］；
for（v=0；v<G—〉vexnum；v++)
for（w=0；w〈G—>vexnum;w++)
{
D［v]［w]=G-〉arcs［v］[w］。

adj；
for（u=0；u<G—〉vexnum；u++）
p[v］［w][u]=0；
if（D[v]［w]〈INFINITY)
｛
p［v］[w]［v］=1；p［v]［w］[w］=1；
}
}
for（u=0；u<G—>vexnum;u++)
for（v=0;v<G—〉vexnum；v++）
for（w=0；w〈G-〉vexnum;w++）
if(D［v][u]+D［u］［w］〈D［v］［w]）
｛
D［v］［w］=D［v][u］+D［u]［w]；
for(i=0；i<G->vexnum;i++）
p[v］［w]［i］=p[v][u][i]｜|p［u][w]［i]；
｝
while(flag)
｛
printf("请输入出发地编号:"）;
scanf("％d",&k）；
if(k〈0｜｜k>G-〉vexnum）
｛
printf("景点编号存!\n请输入出发地编号：”）；
scanf（"%d"，&k）；
｝
printf("请输入目的地编号：”）;
scanf("％d”，＆j）；
if(j〈0｜|j〉G->vexnum）
｛
printf(”景点编号存！\n请输入目的地编号：");
scanf（”%d",＆j)；
}
if（k〉=0&＆k<G->vexnum&＆j〉=0&&j〈G—>vexnum) flag=0;
｝
printf（”%s”,G->vexs[k］。

name)；
for(u=0；u〈G—〉vexnum;u++)
if（p［k]［j]［u］＆&k!=u&&j！=u）
printf("-—〉％s”，G->vexs[u]。

name);
printf（”-—〉％s”，G->vexs［j］。

name);
printf（" 总路线％dm\n”,D［k］［j])；
}//Floyd end
void Search(MGraph *G)//查找
｛
int k,flag=1;
while(flag)
{
printf（"请输入要查询景点编号:”)；
scanf（”％d”，&k）；
if（k〈0｜｜k〉G->vexnum）
{
printf（"景点编号存在! 请重新输入景点编号:”）;
scanf("％d",＆k）；
}
if（k〉=0&＆k〈G->vexnum）
flag=0；
｝
printf("┏━━┳━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n");
printf(”┃编号┃景点名称┃简介┃\n")；
printf(”┃％-4d┃％-20s ％-60s\n",G-〉vexs[k]。

num，G—〉vexs[k]。

name,G—〉vexs ［k］.introduction）；
printf(”┗━━┻━━━━┻━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛\n”);
｝//Search end
int LocateVex(MGraph ＊G，char* v）
｛
int c=—1,i;
for（i=0;i<G—〉vexnum；i++)
if（strcmp(v，G—>vexs［i].name)==0)
｛c=i;break;｝
return c;
｝
MGraph * CreatUDN(MGraph *G)//初始化图形接受输入
{
int i,j,k，w;
char v1[20],v2［20］；
printf（”请输入图顶点数,弧数:"）；
scanf（”%d％d”，&G-〉vexnum,＆G-〉arcnum);
printf(”请输入景点编号:、名称、简介：\n"）；
for（i=0;i<G->vexnum;i++)
｛
printf（”景点编号:"）;
scanf("％d",＆G—>vexs—〉num)；
printf（"景点名称："）;
scanf(”%s"，G—〉vexs[i].name）;
printf（”景点简介: ”）；
scanf（"%s",G—>vexs—〉introduction)；
}
for(i=0;i<G->vexnum;i++)
for（j=0；j〈G-〉vexnum；j++)
G—>arcs［i］[j］。

adj=INFINITY;
printf（"请输入路径度：\n”);
for（k=0;k<G—〉arcnum;k++）
{
printf（”第%d条边:\n",k+1)；
printf("景点(x,y）:"）；
scanf（”%s",v1）;
scanf（”%s"，v2）；
printf(”路径度:”)；
scanf（”%d”,&w）；
i=LocateVex(G，v1)；
j=LocateVex（G，v2);
if（i>=0&&j〉=0)
｛
G->arcs[i]［j]。

adj=w；
G—>arcs[j］［i]=G-〉arcs[i]［j］；
}
｝
return G；
｝
void print(MGraph ＊G）//输出
｛
int v,w，t=0；
for(v=0；v<G—〉vexnum；v++）
for（w=0；w<G->vexnum；w++）
｛if(G—>arcs[v]［w］.adj==INFINITY) printf("∞")；
else printf（”%-7d",G—〉arcs[v]［w].adj）；
t++;
if(t％G->vexnum==0）
printf("\n”)；
}
｝。