图之Dijkstra算法
Dijkstra算法是一种求单源最短路的算法，即从一个点开始到所有其他点的最短路。其步骤如下：
c语言实现如下：（使用邻接矩阵存储）
#include <stdio.h>
#include <malloc.h>
#define VERTEXNUM 6 //存放最短路径的边元素
typedef struct edge{
int vertex;
int value;
struct edge* next;
}st_edge; void createGraph(int (*edge)[VERTEXNUM], int start, int end, int value);
void displayGraph(int (*edge)[VERTEXNUM]);
void displayPath(st_edge** path, int startVertex,int* shortestPath);
void dijkstra(int (*edge)[VERTEXNUM], st_edge*** path, int** shortestPath, int startVertex, int* vertexStatusArr);
int getDistance(int value, int startVertex, int start, int* shortestPath);
void createPath(st_edge **path, int startVertex, int start, int end, int edgeValue); int main(void){
//动态创建存放边的二维数组
int (*edge)[VERTEXNUM] = (int (*)[VERTEXNUM])malloc(sizeof(int)*VERTEXNUM*VERTEXNUM);
int i,j;
for(i=0;i<VERTEXNUM;i++){
for(j=0;j<VERTEXNUM;j++){
edge[i][j] = 0;
}
}
//存放顶点的遍历状态，0：未遍历，1：已遍历
int* vertexStatusArr = (int*)malloc(sizeof(int)*VERTEXNUM);
for(i=0;i<VERTEXNUM;i++){
vertexStatusArr[i] = 0;
} printf("after init:\n");
displayGraph(edge);
//创建图
createGraph(edge,0,1,6);
createGraph(edge,0,3,5);
createGraph(edge,0,2,1);
createGraph(edge,1,2,5);
createGraph(edge,1,4,3);
createGraph(edge,2,4,6);
createGraph(edge,2,3,5);
createGraph(edge,2,5,4);
createGraph(edge,3,5,2);
createGraph(edge,4,5,6); printf("after create:\n");
displayGraph(edge);
//最短路径
/*存储的结构如下：
path[0]:edge0->NULL
path[1]:edge1->NULL
path[2]:edge1->edge2->NULL
path[3]:edge1->edge2->edge3->NULL
path[4]:edge4->NULL
从顶点0到0的最短路径：从0出发直接到0
从顶点0到1的最短路径：从0出发直接到1
从顶点0到2的最短路径：从0出发到1，从1出发到2
......
*/
st_edge** path = NULL;
//存储最短路径的权值
/*
shortestPath[0] = 0;
shortestPath[1] = 8;
shortestPath[2] = 12;
从顶点0到0的路径是0
从顶点0到1的路径是8
从顶点0到2的路径是12
*/
int* shortestPath = NULL;
//从顶点0开始寻找最短路径
int startVertex = 0;
//最短路径
dijkstra(edge, &path, &shortestPath, startVertex, vertexStatusArr);
printf("the path is:\n");
displayPath(path,startVertex,shortestPath); free(edge);
free(path);
return 0;
}
//创建图
void createGraph(int (*edge)[VERTEXNUM], int start, int end, int value){
edge[start][end] = value;
edge[end][start] = value;
}
//打印存储的图
void displayGraph(int (*edge)[VERTEXNUM]){
int i,j;
for(i=0;i<VERTEXNUM;i++){
for(j=0;j<VERTEXNUM;j++){
printf("%d ",edge[i][j]);
}
printf("\n");
}
}
//打印最短路径
void displayPath(st_edge** path, int startVertex,int* shortestPath){
int i;
st_edge* p;
for(i=0;i<VERTEXNUM;i++){
printf("Path from %d to %d:",startVertex,i);
p = *(path+i);
while(p != NULL){
printf("%d(%d) ",p->vertex,p->value);
p = p->next;
}
printf("\n");
printf("the count is:%d\n",shortestPath[i]);
}
}
//最短路径
void dijkstra(int (*edge)[VERTEXNUM], st_edge*** path, int** shortestPath, int startVertex, int* vertexStatusArr){
//初始化最短路径
*path = (st_edge**)malloc(sizeof(st_edge*)*VERTEXNUM);
int i,j;
for(i=0;i<VERTEXNUM;i++){
if(i == startVertex){
st_edge* e = (st_edge*)malloc(sizeof(st_edge));
e->vertex = startVertex;
e->value = 0;
e->next = NULL;
(*path)[i] = e;
}else{
(*path)[i] = NULL;
}
}
//初始化最短路径的权值
*shortestPath = (int *)malloc(sizeof(int)*VERTEXNUM);
for(i=0;i<VERTEXNUM;i++){
if(i == startVertex){
(*shortestPath)[i] = 0;
}else{
(*shortestPath)[i] = -1;
}
}
//从顶点0开始，则顶点0就是已访问的
vertexStatusArr[startVertex] = 1; int shortest, distance,start, end, edgeValue, vNum = 1;
//如果还顶点还没有访问完
while(vNum < VERTEXNUM){
shortest = 9999;
for(i=0;i<VERTEXNUM;i++){
//选择已经访问过的点
if(vertexStatusArr[i] == 1){
for(j=0;j<VERTEXNUM;j++){
//选择一个没有访问过的点
if(vertexStatusArr[j] == 0){
//选出一条value最小的边
if(edge[i][j] != 0 && (distance = getDistance(edge[i][j], startVertex, i, *shortestPath)) < shortest){
shortest = distance;
edgeValue = edge[i][j];
start = i;
end = j;
}
}
}
}
}
vNum++;
//将点设置为访问过
vertexStatusArr[end] = 1;
//保存最短路径权值
(*shortestPath)[end] = shortest;
//保存最短路径
createPath(*path, startVertex, start, end, edgeValue);
}
} //返回从startVertex到新的顶点的距离
int getDistance(int value, int startVertex, int start, int* shortestPath){
if(start == startVertex){
return value;
}else{
return shortestPath[start] + value;
}
} //保存最短路径
void createPath(st_edge **path, int startVertex, int start, int end, int edgeValue){
if(start == startVertex){
st_edge* newEdge = (st_edge*)malloc(sizeof(st_edge));
newEdge->vertex = end;
newEdge->value = edgeValue;
newEdge->next = NULL; st_edge** p = path + end;
while((*p) != NULL){
p = &((*p)->next);
}
*p = newEdge;
}else{
st_edge** pCopySrc = path + start;
st_edge** pCopyDes = path + end;
st_edge* newEdge = NULL;
while((*pCopySrc) != NULL){
newEdge = (st_edge*)malloc(sizeof(st_edge));
*newEdge = **pCopySrc;
newEdge->next = NULL;
*pCopyDes = newEdge;
pCopySrc = &((*pCopySrc)->next);
pCopyDes = &((*pCopyDes)->next);
}
newEdge = (st_edge*)malloc(sizeof(st_edge));
newEdge->vertex = end;
newEdge->value = edgeValue;
newEdge->next = NULL;
*pCopyDes = newEdge;
}
}
c语言实现如下：（使用邻接表存储）
#include <stdio.h>
#include <malloc.h>
#define VERTEXNUM 6 //存放顶点的邻接表元素
//存放最短路径的边元素
typedef struct edge{
int vertex;
int value;
struct edge* next;
}st_edge; void createGraph(st_edge** edge, int start, int end, int value);
void displayGraph(st_edge** edge);
void delGraph(st_edge** edge);
void dijkstra(st_edge** edge, st_edge*** path, int** shortestPath, int startVertex, int* vertexStatusArr);
void displayPath(st_edge** path, int startVertex,int* shortestPath);
int getDistance(int value, int startVertex, int start, int* shortestPath);
void createPath(st_edge **path, int startVertex, int start, int end, int edgeValue); int main(void){
//动态创建存放边的指针数组
st_edge** edge = (st_edge**)malloc(sizeof(st_edge*)*VERTEXNUM);
int i;
for(i=0;i<VERTEXNUM;i++){
edge[i] = NULL;
}
//存放顶点的遍历状态，0：未遍历，1：已遍历
int* vertexStatusArr = (int*)malloc(sizeof(int)*VERTEXNUM);
for(i=0;i<VERTEXNUM;i++){
vertexStatusArr[i] = 0;
} printf("after init:\n");
displayGraph(edge);
//创建图
createGraph(edge,0,1,6);
createGraph(edge,0,3,5);
createGraph(edge,0,2,1);
createGraph(edge,1,2,5);
createGraph(edge,1,4,3);
createGraph(edge,2,4,6);
createGraph(edge,2,3,5);
createGraph(edge,2,5,4);
createGraph(edge,3,5,2);
createGraph(edge,4,5,6); printf("after create:\n");
displayGraph(edge); //最短路径
/*存储的结构如下：
path[0]:edge0->NULL
path[1]:edge1->NULL
path[2]:edge1->edge2->NULL
path[3]:edge1->edge2->edge3->NULL
path[4]:edge4->NULL
从顶点0到0的最短路径：从0出发直接到0
从顶点0到1的最短路径：从0出发直接到1
从顶点0到2的最短路径：从0出发到1，从1出发到2
......
*/
st_edge** path = NULL;
//存储最短路径的权值
/*
shortestPath[0] = 0;
shortestPath[1] = 8;
shortestPath[2] = 12;
从顶点0到0的路径是0
从顶点0到1的路径是8
从顶点0到2的路径是12
*/
int* shortestPath = NULL;
int startVertex = 0;
//最短路径
dijkstra(edge, &path, &shortestPath, startVertex, vertexStatusArr);
printf("the path is:\n");
displayPath(path,startVertex,shortestPath); delGraph(edge);
edge = NULL; delGraph(path);
path = NULL; if(vertexStatusArr != NULL){
free(vertexStatusArr);
vertexStatusArr = NULL;
} if(shortestPath != NULL){
free(shortestPath);
shortestPath = NULL;
}
return 0;
}
//创建图
void createGraph(st_edge** edge, int start, int end, int value){
st_edge* newedge1 = (st_edge*)malloc(sizeof(st_edge));
newedge1->vertex = end;
newedge1->value = value;
newedge1->next = NULL;
st_edge** edge1 = edge + start;
while(*edge1 != NULL){
edge1 = &((*edge1)->next);
}
*edge1 = newedge1; st_edge* newedge2 = (st_edge*)malloc(sizeof(st_edge));
newedge2->vertex = start;
newedge2->value = value;
newedge2->next = NULL;
st_edge** edge2 = edge + end;
while(*edge2 != NULL){
edge2 = &((*edge2)->next);
}
*edge2 = newedge2;
}
//打印存储的图
void displayGraph(st_edge** edge){
int i;
st_edge* p;
for(i=0;i<VERTEXNUM;i++){
printf("%d:",i);
p = *(edge+i);
while(p != NULL){
printf("%d(%d) ",p->vertex,p->value);
p = p->next;
}
printf("\n");
}
}
//打印最短路径
void displayPath(st_edge** path, int startVertex,int* shortestPath){
int i;
st_edge* p;
for(i=0;i<VERTEXNUM;i++){
printf("Path from %d to %d:",startVertex,i);
p = *(path+i);
while(p != NULL){
printf("%d(%d) ",p->vertex,p->value);
p = p->next;
}
printf("\n");
printf("the count is:%d\n",shortestPath[i]);
}
}
//释放邻接表占用的内存
void delGraph(st_edge** edge){
int i;
st_edge* p;
st_edge* del;
for(i=0;i<VERTEXNUM;i++){
p = *(edge+i);
while(p != NULL){
del = p;
p = p->next;
free(del);
}
edge[i] = NULL;
}
free(edge);
}
//dijkstra求最短路径
void dijkstra(st_edge** edge, st_edge*** path, int** shortestPath, int startVertex, int* vertexStatusArr){
//初始化最短路径
*path = (st_edge**)malloc(sizeof(st_edge*)*VERTEXNUM);
int i,j;
for(i=0;i<VERTEXNUM;i++){
if(i == startVertex){
st_edge* e = (st_edge*)malloc(sizeof(st_edge));
e->vertex = startVertex;
e->value = 0;
e->next = NULL;
(*path)[i] = e;
}else{
(*path)[i] = NULL;
}
}
//初始化最短路径的权值
*shortestPath = (int *)malloc(sizeof(int)*VERTEXNUM);
for(i=0;i<VERTEXNUM;i++){
if(i == startVertex){
(*shortestPath)[i] = 0;
}else{
(*shortestPath)[i] = -1;
}
} vertexStatusArr[startVertex] = 1; st_edge* p;
int shortest, distance, edgeValue, start, end, vNum = 1;
//如果还顶点还没有访问完
while(vNum < VERTEXNUM){
shortest = 9999;
for(i=0;i<VERTEXNUM;i++){
//选择已经访问过的点
if(vertexStatusArr[i] == 1){
for(j=0;j<VERTEXNUM;j++){
//选择一个没有访问过的点
if(vertexStatusArr[j] == 0){
p = *(edge+i);
while(p != NULL){
//如果从startVertex到j的距离小于shortest
if((distance = getDistance(p->value, startVertex, i, *shortestPath)) < shortest && p->vertex == j){
shortest = distance;
edgeValue = p->value;
start = i;
end = j;
}
p = p->next;
}
}
}
}
}
vNum++;
vertexStatusArr[end] = 1;
//保存最短路径的权值
(*shortestPath)[end] = shortest;
//保存最短路径
createPath(*path, startVertex, start, end, edgeValue);
}
}
//返回从startVertex到新的顶点的距离
int getDistance(int value, int startVertex, int start, int* shortestPath){
if(start == startVertex){
return value;
}else{
return value + shortestPath[start];
}
}
//保存最短路径
void createPath(st_edge **path, int startVertex, int start, int end, int edgeValue){
if(start == startVertex){
st_edge* newEdge = (st_edge*)malloc(sizeof(st_edge));
newEdge->vertex = end;
newEdge->value = edgeValue;
newEdge->next = NULL; st_edge** p = path + end;
while((*p) != NULL){
p = &((*p)->next);
}
*p = newEdge;
}else{
st_edge** pCopySrc = path + start;
st_edge** pCopyDes = path + end;
st_edge* newEdge = NULL;
while((*pCopySrc) != NULL){
newEdge = (st_edge*)malloc(sizeof(st_edge));
*newEdge = **pCopySrc;
newEdge->next = NULL;
*pCopyDes = newEdge;
pCopySrc = &((*pCopySrc)->next);
pCopyDes = &((*pCopyDes)->next);
}
newEdge = (st_edge*)malloc(sizeof(st_edge));
newEdge->vertex = end;
newEdge->value = edgeValue;
newEdge->next = NULL;
*pCopyDes = newEdge;
}
}
图之Dijkstra算法的更多相关文章
- Dijkstra 算法，用于对有权图进行搜索，找出图中两点的最短距离
Dijkstra 算法,用于对有权图进行搜索,找出图中两点的最短距离,既不是DFS搜索,也不是BFS搜索. 把Dijkstra 算法应用于无权图,或者所有边的权都相等的图,Dijkstra 算法等同于 ...
- 【算法设计与分析基础】25、单起点最短路径的dijkstra算法
首先看看这换个数据图 邻接矩阵 dijkstra算法的寻找最短路径的核心就是对于这个节点的数据结构的设计 1.节点中保存有已经加入最短路径的集合中到当前节点的最短路径的节点 2.从起点经过或者不经过 ...
- 单源最短路径（1）：Dijkstra 算法
一:背景 Dijkstra 算法(中文名:迪杰斯特拉算法)是由荷兰计算机科学家 Edsger Wybe Dijkstra 提出.该算法常用于路由算法或者作为其他图算法的一个子模块.举例来说,如果图中的 ...
- Dijkstra算法(朴素实现、优先队列优化)
Dijkstra算法只能求取边的权重为非负的图的最短路径,而Bellman-Ford算法可以求取边的权重为负的图的最短路径(但Bellman-Ford算法在图中存在负环的情况下,最短路径是不存在的(负 ...
- 理解最短路径-Dijkstra算法
最短路径—Dijkstra算法和Floyd算法 透彻理解迪杰斯特拉算法 Dijkstra算法的使用条件:图中不存在负权边. ---------------------------有待验证------- ...
- 带权图的最短路径算法(Dijkstra)实现
一,介绍 本文实现带权图的最短路径算法.给定图中一个顶点,求解该顶点到图中所有其他顶点的最短路径 以及 最短路径的长度.在决定写这篇文章之前,在网上找了很多关于Dijkstra算法实现,但大部分是不带 ...
- python数据结构与算法——图的最短路径（Dijkstra算法）
# Dijkstra算法——通过边实现松弛 # 指定一个点到其他各顶点的路径——单源最短路径 # 初始化图参数 G = {1:{1:0, 2:1, 3:12}, 2:{2:0, 3:9, 4:3}, ...
- C++编程练习(11)----“图的最短路径问题“（Dijkstra算法、Floyd算法）
1.Dijkstra算法 求一个顶点到其它所有顶点的最短路径,是一种按路径长度递增的次序产生最短路径的算法. 算法思想: 按路径长度递增次序产生算法: 把顶点集合V分成两组: (1)S:已求出的顶点的 ...
- 数据结构与算法系列研究七——图、prim算法、dijkstra算法
图.prim算法.dijkstra算法 1. 图的定义 图(Graph)可以简单表示为G=<V, E>,其中V称为顶点(vertex)集合,E称为边(edge)集合.图论中的图(graph ...
随机推荐
- python+selenium第一步 - 环境搭建
刚开始学习一门技术,肯定是要从环境搭建开始的,我也不例外. 首先选择需要安装的版本,我使用的是mac自带的2.7版本. selenium2,和火狐浏览器 为求稳定不会出现未知问题,我选择了seleni ...
- IntelliJ IDEA 里 查看一个函数注释的方法是 ctrl+q
ctrl + q 也可以看到 官方的文档注释,java真是个强大的东西,官方的每个函数都有注释,这些注释 自动生成了官方的文档,所以看官方的注释 就是 看 官方的文档.
- 2016-2017-2 20155309南皓芯《java程序设计》第十周学习总结
教材内容总结 网络编程 定义:网络编程就是在两个或两个以上的设备之间传输数据. 计算机网络概述: 网络编程的实质就是两个(或多个)设备(例如计算机)之间的数据传输. 网络中的每个设备都会有一个唯一的数 ...
- 在Visio里加上、下标方法
添加上标:选中要成为上标的文字,ctrl+shift+“=” 添加下标:选中要成为下标的文字,ctrl+“=”
- 通过okhttp3下载文件实现APP版本更新
原文:https://blog.csdn.net/qq_34261214/article/details/77124729 概况 思路是这样的,首先在服务器上把已经签名打包的apk放上去,还有一份TX ...
- jquery插件使用记录
1.imgPreview(图片预览功能插件) demo地址:http://james.padolsey.com/demos/imgPreview/full/
- 使用Caffe训练适合自己样本集的AlexNet网络模型，并对其进行分类
1.在开始之前,先简单回顾一下几个概念. Caffe(Convolution Architecture For Feature Extraction-卷积神经网络框架):是一个清晰,可读性高,快速的深 ...
- 浅谈jvm
1 .说起jvm,很多人感觉jvm离我们开发实际很远.但是,我们开发缺每时每刻都离不开jvm. a: java源码 编译后成.class字节码文件, b:根据classpath找到这个字节码文件, c ...
- win10字体大小设置
有时图形化界面不能正常显示,需要改变字体大小来查看 更改字体大小: 更改字体:
- QT STUDY 模型-视图-控制器