Dijkstra算法是一种用于解决单源最短路径问题的经典算法，由荷兰计算机科学家Edsger W. Dijkstra于1956年提出。它可以找到从起始节点到所有其他节点的最短路径。
基本介绍
该算法的基本思想是通过逐步扩展节点的方式，逐渐确定从起始节点到其他节点的最短路径。算法维护两个集合：一个是已确定最短路径的节点集合，记为S；另一个是还未确定最短路径的节点集合，记为V-S。
算法步骤：
-
创建一个距离表，用于记录起始节点到各个节点的当前最短距离。起始节点的最短距离初始化为0，其他节点的最短距离初始化为无穷大（或一个很大的数）。
-
选择起始节点作为当前节点，并将其加入已确定最短路径的节点集合S。
-
对于当前节点的所有邻居节点，更新它们的最短距离。具体步骤如下：
- 遍历当前节点的所有邻居节点。
- 对于每个邻居节点，计算从起始节点经过当前节点到达该邻居节点的距离。如果该距离小于该邻居节点当前的最短距离，则更新最短距离。
-
从未确定最短路径的节点集合V-S中选择一个距离最小的节点作为新的当前节点，并将其加入已确定最短路径的节点集合S。
-
重复步骤3和步骤4，直到所有节点都被加入到已确定最短路径的节点集合S中，或者无法找到更短的路径。
-
最终，距离表中记录的即为起始节点到各个节点的最短距离。
Dijkstra算法的关键在于每次选择距离最小的节点作为当前节点，并通过更新邻居节点的最短距离来逐步扩展最短路径。该算法基于贪心策略，每次选择当前最优解，因此可以找到最短路径。
需要注意的是，Dijkstra算法要求图中的边权重非负，且对于有向图和无向图都适用。如果图中存在负权边，可以使用其他算法，如Bellman-Ford算法或SPFA算法来解决最短路径问题。
举例
以D为开头，求D到各个点的最短距离。
第1步：初始化距离，其实指与D直接连接的点的距离。dis[c]代表D到C点的最短距离，因而初始dis[C]=3，dis[E]=4，dis[D]=0，其余为无穷大。设置集合S 用来表示已经找到的最短路径。此时，S={D}。现在得到D到各点距离 {D(0)，C(3)，E（4），F（*），G（*），B（*），A(*)} ，其中*代表未知数也可以说是无穷大，括号里面的数值代表D点到该点的最短距离。
第2步：不考虑集合S中的值，因为dis[C]=3，是当中距离最短的，所以此时更新S，S={D,C} 。接着我们看与C连接的点，分别有B，E，F，已经在集合S中的不看 ，dis[C-B]=10，因而dis[B]=dis[C]+10=13，dis[F]=dis[C]+dis[C-F]=9，dis[E]=dis[C]+dis[C-E]=3+5=8>4 (初始化时的dis[E]=4) 不更新。此时 {D(0)，C(3)，E（4），F（9），G（*），B（13），A(*)}。
第3步：在第2步中，E点的值4最小，更新S={D，C，E} ，此时看与E点直接连接的点，分别有F，G。dis[F]=dis[E]+dis[E-F]=4+2=6（比原来的值小，得到更新 ），dis[G]=dis[E]+dis[E-G]=4+8=12（更新 ）。此时 {D(0)，C(3)，E（4），F（6），G（12），B（13），A(*)} 。
第4步：在第3步中，F点的值6最小，更新S={D，C，E，F} ，此时看与F点直接连接的点，分别有B，A，G。dis[B]=dis[F]+dis[F-B]=6+7=13，dis[A]=dis[F]+dis[F-A]=6+16=22，dis[G]=dis[F]+dis[F-G]=6+9=15>12（不更新 ）。此时 {D(0)，C(3)，E（4），F（6），G（12），B（13），A(22)}.
第5步：在第4步中，G点的值12最小，更新S={D，C，E，F，G} ，此时看与G点直接连接的点，只有A。dis[A]=dis[G]+dis[G-A]=12+14=26>22(不更新 )。 {D(0)，C(3)，E（4），F（6），G（12），B（13），A(22)}.
第6步：在第5步中，B点的值13最小，更新S={D，C，E，F，G，B} ，此时看与B点直接连接的点，只有A。dis[A]=dis[B]+dis[B-A]=13+12=25>22(不更新 )。 {D(0)，C(3)，E（4），F（6），G（12），B（13），A(22)}.
第6步：最后只剩下A值，直接进入集合S={D，C，E，F，G，B，A} ，此时所有的点都已经遍历结束，得到最终结果 {D(0)，C(3)，E（4），F（6），G（12），B（13），A(22)}.
JAVA实现
上述案例的JAVA实现
java
import java.util.Arrays;
public class DijkstraAlgorithm {
private static int minDistance(int[] dist, boolean[] visited) {
int min = Integer.MAX_VALUE;
int minIndex = -1;
for (int i = 0; i < dist.length; i++) {
if (!visited[i] && dist[i] <= min) {
min = dist[i];
minIndex = i;
}
}
return minIndex;
}
private static void dijkstra(int[][] graph, int source) {
int numVertices = graph.length;
int[] dist = new int[numVertices];
boolean[] visited = new boolean[numVertices];
Arrays.fill(dist, Integer.MAX_VALUE);
dist[source] = 0;
for (int count = 0; count < numVertices - 1; count++) {
int u = minDistance(dist, visited);
visited[u] = true;
for (int v = 0; v < numVertices; v++) {
if (!visited[v] && graph[u][v] != 0 && dist[u] != Integer.MAX_VALUE && dist[u] + graph[u][v] < dist[v]) {
dist[v] = dist[u] + graph[u][v];
}
}
}
System.out.println("Shortest distances from vertex " + source + ":");
for (int i = 0; i < numVertices; i++) {
System.out.println("Vertex " + i + ": " + dist[i]);
}
}
public static void main(String[] args) {
int[][] graph = {
{0, 12, 0, 0, 0, 14, 16},
{12, 0, 10, 0, 0, 0, 7},
{0, 10, 0, 3, 5, 0, 6},
{0, 0, 3, 0, 4, 0, 0},
{0, 0, 5, 4, 0, 8, 2},
{14, 0, 0, 0, 8, 0, 9},
{16, 7, 6, 0, 2, 9, 0}
};
int source = 3; // Starting vertex
dijkstra(graph, source);
}
}参考