校园导游程序代码（校园导游程序设计）

本篇文章给大家谈谈校园导游程序代码，以及校园导游程序设计对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。

本文目录一览：

• 1、设计一个校园导游程序，（3）为来访客人提供从校门口到图中任意景点的问路查询；哪位大侠帮忙下，出错了~
• 2、求用C语言和数据结构中的无向图存储结构编一个校园导游图完全的程序代码？
• 3、求校园导游咨询程序（最短路径算法）

设计一个校园导游程序，（3）为来访客人提供从校门口到图中任意景点的问路查询；哪位大侠帮忙下，出错了~

#define INFINITY 10000 /*无穷大*/

#define MAX_VERTEX_NUM 40

#define MAX 40

#includestdlib.h

#includestdio.h

#includeconio.h

#includestring.h

typedef struct ArCell

{

int adj; //路径长度

}ArCell,AdjMatrix[MAX_VERTEX_NUM][MAX_VERTEX_NUM];// 邻接矩阵存储

typedef struct //图中顶点表示主要景点，存放景点的编号、名称、简介等信息，

{

char name[30];//景点名

int num;//景点编号

char introduction[100];//简介

}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);

int main(void)

{

cmd();

return 0;

}

void cmd(void)

{

int i;

b=InitGraph();

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;

}

scanf("%d",i);

}

}

MGraph InitGraph(void)

{

MGraph G;

int i,j;

G.vexnum=10;//十个结点

G.arcnum=14;//14条弧

for(i=0;iG.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,"3号学生宿舍楼");

strcpy(G.vexs[2].introduction,"室内环境最好的寝室楼");

strcpy(G.vexs[3].name,"医院");

strcpy(G.vexs[3].introduction,"校医院,设施不是很齐全，只能看小病，药费很便宜");

strcpy(G.vexs[4].name,"图书馆");

strcpy(G.vexs[4].introduction,"藏书量大，5楼可以上网");

strcpy(G.vexs[5].name,"足球场");

strcpy(G.vexs[5].introduction,"现代化塑胶跑道,人造草坪,晨练");

strcpy(G.vexs[6].name,"林荫路");

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,"灰色小楼，Triz理论基地");

for(i=0;iG.vexnum;i++)

for(j=0;jG.vexnum;j++)

G.arcs[i][j].adj=INFINITY;//初值赋值无穷大

G.arcs[0][1].adj=100;//赋值每条弧

G.arcs[0][2].adj=200;

G.arcs[0][6].adj=400;

G.arcs[1][7].adj=300;

G.arcs[2][3].adj=120;

G.arcs[3][6].adj=220;

G.arcs[3][4].adj=100;

G.arcs[4][5].adj=300;

G.arcs[4][9].adj=250;

G.arcs[5][9].adj=350;

G.arcs[6][7].adj=60;

G.arcs[6][9].adj=200;

G.arcs[7][8].adj=50;

G.arcs[8][9].adj=20;

for(i=0;iG.vexnum;i++)

for(j=0;jG.vexnum;j++)

G.arcs[j][i].adj=G.arcs[i][j].adj;//完全有向图邻接矩阵对称

return G;

}//InitGraph end

void Menu()

{

printf("\n 东北林业大学导游图\n");

printf(" 1.介绍东北林业大学主要景点 \n");

printf(" 2.主要景点浏览路线 \n");

printf(" 3.选择出发地和目的地 \n");

printf(" 4.选择你想了解的主要景点 \n");

printf(" 5.退出系统 \n");

printf("请您选择:");

}

void Browser(MGraph *G)

{

int v;

printf(" 编号 景点名称 简介 \n");

for(v=0;vG-vexnum;v++)//浏览所有景点信息

printf(" %-4d %-16s %-56s \n",G-vexs[v].num,G-vexs[v].name,G-vexs[v].introduction);

}

void ShortestPath_DIJ(MGraph * G)// 迪杰斯特拉算法来计算出起点到各个顶点之间的最短路径,v0为起点

{

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(v00||v0G-vexnum)

{

printf("景点编号不存在!请重新输入景点编号:");

scanf("%d",v0);

}

if(v0=0v0G-vexnum)//

flag=0;

}

for(v=0;vG-vexnum;v++)//初始化

{

final[v]=0;//所有顶点的最短路径还没确定

D[v]=G-arcs[v0][v].adj;//初始时的最短路径是v0到v边的值

for(w=0;wG-vexnum;w++)

p[v][w]=0;

if(D[v]INFINITY)//如果与源点有直接的弧则假定该弧即是当前最短路径

{

p[v][v0]=1;p[v][v]=1;

}

}

D[v0]=0;final[v0]=1;//初始化，v0顶点属于S集

for(i=1;iG-vexnum;i++)//寻找下一个确定其最短路径的v

{

min=INFINITY; //当前所知道的离v0最近的距离

for(w=0;wG-vexnum;w++)//v应是在S中且到源点最短路径长度最小的顶点

if(!final[w])

if(D[w]min){v=w;min=D[w];}//w顶点离v0更近

final[v]=1; //w加入s集合

for(w=0;wG-vexnum;w++)//出现了通过源点v的最短路径然后又到达w的最短路径

if(!final[w](min+G-arcs[v][w].adjD[w]))//更新

{

D[w]=min+G-arcs[v][w].adj;//当前最短路径为v的最短路径长度加v,w 的长度

for(x=0;xG-vexnum;x++) //当前最短路径为v的最短路径长度加v,w

p[w][x]=p[v][x];

p[w][w]=1;

}

}

for(v=0;vG-vexnum;v++)

{

if(v0!=v) printf("%s",G-vexs[v0].name);

for(w=0;wG-vexnum;w++)

{

if(p[v][w]w!=v0) printf("--%s",G-vexs[w].name);

t++;

}

if(tG-vexnum-1v0!=v)printf(" 总路线长%dm\n\n",D[v]);

}

}//ShortestPath_DIJ end

void Floyd(MGraph *G)//出发地和目的地的信息

{

int v,u,i,w,k,j,flag=1,p[10][10][10],D[10][10];

for(v=0;vG-vexnum;v++)

for(w=0;wG-vexnum;w++)

{

D[v][w]=G-arcs[v][w].adj;

for(u=0;uG-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;uG-vexnum;u++)

for(v=0;vG-vexnum;v++)

for(w=0;wG-vexnum;w++)

if(D[v][u]+D[u][w]D[v][w])

{

D[v][w]=D[v][u]+D[u][w];

for(i=0;iG-vexnum;i++)

p[v][w][i]=p[v][u][i]||p[u][w][i];

}

while(flag)

{

printf("请输入出发地和目的地的编号:");

scanf("%d%d",k,j);

if(k0||kG-vexnum||j0||jG-vexnum)

{

printf("景点编号不存在!请重新输入出发地和目的地的编号:");

scanf("%d%d",k,j);

}

if(k=0kG-vexnumj=0jG-vexnum)

flag=0;

}

printf("%s",G-vexs[k].name);

for(u=0;uG-vexnum;u++)

if(p[k][j][u]k!=uj!=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(k0||kG-vexnum)

{

printf("景点编号不存在!请重新输入景点编号:");

scanf("%d",k);

}

if(k=0kG-vexnum)

flag=0;

}

printf(" 编号 景点名称 简介 \n");

printf(" %-4d %-16s %-56s \n",G-vexs[k].num,G-vexs[k].name,G-vexs[k].introduction);

}//Search end

int LocateVex(MGraph *G,char* v)

{

int c=-1,i;

for(i=0;iG-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;iG-vexnum;i++)

{

printf("景点编号:");

scanf("%d",G-vexs-num);

printf("景点名称:");

scanf("%s",G-vexs[i].name);

printf("景点简介:");

scanf("%s",G-vexs-introduction);

}

for(i=0;iG-vexnum;i++)

for(j=0;jG-vexnum;j++)

G-arcs[i][j].adj=INFINITY;

printf("请输入路径长度:\n");

for(k=0;kG-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=0j=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;vG-vexnum;v++)

for(w=0;wG-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");

}

}

求用C语言和数据结构中的无向图存储结构编一个校园导游图完全的程序代码？

#define Infinity 1000

#define MaxVertexNum 35

#define MAX 40

#includestdio.h

#includestdlib.h

#includeconio.h

#includestring.h

#includeiostream.h

typedef struct arcell //边的权值信息

{

int adj; //权值

}arcell,adjmatrix[MaxVertexNum][MaxVertexNum]; //图的邻接矩阵类型

typedef struct vexsinfo //顶点信息

{

int position; //景点的编号

char name[32]; //景点的名称

char introduction[256]; //景点的介绍

}vexsinfo;

typedef struct mgraph //图结构信息

{

vexsinfo vexs[MaxVertexNum]; //顶点向量(数组)

adjmatrix arcs; //邻接矩阵

int vexnum,arcnum; //分别指定顶点数和边数

}mgraph;

//全局变量

int visited[35]; //用于标志是否已经访问过

int d[35]; //用于存放权值或存储路径顶点编号

mgraph campus; //图变量(大学校园)

// (1) 对图初始化

mgraph initgraph()

{

int i=0,j=0;

mgraph c;

c.vexnum =28; //顶点个数

c.arcnum =39; //边的个数

for(i=0;ic.vexnum ;i++) //依次设置顶点编号

c.vexs[i].position =i;

//依次输入顶点信息

strcpy(c.vexs[0].name ,"小西南门");

strcpy(c.vexs[0].introduction ,"离公交站近");

strcpy(c.vexs[1].name ,"学校南正门");

strcpy(c.vexs[1].introduction ,"学校大门、学校班车进出口");

strcpy(c.vexs[2].name ,"语言文化职业学院");

strcpy(c.vexs[2].introduction ,"语言文化职业学院办公楼，楼高6层");

strcpy(c.vexs[3].name ,"艺术学院");

strcpy(c.vexs[3].introduction ,"音乐系、美术系，楼高4层");

strcpy(c.vexs[4].name ,"行政楼");

strcpy(c.vexs[4].introduction ,"行政办公大楼，楼高5层");

strcpy(c.vexs[5].name,"文学院");

strcpy(c.vexs[5].introduction ,"文学院，楼高6层");

strcpy(c.vexs[6].name ,"体育场");

strcpy(c.vexs[6].introduction ,"室外标准田径场");

strcpy(c.vexs[7].name,"教育科学学院");

strcpy(c.vexs[7].introduction ,"教心系、经管系，楼高5层");

strcpy(c.vexs[8].name ,"南区学生宿舍");

strcpy(c.vexs[8].introduction ,"离西南门近");

strcpy(c.vexs[9].name, "数学与经济管理学院");

strcpy(c.vexs[9].introduction , "数学与经济管理学院大楼，楼高4层");

strcpy(c.vexs[10].name ,"中区学生宿舍");

strcpy(c.vexs[10].introduction ,"若干栋，离学生1、2食堂近");

strcpy(c.vexs[11].name ,"职业学院教学大楼");

strcpy(c.vexs[11].introduction ,"职业学院教学大楼，楼高5层");

strcpy(c.vexs[12].name ,"体育系");

strcpy(c.vexs[12].introduction ,"体育系，楼高5层");

strcpy(c.vexs[13].name ,"游泳馆");

strcpy(c.vexs[13].introduction ,"室内小型游泳馆");

strcpy(c.vexs[14].name ,"报告厅、阶梯教室");

strcpy(c.vexs[14].introduction ,"可举办中、大型学术会议。有大小报告厅1－6个、阶梯教室1－6个");

strcpy(c.vexs[15].name ,"大礼堂、体育馆");

strcpy(c.vexs[15].introduction ,"文艺演出所在地、室内运动场");

strcpy(c.vexs[16].name ,"1食堂");

strcpy(c.vexs[16].introduction ,"教工食堂及学生1食堂在此");

strcpy(c.vexs[17].name ,"新图书馆");

strcpy(c.vexs[17].introduction ,"建筑面积46000平方米");

strcpy(c.vexs[18].name ,"2食堂");

strcpy(c.vexs[18].introduction ,"学校东区，学生食堂");

strcpy(c.vexs[19].name ,"东区学生宿舍");

strcpy(c.vexs[19].introduction ,"离学生2食堂近");

strcpy(c.vexs[20].name ,"计算机学院");

strcpy(c.vexs[20].introduction ,"计算机学院大楼，楼高5层");

strcpy(c.vexs[21].name ,"教工宿舍");

strcpy(c.vexs[21].introduction ,"学校青年教职工租住地");

strcpy(c.vexs[22].name ,"西区学生宿舍");

strcpy(c.vexs[22].introduction ,"离学生3、4食堂近");

strcpy(c.vexs[23].name ,"3食堂");

strcpy(c.vexs[23].introduction ,"学校西区，学生食堂");

strcpy(c.vexs[24].name ,"外国语学院");

strcpy(c.vexs[24].introduction ,"外国语学院大楼，楼高5层");

strcpy(c.vexs[25].name ,"4食堂");

strcpy(c.vexs[25].introduction ,"学校西区，学生食堂，人气较高");

strcpy(c.vexs[26].name ,"校医院");

strcpy(c.vexs[26].introduction ,"看小病的地方");

strcpy(c.vexs[27].name ,"实验楼");

strcpy(c.vexs[27].introduction ,"物电学院、化学与生命科学学院、机电系、建材系所在地，机房及多媒体教室若干");

//依次输入边上的权值信息

for(i=0;ic.vexnum ;i++)

for(j=0;jc.vexnum ;j++)

c.arcs [i][j].adj =Infinity; //先初始化图的邻接矩阵

//部分弧长

c.arcs[0][2].adj=50; c.arcs[0][3].adj=60;

c.arcs[1][4].adj=90;

c.arcs[2][3].adj=60; c.arcs[2][8].adj=40;

c.arcs[3][4].adj=60; c.arcs[3][6].adj=40;

c.arcs[4][5].adj=70; c.arcs[4][9].adj=70; c.arcs[4][10].adj=80; c.arcs[4][17].adj=200;

c.arcs[5][7].adj=70;

c.arcs[6][9].adj=40;

c.arcs[7][18].adj=190;

c.arcs[8][11].adj=50;

c.arcs[9][12].adj=40;

c.arcs[10][18].adj=70;

c.arcs[11][12].adj=60; c.arcs[11][14].adj=50; c.arcs[11][15].adj=50;

c.arcs[12][16].adj=50;

c.arcs[13][14].adj=40; c.arcs[13][22].adj=60;

c.arcs[14][15].adj=50; c.arcs[14][20].adj=90;

c.arcs[15][16].adj=60; c.arcs[15][21].adj=40;

c.arcs[16][17].adj=60;

c.arcs[17][18].adj=80;

c.arcs[18][19].adj=60;

c.arcs[20][21].adj=60; c.arcs[20][24].adj=80;

c.arcs[22][23].adj=60; c.arcs[22][25].adj=80;

c.arcs[23][24].adj=60;

c.arcs[24][26].adj=100; c.arcs[24][27].adj=100;

c.arcs[25][26].adj=90;

c.arcs[26][27].adj=90;

for(i=0;ic.vexnum ;i++) //邻接矩阵是对称矩阵，对称赋值

for(j=0;jc.vexnum ;j++)

c.arcs[j][i].adj =c.arcs[i][j].adj ;

return c;

}//initgraph

// (2) 查找景点在图中的序号

int locatevex(mgraph c,int v)

{

int i;

for(i=0;ic.vexnum ;i++)

if(v==c.vexs[i].position)

return i; //找到，返回顶点序号i

return -1; //否则，返回-1

}

//(3) 、(4) 求两景点间的所有路径

// (3) 打印序号为m,n景点间的长度不超过8个景点的路径

void path(mgraph c, int m,int n,int k)

{

int s,x=0;

int t=k+1; //t 记载路径上下一个中间顶点在d[]数组中的下标

if(d[k]==n k8) //d[k]存储路径顶点。若d[k]是终点n且景点个数=8，则输出该路径

{ //递归出口，找到一条路径

for(s=0;sk;s++)

printf("%s---",c.vexs[d[s]].name); //输出该路径。s=0 时为起点m

printf("%s",c.vexs[d[s]].name); //输出最后一个景点名(即顶点n的名字，此时s==k)

printf("\n\n");

}

else

{

s=0;

while(sc.vexnum) //从第m个顶点，试探至所有顶点是否有路径

{

if((c.arcs[d[k]][s].adjInfinity) (visited[s]==0)) //初态：顶点m到顶点s有边，且未被访问

{

visited[s]=1;

d[k+1]=s; //存储顶点编号s 至d[k+1]中

path(c,m,n,t); //求从下标为t=k+1的第d[t]个顶点开始的路径(递归调用)，同时打印出一条m至n的路径

visited[s]=0; //将找到的路径上顶点的访问标志重新设置为0，以用于试探新的路径

}

s++; //试探从下一个顶点 s 开始是否有到终点的路径

}//endwhile

}//endelse

}//endpath

//(4) 打印两景点间的景点个数不超过8的所有路径。调用(3)

int allpath(mgraph c)

{

int k,i,j,m,n;

printf("\n\n请输入你要查询的两个景点编号:\n\n");

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

printf("\n\n");

m=locatevex(c,i); //调用(2)，确定该顶点是否存在。若存在，返回该顶点编号

n=locatevex(c,j);

d[0]=m; //存储路径起点m (int d[]数组是全局变量)

for(k=0;kc.vexnum;k++) //全部顶点访问标志初值设为0

visited[k]=0;

visited[m]=1; //第m个顶点访问标志设置为1

path(c,m,n,0); //调用(3)。k=0，对应起点d[0]==m。k为d[]数组下标

return 1;

}

// (5) 用迪杰斯特拉算法，求出一个景点到其他景点间的最短路径，并打印

void shortestpath_dij(mgraph c)

{

//迪杰斯特拉算法，求从顶点v0到其余顶点的最短路经及其带权长度d[v]

//若p[v][w]为1，则w是从v0到v的最短路经上的顶点

//final[v]类型用于设置访问标志

int v,w,i,min,t=0,x,flag=1,v0; //vo为起始景点的编号

int final[35],d[35],p[35][35];

printf("\n请输入一个起始景点的编号：");

scanf("%d",v0);

printf("\n\n");

while(v00||v0c.vexnum)

{

printf("\n你所输入的景点编号不存在\n");

printf("请重新输入：");

scanf("%d",v0);

}//while

for(v=0;vc.vexnum ;v++)

{

final[v]=0; //初始化各顶点访问标志

d[v]=c.arcs[v0][v].adj; //v0 到各顶点 v 的权值赋值给d[v]

for(w=0;wc.vexnum ;w++) //初始化p[][]数组，各顶点间的路径全部设置为空路径0

p[v][w]=0;

if(d[v]Infinity) //v0 到v 有边相连，修改p[v][v0]的值为1

{

p[v][v0]=1;

p[v][v]=1; //各顶点自己到自己要连通

}

}//for

d[v0]=0; //自己到自己的权值设为0

final[v0]=1; //v0的访问标志设为1，v 属于 s 集

for(i=1;ic.vexnum ;i++) //对其余c.vexnum-1个顶点w，依次求 v 到 w 的最短路径

{

min=Infinity;

for(w=0;wc.vexnum ;w++) //在未被访问的顶点中，查找与 v0 最近的顶点v

if(!final[w])

if(d[w]min) //v0 到 w (有边)的权值min

{

v=w;

min=d[w];

}//if

final[v]=1; //v 的访问标志设置为1，v 属于s集

for(w=0;wc.vexnum ;w++) //修改v0 到其余各顶点w 的最短路径权值d[w]

if(!final[w](min+c.arcs[v][w].adj d[w])) //若w 不属于s，且v 到w 有边相连

{

d[w]=min+c.arcs[v][w].adj; //修改v0 到w 的权值d[w]

for(x=0;xc.vexnum ;x++) //所有v0 到v 的最短路径上的顶点x，都是v0 到w 的最短路径上的顶点

p[w][x]=p[v][x];

p[w][w]=1;

}//if

}//for

for(v=0;vc.vexnum ;v++) //输出v0 到其它顶点v 的最短路径

{

if(v!=v0)

printf("%s",c.vexs[v0].name); //输出景点v0 的景点名

for(w=0;wc.vexnum ;w++) //对图中每个顶点w，试探w 是否是v0 到v 的最短路径上的顶点

{

if(p[v][w] w!=v0 w!=v) //若w 是且w 不等于v0，则输出该景点

printf("---%s",c.vexs[w].name);

}

printf("----%s",c.vexs[v].name);

printf("\n总路线长为%d米\n\n",d[v]);

}//for

}//shortestpath

//(6)-(11)修改图的信息。包括建图、更新信息、删除、增加结点和边

//(6) 构造图的邻接矩阵

int creatgragh(mgraph c) //建图。以图的邻接矩阵存储图

{

int i,j,m,n;

int v0,v1;

int distance;

printf("请输入图的顶点数和边数: \n");

scanf("%d %d",c.vexnum ,c.arcnum );

printf("下面请输入景点的信息：\n");

for(i=0;ic.vexnum ;i++) //构造顶点向量(数组)

{

printf("请输入景点的编号：");

scanf("%d",c.vexs[i].position );

printf("\n请输入景点的名称：");

scanf("%s",c.vexs[i].name );

printf("\n请输入景点的简介：");

scanf("%s",c.vexs[i].introduction );

}

for(i=0;ic.arcnum ;i++) //初始化邻接矩阵

for(j=0;jc.arcnum ;j++)

c.arcs[i][j].adj =Infinity;

printf("下面请输入图的边的信息：\n");

for(i=1;i=c.arcnum ;i++) //构造邻接矩阵

{

printf("\n第%d条边的起点 终点 长度为：",i);//输入一条边的起点、终点及权值

scanf("%d %d %d",v0,v1,distance);

m=locatevex(c,v0);

n=locatevex(c,v1);

if(m=0 n=0)

{

c.arcs[m][n].adj =distance;

c.arcs[n][m].adj =c.arcs[m][n].adj ;

}

}

return 1;

}//creatgragh

// (7) 更新图的部分信息。返回值: 1

int newgraph(mgraph c)

{

int changenum; //计数。用于记录要修改的对象的个数

int i,m,n,t,distance,v0,v1;

printf("\n下面请输入你要修改的景点的个数：\n");

scanf("%d",changenum);

while(changenum0||changenumc.vexnum )

{

printf("\n输入错误！请重新输入");

scanf("%d",changenum);

}

for(i=0;ichangenum;i++)

{

printf("\n请输入景点的编号：");

scanf("%d",m);

t=locatevex(c,m);

printf("\n请输入景点的名称：");

scanf("%s",c.vexs[t].name );

printf("\n请输入景点的简介：");

scanf("%s",c.vexs[t].introduction );

}

printf("\n下面请输入你要更新的边数");

scanf("%d",changenum);

while(changenum0||changenumc.arcnum )

{

printf("\n输入错误！请重新输入");

scanf("%d",changenum);

}

printf("\n下面请输入更新边的信息：\n");

for(i=1;i=changenum ;i++)

{

printf("\n修改的第%d条边的起点 终点 长度为：",i);

scanf("%d %d %d",v0,v1,distance);

m=locatevex(c,v0);

n=locatevex(c,v1);

if(m=0n=0)

{

c.arcs[m][n].adj =distance;

c.arcs[n][m].adj =c.arcs[m][n].adj ;

}

}

return 1;

}//newgraph

求校园导游咨询程序（最短路径算法）

校园导游程序

[问题描述]

用无向网表示学校的校园景点平面图，图中顶点表示主要景点，存放景点的编号、名称、简介等信息，

图中的边表示景点间的道路，存放路径长度等信息。要求能够回答有关景点介绍、游览路径等问题。游

客通过终端可询问：

（1）从某一景点到另一景点的最短路径。(最短路径问题)

（2）游客从公园进入，选取一条最佳路线。

（3）使游客可以不重复地浏览各景点，最后回到出口（出口就在入口旁边）。

[基本要求]

（1）将导游图看作一张带权无向图，顶点表示公园的各个景点，边表示各景点之间的道路，边上的权值

表示距离．为此图选择适当的数据结构。

（2）把各种路径都显示给游客，由游客自己选择浏览路线。

（3）画出景点分布图于屏幕上。

[实现提示]

（1）构造一个无向图G并用邻接矩阵来存储。

（2）利用迪杰斯特拉算法来计算出起点到各个顶点之间的最短路径用二维数组p[i][]来记录，最短路径长

度就用一维数组d[i]存放；i的范围：0～20。

（3）一维数组have[]是用来记录最短路径出现顶点的顺序。

（4）根据起点和终点输出最短路径和路径长度。

*/

#include "string.h"

#include "stdio.h"

#include "stdio.h"

#include "malloc.h"

#include "stdlib.h"

#define Max 20000

#define NUM 9

typedef struct ArcCell{

int adj; /* 相邻接的景点之间的路程 */

}ArcCell; /* 定义边的类型 */

typedef struct VertexType{

int number; /* 景点编号 */

char *sight; /* 景点名称 */

char *description; /* 景点描述 */

}VertexType; /* 定义顶点的类型 */

typedef struct{

VertexType vex[NUM]; /* 图中的顶点，即为景点 */

ArcCell arcs[NUM][NUM]; /* 图中的边，即为景点间的距离 */

int vexnum,arcnum; /* 顶点数，边数 */

}MGraph; /* 定义图的类型 */

MGraph G; /* 把图定义为全局变量 */

int P[NUM][NUM]; /* */

long int D[NUM]; /* 辅助变量存储最短路径长度 */

int x[9]={0};

void CreateUDN(int v,int a); /* 造图函数 */

void narrate(); /*说明函数*/

void ShortestPath(int num); /*最短路径函数*/

void output(int sight1,int sight2); /*输出函数*/

char Menu(); /* 主菜单 */

void search(); /* 查询景点信息 */

char SearchMenu(); /* 查询子菜单 */

void HaMiTonian(int); /* 哈密尔顿图的遍历 */

void NextValue(int);

void display(); /* 显示遍历结果 */

void main() /* 主函数 */

{

int v0,v1;

char ck;

system("color fc");

CreateUDN(NUM,11);

do

{

ck=Menu();

switch(ck)

{

case '1':

system("cls");

narrate();

printf("\n\n\t\t\t请选择起点景点（0～8）：");

scanf("%d",v0);

printf("\t\t\t请选择终点景点（0～8）：");

scanf("%d",v1);

ShortestPath(v0); /* 计算两个景点之间的最短路径 */

output(v0,v1); /* 输出结果 */

printf("\n\n\t\t\t\t请按任意键继续...\n");

getchar();

getchar();

break;

case '2':search();

break;

case '3':

system("cls");

narrate();

x[0]=1;

HaMiTonian(1);

printf("\n\n\t\t\t\t请按任意键继续...\n");

getchar();

getchar();

break;

};

}while(ck!='e');

}

char Menu() /* 主菜单 */

{

char c;

int flag;

do{

flag=1;

system("cls");

narrate();

printf("\n\t\t\t┏━━━━━━━━━━━━━━━┑\n");

printf("\t\t\t┃ ┃\n");

printf("\t\t\t┃ 1、查询景点路径 ┃\n");

printf("\t\t\t┃ 2、查询景点信息 ┃\n");

printf("\t\t\t┃ 3、推荐参观路线 ┃\n");

printf("\t\t\t┃ e、退出 ┃\n");

printf("\t\t\t┃ ┃\n");

printf("\t\t\t┗━━━━━━━━━━━━━━━┛\n");

printf("\t\t\t\t请输入您的选择：");

scanf("%c",c);

if(c=='1'||c=='2'||c=='3'||c=='e')

flag=0;

}while(flag);

return c;

}

char SearchMenu() /* 查询子菜单 */

{

char c;

int flag;

do{

flag=1;

system("c

校园导游程序代码的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于校园导游程序设计、校园导游程序代码的信息别忘了在本站进行查找喔。