最短路径(单源 dijkstra算法-邻接矩阵)
dijkstra算法代码python
dijkstra算法代码pythonDijkstra算法是一种贪心算法，用于计算图中单源最短路径。
该算法基于贪心算法的原则，每次选择一个距离源点最近的顶点，然后更新这个顶点的邻元素的距离。
算法步骤：1. 初始化距离数组，设置源点的距离为0，其余点的距离为无穷大（表示没有到达该点的路径）。
2. 创建一个空的集合S，用于存放已经求出的最短路径的结点。
3. 循环执行以下步骤，直到所有点都被添加到集合S中：- 在未确定最短路径的结点中，选择距离源点最近的结点，并将该结点添加到S集合中。
- 更新该结点的邻元素的距离，如果新路径的距离小于目前已知的最短路径，则更新最短路径。
在实现Dijkstra算法时，需要使用图的邻接矩阵或邻接表来表示图。
下面是使用邻接矩阵实现Dijkstra算法的Python代码：def dijkstra(graph, src):# 初始化距离数组dist = [float('inf')] * len(graph)# 设置源点的距离为0dist[src] = 0# 用于存放最短路径的结点s = []# 循环执行直到所有点都被添加到集合S中while len(s) < len(graph):# 在未确定最短路径的结点中，选择距离源点最近的结点，并将该结点添加到集合S 中min_dist = float('inf')min_index = -1for i in range(len(graph)):if i not in s and dist[i] < min_dist:min_dist = dist[i]min_index = is.append(min_index)return dist# 示例graph = [[0, 2, 4, 0, 0],[2, 0, 1, 3, 0],[4, 1, 0, 5, 6],[0, 3, 5, 0, 2],[0, 0, 6, 2, 0]]上述代码通过邻接矩阵表示图，其中0表示两点之间没有边，其他数字表示该边的边权。
邻接矩阵求最短路径c语言
邻接矩阵求最短路径c语言邻接矩阵表示图中各个节点之间的关系，在求解最短路径问题中，邻接矩阵是非常重要的数据结构之一。
下面是一个简单的C语言程序，用于利用邻接矩阵求解最短路径问题。
首先，我们需要定义一个邻接矩阵。
假设我们有一个图，其中有5个节点，节点编号从1到5，邻接矩阵可以表示为一个5x5的二维数组，其中arr[i][j]表示从节点i到节点j的距离。
如果两个节点之间没有直接的边，则arr[i][j]的值为无穷大。
接下来，我们需要使用Dijkstra算法来求解最短路径。
该算法使用贪心策略，在每一次迭代中，选择当前距离源点最近的节点，并以该节点为中心更新其周围的节点的距离。
具体实现如下：1. 定义一个长度为n的数组dist，其中dist[i]表示从源点到节点i的距离。
2. 将dist数组初始化为无穷大，源点的dist值为0。
3. 定义一个长度为n的数组visited，标记已经被访问过的节点。
4. 循环n次，每次选择一个距离源点最近的未被访问过的节点u。
5. 标记节点u为已经访问过。
6. 遍历节点u的所有邻居v，如果从源点到v的距离通过u可以更新，则更新dist[v]的值。
7. 返回dist数组，即为从源点到各个节点的最短距离。
下面是一个简单的C语言程序，用于实现邻接矩阵求最短路径的功能。
```c#include <stdio.h>#define INF 99999#define MAX_N 100int arr[MAX_N][MAX_N]; //邻接矩阵int dist[MAX_N]; //存储最短距离int visited[MAX_N]; //标记已经被访问过的节点int n; //节点数int minDistance() {int minDist = INF;int minIndex = -1;for (int i = 0; i < n; i++) {if (visited[i] == 0 && dist[i] < minDist) {minDist = dist[i];minIndex = i;}}return minIndex;}void dijkstra(int start) {//初始化dist数组和visited数组for (int i = 0; i < n; i++) {dist[i] = INF;visited[i] = 0;}dist[start] = 0;for (int i = 0; i < n - 1; i++) {int u = minDistance();visited[u] = 1;for (int v = 0; v < n; v++) {if (visited[v] == 0 && arr[u][v] != INF && dist[u] + arr[u][v] < dist[v]) {dist[v] = dist[u] + arr[u][v];}}}}int main() {//初始化邻接矩阵n = 5;for (int i = 0; i < n; i++) {for (int j = 0; j < n; j++) {arr[i][j] = INF;}}arr[0][1] = 10;arr[0][4] = 5;arr[1][2] = 1;arr[1][4] = 2;arr[2][3] = 4;arr[3][2] = 6;arr[3][0] = 7;arr[4][1] = 3;arr[4][2] = 9;arr[4][3] = 2;//执行Dijkstra算法dijkstra(0);//输出结果for (int i = 0; i < n; i++) {printf('从节点0到节点%d的最短距离是%d ', i, dist[i]);}return 0;}```代码中，我们使用了INF表示两个节点之间没有直接的边。
Dijkstra最短路径算法的实现及优化
Ｄｉｊｋｓｔｒａ最短路径算法的实现及优化 施培港 厦门信息港建设发展股份有限公司 厦门市槟榔路１号联谊广场五层 ３６１００４ Ｅｍａｉｌ：ｓｐｇ＠ｘｍｉｎｆｏｐｏｒｔ．ｃｏｍ 摘要：最短路径算法种类繁多，比较有名的算法包括：Ｄｉｊｋｓｔｒａ算法、Ｆｏｒｄ算法、Ｆｌｏｙｄ算法、Ｍｏｏｒｅ算法、Ａ＊算法、Ｋ值算法，而即使同一种算法也有多种不同的实现方式。
本文就Ｄｉｊｋｓｔｒａ算法的两种实现方式做一定的分析，并采用一种新的实现方法达到对算法优化的目的。
关键字：Ｄｉｊｋｓｔｒａ算法 最短路径 网络分析 地理信息系统（ＧＩＳ） １． 何谓最短路径 所谓最短路径就是网络中两点之间距离最短的路径，这里讲的距离可以是实际的距离，也可以引申为其它的度量，如时间、运费、流量等。
因此，从广义上讲，最短路径算法就是指从网络中找出两个点之间最小阻抗路径的算法。
２． Ｄｉｊｋｓｔｒａ算法介绍 Ｄｉｊｋｓｔｒａ算法本身是一种贪婪算法，它通过分步的方法来求最短路径。
首先，初始产生源点到它自身的路径，其长度为零，然后在贪婪算法的每一步中，产生一个到达新的目的顶点的最短路径。
其算法描述如下（算法中以有向图表示网络结构）： 对于有向图Ｇ ＝（Ｖ，Ｅ），图中有ｎ个顶点，有ｅ条弧，其中Ｖ为顶点的集合，Ｅ为弧的集合，求源点ＶＳ到终点ＶＴ的最短路径。
（１） 用带权的邻接矩阵Ｌ来表示有向图，Ｌ（Ｘ，Ｙ）表示弧＜Ｘ，Ｙ＞的权值，若弧＜Ｘ，Ｙ＞不存在，则设Ｌ（Ｘ，Ｙ）＝∞；用Ｄ（Ｘ）表示源点ＶＳ到顶点Ｘ的距离，除源点ＶＳ的值为０外，其余各点设为∞；用Ｓ表示已找到的从源点ＶＳ出发的最短路径的顶点的集合，其初始状态为空集；用Ｖ－Ｓ表示未找到最短路径的顶点的集合； （２） 选择源点ＶＳ做标记，令Ｙ ＝ ＶＳ，Ｓ ＝ Ｓ ∪ ｛ＶＳ｝； （３） 对于Ｖ－Ｓ中各顶点， 若Ｄ（Ｘ） ＞ Ｄ（Ｙ） ＋ Ｌ（Ｙ，Ｘ），则修改Ｄ（Ｘ）为 Ｄ（Ｘ） ＝ Ｄ（Ｙ） ＋ Ｌ（Ｙ，Ｘ） 其中Ｙ是己确定作标记的点； （４） 选择Ｖｊ，使得Ｄ（ｊ） ＝ ｍｉｎ｛ Ｄ（ｉ） ｜ Ｖｉ ∈ Ｖ－Ｓ ｝ 若Ｄ（ｊ）为∞，则说明ＶＳ到Ｖ－Ｓ中各顶点都没有通路，算法终止；否则，Ｖｊ就是当前求得的一条从源点ＶＳ出发的最短路径的终点，对Ｖｊ做标记，令Ｙ ＝ Ｖｊ，并把Ｖｊ放入集合Ｓ中，即令Ｓ ＝ Ｓ ∪ ｛Ｖｊ｝； （５） 如果Ｙ等于ＶＴ，则说明已经找到从ＶＳ到ＶＴ的最短路径，算法终止；否则，转到３继续执行。
最短距离算法范文
最短距离算法范文最短路径算法被广泛应用于许多领域，例如路由算法、导航系统、网络优化等。
本文将介绍三种常见的最短距离算法：Dijkstra算法、贝尔曼-福特算法和弗洛伊德算法。
1. Dijkstra算法：Dijkstra算法是一种基于贪心的算法，用于解决单源最短路径问题。
在一个有向加权图中，该算法从源节点开始，逐步选择与源节点距离最短的节点，直到到达目标节点。
具体步骤如下：1）创建一个距离列表，记录源节点到每个节点的距离，初始状态为无限大。
2）将源节点的距离设置为0，并标记为已访问。
3）从源节点开始，遍历与当前节点相邻的节点，并更新距离列表中的距离。
4）选择一个当前距离最小的节点，标记为已访问。
5）重复步骤3和步骤4，直到目标节点被标记为已访问或没有节点可访问。
2.贝尔曼-福特算法：贝尔曼-福特算法是一种解决任意两个节点之间最短路径的算法。
该算法通过多次迭代，逐步更新节点之间的距离，直到收敛到最短路径为止。
具体步骤如下：1）创建一个距离列表，记录源节点到每个节点的初始距离，初始状态为无限大。
2）将源节点的距离设置为0。
3）重复以下步骤N-1次（N为图中节点的个数）：a)遍历图中的每条边，如果当前边的权重与源节点到边的起点的距离之和小于边的终点的距离，则更新边终点的距离。
4）遍历图中的每条边，如果存在一条边满足上述条件，则图中存在负权重环，算法无法得出最短路径。
5）如果没有负权重环，则距离列表即为最短路径。
3.弗洛伊德算法：弗洛伊德算法是一种解决任意两个节点之间最短路径的算法。
该算法通过多次迭代，逐步更新节点之间的距离，直到收敛到最短路径为止。
与贝尔曼-福特算法不同的是，弗洛伊德算法可以处理含有负权重边的图。
具体步骤如下：1）创建一个邻接矩阵，用于记录每对节点之间的初始距离。
2）通过多次迭代，根据节点之间的中间节点更新距离矩阵。
3）重复以下步骤N次（N为图中节点的个数）：a)遍历图中的每对节点，如果当前节点之间的距离大于通过一些中间节点的距离之和，则更新距离矩阵中的距离。
迪杰斯特拉算法c语言从某个源点到其余各顶点的最短路径 -回复
迪杰斯特拉算法c语言从某个源点到其余各顶点的最短路径-回复如何用C语言实现Dijkstra算法来找出从某个源点到其余各顶点的最短路径。
第一步：了解Dijkstra算法的基本原理Dijkstra算法是一种解决单源最短路径的经典算法。
它通过不断更新顶点的最短距离来求解从源点到其他顶点的最短路径。
算法基于一个贪心策略，每次选择当前最短距离的节点进行松弛操作，并标记该节点为已访问。
具体而言，算法包括以下步骤：1. 初始化，设置源点距离为0，其他所有节点的距离设为无穷大。
2. 选择距离源点最近的节点作为当前节点，并将它标记为已访问。
3. 遍历当前节点的所有邻接节点，如果经过当前节点到达邻接节点的距离比已知的最短距离小，则更新该邻接节点的最短距离。
4. 重复步骤2和3，直到所有节点都被标记为已访问，或者所有节点的最短距离都已确定。
第二步：创建数据结构来表示图为了实现Dijkstra算法，我们需要使用图数据结构来表示顶点和它们之间的边。
在C语言中，我们可以使用邻接矩阵和邻接链表两种方式来表示图。
邻接链表相对而言更加灵活和高效，因此我们选择使用邻接链表来表示图。
我们可以创建一个结构体来表示顶点，其中包含了顶点的索引、距离以及指向邻接节点的指针。
另外，我们还需要创建一个结构体来表示边，其中包含了边的权重和指向目标顶点的指针。
第三步：实现Dijkstra算法的主要函数首先，我们需要编写一个用于初始化图的函数，其中包括创建顶点和边的操作。
具体而言，我们可以使用邻接链表，将每个顶点作为链表的头节点，链表中的每个节点表示一个边，其中包含目标顶点的索引、权重和指向下一条边的指针。
接下来，我们需要编写一个用于查找当前最短距离的函数。
在该函数中，我们遍历所有未访问的节点，并返回距离源点最近的节点。
然后，我们需要编写一个用于更新当前节点的邻接节点的最短距离的函数。
在该函数中，我们遍历当前节点的邻接节点，如果通过当前节点到达邻接节点的距离比已知的最短距离小，则更新该邻接节点的最短距离。
最短路问题(整理版)
最短路问题(short-path problem)若网络中的每条边都有一个权值值(长度、成本、时间等)，则找出两节点(通常是源节点与结束点)之间总权和最小的路径就是最短路问题。
最短路问题是网络理论解决的典型问题之一，可用来解决管路铺设、线路安装、厂区布局和设备更新等实际问题。
最短路问题，我们通常归属为三类：单源最短路径问题（确定起点或确定终点的最短路径问题）、确定起点终点的最短路径问题（两节点之间的最短路径）1、Dijkstra算法：用邻接矩阵a表示带权有向图，d为从v0出发到图上其余各顶点可能达到的最短路径长度值，以v0为起点做一次dijkstra，便可以求出从结点v0到其他结点的最短路径长度代码：procedure dijkstra（v0：longint）；//v0为起点做一次dijkstrabegin//a数组是邻接矩阵，a[i,j]表示i到j的距离，无边就为maxlongintfor i:=1 to n do d[i]:=a[v0,i];//初始化d数组（用于记录从v0到结点i的最短路径）， fillchar(visit,sizeof(visit),false);//每个结点都未被连接到路径里visit[v0]:=true;//已经连接v0结点for i:=1 to n-1 do//剩下n-1个节点未加入路径里；beginmin:=maxlongint;//初始化minfor j:=1 to n do//找从v0开始到目前为止，哪个结点作为下一个连接起点（*可优化） if (not visit[j]) and (min>d[j]) then//结点k要未被连接进去且最小begin min:=d[j];k:=j;end;visit[k]:=true;//连接进去for j:=1 to n do//刷新数组d，通过k来更新到达未连接进去的节点最小值，if (not visit[j]) and (d[j]>d[k]+a[k,j]) then d[j]:=a[k,j]+d[k];end;writeln(d[n]);//结点v0到结点n的最短路。
单源最短路径
单源最短路径问题I 用贪心算法求解贪心算法是一种经典的算法，通常以自顶向下的方式进行，以迭代的方式作出相继的贪心选择，每作一次贪心选择就将所求问题简化为规模更小的子问题。
一般具有2个重要的性质：贪心选择性质和最优子结构性质。
一、问题描述与分析单源最短路径问题是一个经典问题，给定带权有向图G =(V,E)，其中每条边的权是非负实数。
另外，还给定V中的一个顶点，称为源。
现在要计算从源到所有其他各顶点的最短路长度。
这里路的长度是指路上各边权之和。
这个问题通常称为单源最短路径问题。
分析过程：运用Dijkstra算法来解决单源最短路径问题。
具备贪心选择性质具有最优子结构性质计算复杂性二、算法设计（或算法步骤）用贪心算法解单源最短路径问题：1.算法思想：设置顶点集合S并不断地作贪心选择来扩充这个集合。
一个顶点属于集合S当且仅当从源到该顶点的最短路径长度已知。
初始时，S中仅含有源。
设u是G的某一个顶点，把从源到u且中间只经过S中顶点的路称为从源到u的特殊路径，并用数组dist记录当前每个顶点所对应的最短特殊路径长度。
Dijkstra算法每次从V-S中取出具有最短特殊路长度的顶点u，将u添加到S中，同时对数组dist作必要的修改。
一旦S包含了所有V中顶点，dist就记录了从源到所有其他顶点之间的最短路径长度。
2.算法步骤：(1) 用带权的邻接矩阵c来表示带权有向图, c[i][j]表示弧<vi,vj>上的权值. 若<vi, vj>∉V,则置c[i][j]为∞。
设S为已知最短路径的终点的集合,它的初始状态为空集。
从源点v到图上其余各点vi的当前最短路径长度的初值为：dist[i]=c[v][i] vi∈V。
(2) 选择vj, 使得dist[j]=Min{dist[i] | vi∈V-S}，vj就是长度最短的最短路径的终点。
令S=SU{j}。
的当前最短路径长度:(3) 修改从v到集合V-S上任一顶点vk如果dist[j]+c[j][k]< dist[k] 则修改dist[K]= dist[j]+c[j][k](4) 重复操作(2),(3)共n-1次.三、算法实现#include <iostream>#include <stdlib.h>using namespace std;#define MAX 1000000 //充当"无穷大"#define LEN sizeof(struct V_sub_S)#define N 5#define NULL 0int s; //输入的源点int D[N]; //记录最短路径int S[N]; //最短距离已确定的顶点集const int G[N][N] = { {0, 10, MAX, 30, 100},{MAX, 0, 50, MAX, MAX},{MAX, MAX, 0, MAX, 10},{MAX, MAX, 20, 0, 60},{MAX, MAX, MAX, MAX, 0} };typedef struct V_sub_S //V-S链表{int num;struct V_sub_S *next;};struct V_sub_S *create(){struct V_sub_S *head, *p1, *p2;int n = 0;head = NULL;p1 = (V_sub_S *)malloc(LEN);p1->num = s;head = p1;for(int i = 0; i < N+1; i ++){if(i != s){++ n;if(n == 1)head = p1;elsep2->next = p1;p2 = p1;p1 = (V_sub_S *)malloc(LEN);p1->num = i;p1->next = NULL;}}free(p1);return head;}struct V_sub_S *DelMin(V_sub_S *head, int i) //删除链表中值为i 的结点{V_sub_S *p1, *p2;p1 = head;while(i != p1->num && p1->next !=NULL){p2 = p1;p1 = p1->next;}p2->next = p1->next;return head;}void Dijkstra(V_sub_S *head, int s){struct V_sub_S *p;int min;S[0] = s;for(int i = 0; i < N; i ++){D[i] = G[s][i];}for(i = 1; i < N; i ++){p = head->next;min = p->num;while(p->next != NULL){if(D[p->num] > D[(p->next)->num])min = (p->next)->num;p = p->next;}S[i] = min;head = DelMin(head, min);p = head->next;while(p != NULL){if(D[p->num] > D[min] + G[min][p->num]){D[p->num] = D[min] + G[min][p->num];}p = p->next;}}}void Print(struct V_sub_S *head){struct V_sub_S *p;p = head->next;while(p != NULL){if(D[p->num] != MAX){cout << "D[" << p->num << "]: " << D[p->num] << endl;p = p->next;}else{cout << "D[" << p->num << "]: " << "∞" << endl;p = p->next;}}}int main(){struct V_sub_S *head;cout << "输入源点s (0到4之间): ";cin >> s;head = create();Dijkstra(head, s);head = create();Print(head);system("pause");return 0;}运行结果：四、算法分析（与改进）对于具有n个顶点和e条边的带权有向图，如果用带权邻接矩阵表示这个图，那么Dijkstra算法的主循环体需要O(n)时间。
最短路径算法
§distance[j]=distance[u]+G[u][j]; §path[j]=u; §}}}
2、算法的正确性和计算复杂性
(1)贪心选择性质 (2)最优子结构性质 (3)计算复杂性 对于具有n个顶点和e条边的带权有向图，如果用 带权邻接矩阵表示这个图，那么Dijkstra算法的主循 环体需要 O (n)时间。这个循环需要执行n-1次，所以完 O(时间。算法的其余部分所需要时间不 n2 ) 成循环需要 O(n 2 ) 超过 。
7.5所有点对的最短路径问题
§对于一个各边权值均大于0的有n个顶点的带 权有向图G=(V,E)，求所有顶点之间的最短 路径和最短距离。
图的邻接矩阵表示法
1
1 1
3
0 2
9
2
2
8 9 6
V = 2
3
L= 8 0 6
1 ∞ 0
(b )
(a )
复习Dijkstra算法
其基本思想是，设置顶点集合S并不断地作 基本思想是 设置顶点集合S 贪心选择来扩充这个集合 一个顶点属于集合S 来扩充这个集合。 贪心选择来扩充这个集合。一个顶点属于集合S 当且仅当从源到该顶点的最短路径长度已知。 当且仅当从源到该顶点的最短路径长度已知。 初始时， 中仅含有源点。 初始时，S中仅含有源点。设u是G的某一个 顶点，把从源点到u且中间只经过S 顶点，把从源点到u且中间只经过S中顶点的路称 为从源到u的特殊路径，并用数组dist distance记录 为从源到u的特殊路径，并用数组dist 记录 当前每个顶点所对应的最短特殊路径长度。 当前每个顶点所对应的最短特殊路径长度。 Dijkstra算法每次从 算法每次从V Dijkstra算法每次从V-S中取出具有最短特殊路 长度的顶点u 添加到S 长度的顶点u，将u添加到S中，同时对数组 distance作必要的修改。一旦S包含了所有V中 作必要的修改。 dist 作必要的修改 一旦S包含了所有V 顶点，distance就记录了从源到所有其它顶点 顶点，dist 就记录了从源到所有其它顶点 之间的最短路径长度。 之间的最短路径长度。
单源最短路径dijkstra算法c语言
单源最短路径dijkstra算法c语言单源最短路径问题是图论中的经典问题之一，指的是在图中给定一个起始节点，求出该节点到其余所有节点之间的最短路径的算法。
其中，Dijkstra 算法是一种常用且高效的解决方案，可以在有向图或无向图中找到起始节点到其余所有节点的最短路径。
本文将逐步介绍Dijkstra算法的思想、原理以及C语言实现。
一、Dijkstra算法的思想和原理Dijkstra算法的思想基于贪心算法，通过逐步扩展当前已知路径长度最短的节点来逐步构建最短路径。
算法维护一个集合S，初始时集合S只包含起始节点。
然后，选择起始节点到集合S之外的节点的路径中长度最小的节点加入到集合S中，并更新其他节点的路径长度。
具体来说，算法分为以下几个步骤：1. 初始化：设置起始节点的路径长度为0，其他节点的路径长度为无穷大。
2. 选择最小节点：从集合S之外的节点中选择当前路径长度最短的节点加入到集合S中。
3. 更新路径长度：对于新加入的节点，更新与其相邻节点的路径长度（即加入新节点后的路径长度可能更小）。
4. 重复步骤2和3，直到集合S包含所有节点。
二、Dijkstra算法的C语言实现下面我们将逐步讲解如何用C语言实现Dijkstra算法。
1. 数据结构准备首先，我们需要准备一些数据结构来表示图。
我们可以使用邻接矩阵或邻接表来表示图。
这里，我们选择使用邻接矩阵的方式来表示权重。
我们需要定义一个二维数组来表示图的边权重，以及一个一维数组来表示起始节点到各个节点的路径长度。
c#define MAX_NODES 100int graph[MAX_NODES][MAX_NODES];int dist[MAX_NODES];2. 初始化在使用Dijkstra算法之前，我们需要对数据进行初始化，包括路径长度、边权重等信息。
cvoid initialize(int start_node, int num_nodes) {for (int i = 0; i < num_nodes; i++) {dist[i] = INT_MAX; 将所有节点的路径长度初始化为无穷大}dist[start_node] = 0; 起始节点到自身的路径长度为0初始化边权重for (int i = 0; i < num_nodes; i++) {for (int j = 0; j < num_nodes; j++) {if (i == j) {graph[i][j] = 0; 自身到自身的边权重为0} else {graph[i][j] = INT_MAX; 其他边权重初始化为无穷大}}}}3. 主要算法接下来是Dijkstra算法的主要逻辑。
dijkstra最短路径算法详解
dijkstra最短路径算法详解
Dijkstra最短路径算法是一种常用的图算法，用于求解带权图中的单源最短路径问题，即从一个固定的源节点到图中的其他节点的最
短路径。
以下是详细的算法步骤：
1. 初始化
一开始，将源节点的距离设为0，其余节点的距离设置为正无穷，在未访问的节点集合中把源节点压入堆中。
2. 确定最短路径
从堆中取出未访问节点集合中距离源节点最近的节点v，标记其
为已访问。
之后，对于v的邻居节点w，计算从源节点到v再到w的距离，如果经过v的路径比已经计算得到的路径短，则更新路径。
更新
后的距离先暂时放入堆中，如果后边有更短的路径，则更新。
3. 重复第2步
重复第2步，直到取出的节点为终点节点，或者堆为空。
4. 算法结束
算法结束后，各节点的距离就是从源节点到它们的最短距离。
Dijkstra算法的复杂度是O(NlogN)，其中N是节点个数。
其优
势在于只需要算一次即可得到所有最短路径，但是要求所有边的权值
必须非负，否则会导致算法不准确。
总之，Dijkstra算法是一种简单有效的最短路径算法，其实现也比较直观。
在处理如飞机和火车等交通路径规划问题中有较好的应用。