迪杰斯特拉(Dijkstra)算法

  1 # include <stdio.h>
  2
  3 # define MAX_VERTEXES 20//最大顶点数
  4 # define INFINITY 65535;//代表∞
  5
  6 typedef struct
  7 {/*    无向图结构体    */
  8     int vexs[MAX_VERTEXES];//顶点下标
  9     int arc[MAX_VERTEXES][MAX_VERTEXES];//矩阵
 10     int numVertexes, numEdges;//顶点数和边数
 11
 12 }MGraph;
 13
 14 typedef int PathArc[MAX_VERTEXES];//存储最短路径的下表数组
 15 typedef int ShortPathTable[MAX_VERTEXES];//存储最短路径的权值数组
 16
 17 void CreateMGraph (MGraph *G)
 18 {/*    创建 */
 19     int i, j;
 20
 21     //printf ("请输入顶点数和边数");
 22     G->numVertexes = 9;//顶点
 23     G->numEdges = 16;//边
 24
 25     for (i=0; i<G->numVertexes; i++)
 26         G->vexs[i] = i;//初始化顶点下标
 27
 28     for (i=0; i<G->numVertexes; i++)//初始化矩阵
 29         for (j=0; j<G->numVertexes; j++)
 30             if (i == j)
 31                 G->arc[i][j] = 0;//本身则0
 32             else
 33                 G->arc[i][j] = INFINITY;//否则为∞
 34
 35     //提前手动输入
 36     G->arc[0][1]=1;
 37     G->arc[0][2]=5;
 38     G->arc[1][2]=3;
 39     G->arc[1][3]=7;
 40     G->arc[1][4]=5;
 41
 42     G->arc[2][4]=1;
 43     G->arc[2][5]=7;
 44     G->arc[3][4]=2;
 45     G->arc[3][6]=3;
 46     G->arc[4][5]=3;
 47
 48     G->arc[4][6]=6;
 49     G->arc[4][7]=9;
 50     G->arc[5][7]=5;
 51     G->arc[6][7]=2;
 52     G->arc[6][8]=7;
 53
 54     G->arc[7][8]=4;
 55
 56     for (i=0; i<G->numVertexes; i++)//无向图--矩阵上三角对称下三角
 57         for (j=i; j<G->numVertexes; j++)
 58             if (i != j)
 59                 G->arc[j][i] = G->arc[i][j];
 60
 61     return ;
 62
 63 }
 64
 65 //P数组-存放最短路径顶点的下标,D数组-存放最短路径(权值)
 66 void Shorsequence_Path_Dijkstra (MGraph G, int v0, PathArc *P, ShortPathTable *D)
 67 {/*    迪杰斯特拉 算法 - 生成最短路径    */
 68     int v, w, k, min;
 69     int final[MAX_VERTEXES];    //final[w] = 1,表示求得顶点v0→vw的最短路径
 70
 71     for (v=0; v<G.numVertexes; v++)
 72     {//初始化
 73         final[v] = 0;            //全部顶点初始化为未知最短路径状态
 74         (*D)[v] = G.arc[v0][v]; //和v0有连线的点加上权值
 75         (*P)[v] = -1;            //初始化路径下标数组初始值为-1;
 76     }
 77
 78     (*D)[v0] = 0;                //v0→v0的路径-权值-为0
 79     final[v0] = 1;                //v0→v0不需要求路径
 80
 81     /*    开始主循环,每次循环求v0到某个v顶点的最短路径    */
 82     for (v=1; v<G.numVertexes; v++)
 83     {
 84         min = INFINITY;            //初始化-目前所知离v0顶点的最近距离
 85
 86         //注意:这里不要想着w=v;因为程序执行的时候有的顶点不符合是直接跨过去了,然后置0是为了循环访问未访问的顶点
 87         for (w=0; w<G.numVertexes; w++)//查找和v0最近的顶点
 88             if (!final[w] && (*D)[w]<min)
 89             {//该顶点未被访问过,并且小于min
 90                 k = w;            //k存入最近顶点的下标
 91                 min = (*D)[w];    //min存入最短路径
 92             }
 93
 94         final[k] = 1;            //将目前找到最近的顶点-做标记
 95
 96         for (w=0; w<G.numVertexes; w++)//目前找到与v0最近的顶点下标k,然后继续寻找与k顶点最近的下标
 97             if (!final[w] && (min+G.arc[k][w] < (*D)[w]))
 98             {//若顶点未被访问 并且    (目前最短路径(权值)v0→k + 目前最近的顶点(k)有关联的顶点路径(权值))小于 v0有关联的权路径(权值)
 99                 (*D)[w] = min + G.arc[k][w];//则与k顶点相关的权值+min--覆盖D数组
100                 (*P)[w] = k;    //则与v0最近的顶点k顶点下标 给 P数组;
101             }//(*D)[w] = min实际上就是上一个顶点和k顶点最短路径的 + arc[k][w]
102     }
103
104     return ;
105 }
106
107 int main (void)
108
109 {
110     int i, j, v0;
111     int number = 0;
112     int sequence[MAX_VERTEXES][MAX_VERTEXES];
113     MGraph G;
114     PathArc P;
115     ShortPathTable D;                       //某点到各点的最短路径
116     v0 = 0;
117
118     CreateMGraph (&G);                       //创建
119
120     Shorsequence_Path_Dijkstra (G, v0, &P, &D);//迪杰斯特拉 算法 - 生成最短路径
121
122     //初始化正序输出的数组
123     for (i=0; i<G.numVertexes; i++)
124         for (j=0; j<G.numVertexes; j++)
125             sequence[i][j] = 0;
126
127     /*    P数组-存放最短路径顶点的下标,D数组-存放最短路径(权值)    */
128
129     printf ("最短路径倒序如下:\n");
130     for (i=1; i<G.numVertexes; i++)
131     {
132         printf ("v%d--v%d\t:  ", v0, i);
133         j = i;
134         while (P[j] != -1)
135         {//若存在下一个顶点
136             printf ("%d  ", P[j]);//则输出顶点
137             j = P[j];//按顺序查找
138             number ++;//记录(辅助正序输出)
139         }
140
141         //离上一个顶点最近的顶点的下标-赋值给sequence数组
142         j = i;
143         while (0<number && P[j] != -1)
144         {
145             sequence[i][number--] = P[j];
146             j = P[j];
147         }
148         number = 0;
149         printf ("\n");
150     }
151
152     //自己修改的
153     printf ("\n最短路径正序如下:\n");
154     for (i=1; i<G.numVertexes; i++)
155     {
156         j = 1;
157         printf ("v%d--v%d\t:  ", v0, i);
158         while (sequence[i][j] != 0)
159             printf ("%d   ", sequence[i][j++]);
160         printf ("\n");
161     }
162
163     printf ("\n源点到各个点的最短路径为:\n");
164     for (i=1; i<G.numVertexes; i++)
165         printf ("v%d--v%d  :  %d\n", G.vexs[0], G.vexs[i], D[i]);
166
167     return 0;
168 }
时间: 2024-10-25 12:03:11

迪杰斯特拉(Dijkstra)算法的相关文章

43. 蛤蟆的数据结构笔记之四十三最短路径之迪杰斯特拉(Dijkstra )算法

43. 蛤蟆的数据结构笔记之四十三最短路径之迪杰斯特拉(Dijkstra )算法 本篇名言:"辛勤的蜜蜂永没有时间悲哀.--布莱克" 这次来看下Dijkstra )算法.还是老方法,先原理,后实现.代码来自网络. 欢迎转载,转载请标明出处:http://blog.csdn.net/notbaron/article/details/47046031 1.  最短路径 最短路径问题是图论研究中的一个经典算法问题, 旨在寻找图(由结点和路径组成的)中两结点之间的最短路径. 管道铺设.线路安排

C# 迪杰斯特拉(Dijkstra)算法

Dijkstra(迪杰斯特拉)算法是典型的最短路径路由算法,用于计算一个节点到其他所有节点的最短路径.主要特点是以起始点为中心向外层层扩展,直到扩展到终点为止. 其基本思想是,设置顶点集合S并不断地作贪心选择来扩充这个集合.一个顶点属于集合S当且仅当从源到该顶点的最短路径长度已知. 初始时,S中仅含有源.设u是G的某一个顶点,把从源到u且中间只经过S中顶点的路称为从源到u的特殊路径,并用数组dist记录当前每个顶点所对应的最短特殊路径长度.Dijkstra算法每次从V-S中取出具有最短特殊路长度

[C++]单源最短路径:迪杰斯特拉(Dijkstra)算法(贪心算法)

1 Dijkstra算法 1.1 算法基本信息 解决问题/提出背景 单源最短路径(在带权有向图中,求从某顶点到其余各顶点的最短路径) 算法思想 贪心算法 按路径长度递增的次序,依次产生最短路径的算法 [适用范围]Dijkstra算法仅适用于[权重为正]的图模型中 时间复杂度 O(n^3) 补充说明 亦可应用于[多源最短路径](推荐:Floyd算法(动态规划,O(n^3))) Dijkstra 时间复杂度:O(n^3) 1.2 算法描述 1.2.1 求解过程(具体思路) 1.2.2 示例 1.2

迪杰斯特拉(Dijkstra)算法求最短路径

我用的是邻接矩阵来存储图的. 代码如下: void Graph:: Dijkstra(){ struct DijNode{ int index; int distance; vector<string> path; bool Founded; //判定是否找到了... }; DijNode*shorestPaths=new DijNode[mgraph.vexnum]; string startPoint; int startIndex; cout<<"请输入单源点:&q

迪杰斯特拉/dijkstra 算法模板(详细注释)

#include <iostream> #include <malloc.h> #include <cstring> #include <stack> #include <cstdio> //定义邻接矩阵的大小 #define N 100 #define M 100 using namespace std; typedef struct node { int map[N][M];//邻接矩阵 int n;//顶点数 int e;//边数 }MGr

迪杰斯特拉/dijkstra 算法模板(具体凝视)

#include <iostream> #include <malloc.h> #include <cstring> #include <stack> #include <cstdio> //定义邻接矩阵的大小 #define N 100 #define M 100 using namespace std; typedef struct node { int map[N][M];//邻接矩阵 int n;//顶点数 int e;//边数 }MGr

数据结构之---C语言实现最短路径之Dijkstra(迪杰斯特拉)算法

此处共有两段代码: 一. 这段代码比较全面,其中参考了github上的相关源码.可以说功能强大. //Dijkstra(迪杰斯特拉算法) #include <stdio.h> #include <stdlib.h> #include <string.h> #define MAX 100 // 矩阵最大容量 #define INF 65535 // 最大值65535 #define isLetter(a) ((((a)>='a')&&((a)<

看数据结构写代码(47)迪杰斯特拉最短路径算法

这个算法的 思想 根 求 最小生成树算法 普里姆(Prim)算法 极其相似.迪杰斯算法 是求 一个顶点 到其他 顶点的 最短路径算法. 下面 上代码:(用的是 邻接矩阵 表示法) //迪杰斯特拉 最短路径. //从 vex顶点 到其他 顶点的 最短路径 void shortestPath_Dij(MGraph g,char vex){ int loc = graphLocation(g,vex); int minArray[MAX_VERTEX_NUM]={0};//最小路径值 bool fin

算法学习 - Dijkstra(迪杰斯特拉)算法学习

Dijkstra算法 其实Dijkstra是单源点最短路径的基础算法,这个算法的目的就是找到一个图中的某个点V到这个图中其他点的最短路径. 条件 有向图 没有负权值路径 时间复杂度:O(E) + O(V^2) = O(V^2) 当图是稠密的时候和稀疏的时候时间复杂度还是有点差别的. 代码实现 其实这个还挺简单的,单源点最短路径还有一个Bellman-Ford算法,以后在写,比较简单. Dijkstra算法: // // main.cpp // Dijkstra // // Created by