安徽大学导游系统设计---迪杰斯特拉算法实现

已于 2022-12-16 11:01:18 修改
阅读量503 收藏 11
点赞数 5
文章标签： 算法 数据结构 c++ c语言
于 2022-12-11 19:27:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_67472400/article/details/128277440
版权

本文是基于《数据结构》相关实验，使用迪杰斯特拉算法来实现最短路径。

总体思路是对于安徽大学磬苑校区进行数学建模，对重要的景点进行抽象。抽象成无向图中间的顶点。之后利用高德地图对各个顶点之间测距。

6dd1a7b57512437d9011299032fca914.jpeg

废话不多说，之后上代码：

首先是初始的一些操作，图和顶点的相关定义：

#define _CRT_SECURE_NO_WARNINGS
#define INFINTY 10000
#define v 20
#include <stdio.h>
#include <iostream>
using namespace std;
typedef struct 
{
	int number;
	char name[100];
	char info[100];
}VertexType; //顶点结构

typedef struct {
	VertexType vexs[20];
	int arcs[20][20];//邻接矩阵
	int vexnum, arcnum;//顶点个数，边的个数 
}MGraph; //图结构

之后手动录入相关景点和边的数据：

void CreateGraph(MGraph &G)
{
	int i,j;
    G.vexnum = 16;
	for (i = 0; i < 16; i++)
	{//初始化路径长度均为0
		for (j = 0; j < 16; j++)
		{
			G.arcs[i][j] = 0;
		}
	}
    strcpy(G.vexs[0].name, "体育馆");
    strcpy(G.vexs[1].name, "北体育场");
    strcpy(G.vexs[2].name, "杏园宿舍");
    strcpy(G.vexs[3].name, "篮球场");
    strcpy(G.vexs[4].name, "理工楼D");
    strcpy(G.vexs[5].name, "橘园食堂");
    strcpy(G.vexs[6].name, "博学北楼");
    strcpy(G.vexs[7].name, "西门");
    strcpy(G.vexs[8].name, "鸣磬广场");
    strcpy(G.vexs[9].name, "文典阁");
	strcpy(G.vexs[10].name, "磬苑广场");
	strcpy(G.vexs[11].name, "笃行南楼");
	strcpy(G.vexs[12].name, "孔子像");
	strcpy(G.vexs[13].name, "桂园食堂");
	strcpy(G.vexs[14].name, "行政楼");
	strcpy(G.vexs[15].name, "南体育场");
    strcpy(G.vexs[0].info, "体育馆可以打羽毛球，做核酸");
    strcpy(G.vexs[1].info, "北体育场可以踢足球，有看台");
    strcpy(G.vexs[2].info, "杏园宿舍和枣园和榴园宿舍都是学生的宿舍");
    strcpy(G.vexs[3].info, "篮球比赛进行的地方");
    strcpy(G.vexs[4].info, "计算机科学与技术学院");
    strcpy(G.vexs[5].info, "烤鸭饭，瑞辛咖啡，蜜雪冰城");
    strcpy(G.vexs[6].info, "基础课专业课教学楼和自习教室");
    strcpy(G.vexs[7].info, "安徽大学人流量最大的进出口");
    strcpy(G.vexs[8].info, "晚上有乐队的演出");
    strcpy(G.vexs[9].info, "图书馆，很多藏书，可以自习，考研圣地");
	strcpy(G.vexs[10].info, "喷泉和安徽大学的标志，旁边有行知楼");
	strcpy(G.vexs[11].info, "计算机实验室和化学实验室");
	strcpy(G.vexs[12].info, "孔子的雕像，旁边是新闻传播学院");
	strcpy(G.vexs[13].info, "安徽大学最好吃的食堂，没有之一");
	strcpy(G.vexs[14].info, "政务处理，教学办");
	strcpy(G.vexs[15].info, "足球场和篮球场和跑道");
    G.arcs[0][1] = G.arcs[1][0] =235;
	G.arcs[1][2] = G.arcs[2][1] =220;
	G.arcs[2][3] = G.arcs[3][2] =130;
	G.arcs[1][3] = G.arcs[3][1] =200;
	G.arcs[1][4] = G.arcs[4][1] =320;
	G.arcs[3][4] = G.arcs[4][3] =210;
	G.arcs[2][5] = G.arcs[5][2] =240;
	G.arcs[3][6] = G.arcs[6][3] =325;
	G.arcs[4][10] = G.arcs[10][4] =400;
	G.arcs[5][6] = G.arcs[6][5] =350;
	G.arcs[6][10] = G.arcs[10][6] =220;
	G.arcs[7][8] = G.arcs[8][7] =180;
	G.arcs[8][9] = G.arcs[9][8] =190;
	G.arcs[9][10] = G.arcs[10][9] =345;
	G.arcs[5][8] = G.arcs[8][5] =310;
	G.arcs[5][9] = G.arcs[9][5] =330;
	G.arcs[6][9] = G.arcs[9][6] =210;
	G.arcs[6][10] = G.arcs[10][6] =200;
	G.arcs[11][12] = G.arcs[12][11] =300;
	G.arcs[9][11] = G.arcs[11][9] =150;
	G.arcs[10][11] = G.arcs[11][10] =300;
	G.arcs[10][12] = G.arcs[12][10] =170;
	G.arcs[11][13] = G.arcs[13][11] =225;
	G.arcs[12][13] = G.arcs[13][12] =270;
	G.arcs[8][13] = G.arcs[13][8] =485;
	G.arcs[14][13] = G.arcs[13][14] =530;
	G.arcs[12][14] = G.arcs[14][12] =510;
	G.arcs[13][15] = G.arcs[15][13] =260;
	for (i = 0; i < 16; i++)
	{
		for (j = 0; j < 16; j++)
		{
			if (i != j && G.arcs[i][j] == 0)
			{
				G.arcs[i][j] = INFINTY;
			}
		}

	}
	for (i = 0; i <16; i++)
	{
		G.vexs[i].number = i;
	}
    G.arcnum = 27;
}

 之后我们来看相关的菜单：

void printsystem()
{
	cout << endl;
	cout << "       安徽大学欢迎您！      \n";
	cout << "             AHU             \n";
	cout << "*****************************\n";
	cout << "*   欢迎来到景点查询系统    *\n";
	cout << "*      1.查看所有景点       *\n";
	cout << "*      2.景点查询           *\n";
	cout << "*      3.问路查询           *\n";
	cout << "*      4.高级功能           *\n";
	cout << "*      0.退出程序           *\n";
	cout << "*****************************\n";
	cout << endl;
}

主函数实现相关功能：

其中的高级功能中还二层嵌套着一个菜单：

int main()
{
	int x = 10;
    MGraph G;
    CreateGraph(G);
	printsystem();
	while (x != 0)
	{
		cin >> x;
		while (x != 1 && x != 2 && x != 3 && x != 4&& x!= 0)
		{
			cout << "错误，请重新输入：" << endl;
			cin >> x;
		}
		switch (x)
		{
		case 1:Allprint(G); cout << endl; break;
        case 2:FindGraph(G); break;
		case 3:
		{
			int qidian;//起点
			int zhongdian;
			int p[v] = { 0 };//p数组为path
			int D[v] = { 0 };//D数组为最短距离
			cout << "请输入起点的编号：\n";
			cin >> qidian;
			cout << "请输入目的地：\n";
			cin >> zhongdian;
			Dijkstra(G, qidian, p, D);
			shortpath(G,p, D, qidian,zhongdian);
			break;
		}
		case 4:
		{
			cout << "    请输入你想要的相关操作:     " << endl;
			cout << "********************************\n";
			cout << "    1.修改已有景点的相关信息    \n";
			cout << "  2.增加一个新景点及其相关信息  \n";
			cout << "      3. 增加一条新的路径       \n";
			cout << "  4. 删除一个景点及其相关信息   \n";
			cout << "       5. 删除一条路径          \n";
			cout << "********************************\n";
			int z;
			cin >> z;
			switch (z)
			{
			case 1:changeinfo(G); break;
			case 2:addves(G); break;
			case 3:addarc(G); break;
			case 4:del_ves(G); break;
			case 5:del_arcone(G); break;
			default:cout << "输入数据错误！\n"; break;
			}
		}break;
        case 0:x = 0; break;
		}
		printsystem();
		cout << endl << endl;
	}
	cout << "谢谢您的使用，欢迎您再来安大！" << endl;
	cout << "       AHU永远欢迎您！" << endl;
	return 0;
}

所有准备工作做好了，我们可以来到正题部分：

首先给出迪杰斯特拉算法，这部分基本和书上一样

void Dijkstra(MGraph G, int v0, int p[], int D[])
{
	int judge[v];//判断v在不在当前集合中
	for (int i = 0; i < G.vexnum; i++)
	{
		judge[i] = 0;
		D[i] = G.arcs[v0][i];//初始化每个点到v0的路径长度
		p[i] = 0;
	}
	D[v0] = 0;//自己到自己的最短路径为0
	judge[v0] = 1;//把v0放入集合之中
	int k = 0;
	for (int i = 0; i < G.vexnum; i++)
	{
		int min = INFINTY;
		for (int w = 0; w < G.vexnum; w++)
		{
			if (!judge[w])//w不在集合中
			{
				if (D[w] < min)
				{
					k = w;
					min = D[w];
				}
			}
		}
		judge[k] = 1;
		for (int w = 0; w < G.vexnum; w++)
		{
			if (!judge[w] && (min + G.arcs[k][w] < D[w]))
			{
				D[w] = min + G.arcs[k][w];//最短路径长度
				p[w] = k;//记录点
			}
		}
	}
}

最短路径的实现（核心为建立临时数组）：

void shortpath(MGraph G,int p[], int D[], int y, int x)
{
	int temp[20] = { 0 }; int j = 0; int x0 = x;//x0储存终点
	while (p[x] != 0)//当p[x]非零时用temp数组储存前驱
	{
		temp[j] = p[x];
		x = p[x];
		j++;
	}
	j--;//指针退一位
	cout << "路径为：" << endl;
	cout << G.vexs[y].name;//输出起点
	for (; j >=0; j--)//输出路径
	{
		cout << "->" << G.vexs[temp[j]].name;
	}
	cout << "->" << G.vexs[x0].name;//输出终点
	cout << endl;
	if (D[x0] == 10000) { cout << "不存在路径！" << endl; return; }
	cout << "最短距离为：" << D[x0] << endl;
}

接下来看看菜单中的高级选项：

（1）修改景点信息

void changeinfo(MGraph& G)//修改景点信息
{
	int x;
	cout << "请输入你想要修改的编号：" << endl;
	cin >> x;
	if (x >= G.vexnum || x < 0) { cout << "错误！" << endl; return; }//输入的x不合法
	cout << "修改名称：" << endl;
	cin >> G.vexs[x].name;
	cout << "修改相关信息：" << endl;
	cin >> G.vexs[x].info;
	cout << "成功！" << endl;
}

（2）增添一个新顶点

void addves(MGraph& G)
{
	if (G.vexnum == v) 
	{
		cout << "景点已满！" << endl; return;
	}
	cout << "请输入你想要增添的景点：" << endl;
	cin >> G.vexs[G.vexnum].name;
	cout << "请输入你想要增添的相关景点的信息：" << endl;
	cin >> G.vexs[G.vexnum].info;
	G.vexs[G.vexnum].number = G.vexnum;
	for (int i = 0; i < G.vexnum; i++)
	{
		G.arcs[i][G.vexnum] = G.arcs[G.vexnum][i] = INFINTY;//目前这个点和别的点距离无限大
	}
	G.arcs[G.vexnum][G.vexnum] = 0;
	G.vexnum++;
	cout << "处理成功！" << endl;
}

（3）增添一条新边

void addarc(MGraph& G)
{
	int x, y; int z;
	cout << "请输入你想要增添的边相连着哪两个景点(空格分隔两个数)：" << endl;
	cin >> x; if (x >= G.vexnum || x < 0) { cout << "错误！" << endl; return; }//输入的x不合法
	cin >> y; if (y >= G.vexnum || y < 0) { cout << "错误！" << endl; return; }//输入的y不合法
	cout << "请输入此边的权值：" << endl;
	cin >> z;
	G.arcs[x][y] = G.arcs[y][x] = z;
	G.arcnum++;
	cout << "处理成功!" << endl;
}

（4）删除一个顶点（这里感觉写得不太好）

void del_ves(MGraph& G)
{
	int x; int sum = 0;//sum统计一共清除了多少条边
	cout << "输入你想要删除的顶点的编号：" << endl;
	cin >> x;
	if (x >= G.vexnum || x < 0) { cout << "错误！" << endl; return; }//输入的x不合法
	strcpy(G.vexs[x].info, "空");
	strcpy(G.vexs[x].name, "空");//将顶点信息为空
	for (int w = 0; w < G.vexnum; w++)//清空关于x的边
	{
		G.arcs[w][x] = INFINTY;
		G.arcs[x][w] = INFINTY;
		sum++;
	}
	G.vexnum--;
	G.arcnum = G.arcnum - sum;
	cout << "处理成功" << endl;
}

（5）删除一条边

void del_arcone(MGraph& G)
{
	int x; int y;
	cout << "请输入你想要删除哪两个景点之间的路径（用编号表示，用空格隔开）：" << endl;
	cin >> x; if (x >= G.vexnum || x < 0){cout << "数据有误！" << endl; return;}
	cin >> y; if (y >= G.vexnum || y < 0){cout << "数据有误！" << endl; return;}
	G.arcs[x][y] = G.arcs[y][x] = INFINTY;
	cout << "处理成功!" << endl;
}

以上就是本导游系统的所有代码部分了

接下来看看部分运行的图片（只展示部分）：

 

d39e7cb1a43e4e2bbce311de7565fca4.png

 

5a97899cd6b74e5595e9f1f52c5d4274.png

 接下来我们试一下最短路径：

（1）从体育馆到南体育场

da0b4c2de22a435594e560bee050251a.png

 aa5f62c5e13f4f289b2a075ccc51f901.png

（2） 从杏园宿舍到文典阁

 65573b470dba4d258628624ae069c1cc.png

 a527cd2b8b354ef29fe65a093668001c.png

 （3）从橘园食堂到孔子像

72dcd5bb7e6142b89658f6519430d80e.png

183a71768b4340cab6f2060500edff7e.png

 以上就是本次的全部内容了。

代码仅供参考，请勿直接抄袭！请勿转载！仅供交流学习使用！谢谢~

 

程序源～菜大侠
关注
  • 5
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
C++实现Dijkstra(迪杰斯特拉)算法
08-19
主要为大家详细介绍了C++实现Dijkstra(迪杰斯特拉)算法，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
c++实现迪杰斯特拉算法（Dijkstra算法）.zip
10-09
迪杰斯特拉算法c
数据结构--Dijkstra算法最清楚的讲解
热门推荐
heroacool的专栏
03-30 15万+
迪杰斯特拉(Dijkstra)算法是典型最短路径算法，用于计算一个节点到其他节点的最短路径。 它的主要特点是以起始点为中心向外层层扩展(广度优先搜索思想)，直到扩展到终点为止基本思想 通过Dijkstra计算图G中的最短路径时，需要指定起点s(即从顶点s开始计算)。 此外，引进两个集合S和U。S的作用是记录已求出最短路径的顶点(以及相应的最短路径长度)，而U则是记录还未求出最短路径的顶点(以及该
路径规划—详解Dijkstra算法
一地鸡毛的博客
10-08 5593
本文首先详述了Dijstra算法的定义和思路，以初始点为中心按照路径长度以递增方式层层向外扩展，直到扩展到终止点。然后使用拓扑连通图展示了其实现步骤。最后展示了在栅格地图中运用Dijstra算法的Matlab仿真效果。
算法之迪杰斯特拉（dijkstra）非常详细介绍
PRML_MAN的博客
03-07 8万+
迪杰斯特拉（dijkstra）算法是单源最短路径问题的求解方法。单源最短路径就在给出一个固定网络，指定一个原点s，一个目标点e，求这两个点之间的最短路径。举个栗子来理解一下。 小明上学的时候，从家到学校的道路非常多，小明为了减少路上骑车的时间，因此，想找出一个最短的路径。他构造一个网络图，如下： 小明是一个很喜欢动脑筋的同学，他开始研究如何才能找出最优的路径呢？ 1）所有的点到家的距离都进行初始化： 2）每次选择距离家最短的一个点，然后用这个点的距离更新其他相邻点到家的距离，如果比当前的点小，则更新节点
数据结构 -最短路径dijkstra（迪杰斯特拉）算法讲解及代码实现
weixin_73612682的博客
05-22 3061
迪杰斯特拉算法是一种广义的贪心算法，求出局部最优解，再去求全局最优解。
最短路径算法-----Dijkstra迪杰斯特拉算法
zzhongcy的专栏
11-06 9395
最近巩固一下算法，提高自己内力，网上看到查看到这篇介绍很详细的《Dijkstra迪杰斯特拉算法》，在这里转载记录一下。 前言 本章介绍迪杰斯特拉算法。和以往一样，本文会先对迪杰斯特拉算法的理论论知识进行介绍，然后给出C语言的实现。后续再分别给出C++和Java版本的实现。 目录1.迪杰斯特拉算法介绍2.迪杰斯特拉算法图解3.迪杰斯特拉算法的代码说明4.迪杰斯特拉算法的源码 转载请注明出处：http://www.cnblogs.com/skywang12345/ 更多内容：数据结构与算法系...
6-2 最短路径（迪杰斯特拉算法）
国家一级致癌物
12-09 3072
6-2 最短路径（迪杰斯特拉算法） (15 分) 试实现迪杰斯特拉最短路径算法。 函数接口定义： void ShortestPath_DIJ(AMGraph G, int v0); 其中 G 是基于邻接矩阵存储表示的有向图， v0表示源点 裁判测试程序样例： #include <iostream> using namespace std; #define MaxInt 32767 #define MVNum 100 typedef char VerTexType; typedef int
单源最短路径算法的实现-----迪杰斯特拉（Dijkstra）算法【C/C++】
bblb的博客
07-25 1426
单源最短路径算法的实现-----迪杰斯特拉（Dijkstra）算法
最短路径-迪杰斯特拉算法
weixin_48434899的博客
09-08 858
文章目录迪杰斯特拉算法(Dijkstra算法)过程 迪杰斯特拉算法(Dijkstra算法) 迪杰斯特拉算法是典型的最短路径路由算法 ,用于计算一个节点到其他所有节点的最短路径.主要特点是以起始点为中心向外层层扩展,知道扩展到终点为止.Dijkstra算法能得出最短路径的最优解,但由于它遍历计算的结点很多,所以效率低.可以用堆优化. 过程 创建两个表，OPEN, CLOSE。 OPEN表保存所有已生成而未考察的节点，CLOSED表中记录已访问过的节点。 1． 访问路网中距离起始点最近且没有被检查过的点，把这个
求最短路径-----迪杰斯特拉算法
weixin_46443427的博客
12-13 458
3），迪杰斯特拉算法（解决单源最短路径） 基本思想：每次找到离源点（如1号结点）最近的一个顶点，然后以该顶点为中心进行扩展，最终得到源点到其余所有点的最短路径。 基本步骤：1，设置标记数组book[]：将所有的顶点分为两部分,已知最短路径的顶点集合P和未知最短路径的顶点集合Q，很显然最开始集合P只有源点一个顶点。book[i]为1表示在集合P中； 2，设置最短路径数组dst[]并不断更新：初始状态下，令dst[i] = edge[s]i，很显然此时dst[s]=0，book[s]=1。此时，在集合Q中可选择
计算机网络基础(十)---网络层-迪杰斯特拉算法
self_realian的博客
07-28 849
文章内容概览 迪杰斯特拉算法 Dijkstra（迪杰斯特拉）算法是著名的图论算法 Dijkstra算法解决有权图从一个节点到其它节点的最短路径问题 特点：“以起点为中心，向外层层扩展” 最短路径问题 假设有下图这样的一个网络，该网络有A、B、C、D、E、F这几个节点和若干条边，每条边都有相应的距离。假设此时要求A到E的最短路径 下边列出由A到E的所有可能的路径以及路径长度 A->B->C->E = 13 A->C->E = 11 A->D->C->E
MATLAB轻松绘制地图路线-Dijkstra(迪杰斯特拉)算法最短路径规划
05-06
博客：MATLAB轻松绘制地图路线——Dijkstra(迪杰斯特拉)算法最短路径规划 所用工程文件
数据库课程设计《火车出行路线规划及售票系统》迪杰斯特拉算法实现
01-04
期末数据库课程设计 《火车出行路线规划及售票系统》 利用迪杰斯特拉算法找到最省钱的城市路线（只是城市路线） 采用简单工厂模式进行设计用户操作
Python实现迪杰斯特拉算法过程解析
09-24
主要介绍了Python实现迪杰斯特拉算法过程解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
【代码随想录】【算法训练营】【第35天】[134]加油站 [135]分发糖果 [860]柠檬水找零 [406]根据身高重建队列
weixin_54954007的博客
06-11 299
思路及算法思维，指路。题目来自。day 35，连休两天~
指针和数组
2301_77634163的博客
06-10 431
有3个指针，中间是一个数组arr，有个指针指向中间,其他两个指向两边，一个指向前面，一个人指向后面。虽然简化好，但是我们C语言要求是不允许这样写的,虽然大部分编译器是可以允许我这样写的。下面那个用数组名也是可以用的，因为他也表示一个地址，加1就会找后面那个元素的地址。我们C语言编译器中说指针允许往后比较大小，但不允许往前比面的指针比较大小。地址向后移，指针相比较，指针减减就是减去一个整数。同一指针相减的绝对值得到的是之间元素的个数。数组和指针的地址是一样的，说明是可以的。地址加地址，指针加指针没有意义。
力扣136. 只出现一次的数字
最新发布
LNsupermali的博客
06-15 428
力扣136. 只出现一次的数字
二叉树顺序结构——堆的结构与实现
qq3304968099的博客
06-10 878
二叉树顺序结构——堆的结构与源代码实现
最短路径算法-迪杰斯特拉(Dijkstra)算法
07-27
迪杰斯特拉算法是一种用于求解带权有向图中单源最短路径的算法。它以一个起始节点为基准，逐步扩展到其他节点，通过不断更新节点的最短路径来找到起始节点到其他节点的最短路径。 算法的基本思想是从起始节点开始，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值