Dijkstra单源最短路径算法（广度优先）

问题：找出顶点C到其他各个顶点的最短路径及具体线路？

思路图解：

工具：
1、需要matrix[][] 二维数组存储构建的二维矩阵，不可达用N（65535）表示；
2、需要already_visit[] 数组来标识已经访问过及未访问的顶点；
3、需要dis[] 存储出发顶点C到其他各个顶点间的最短距离，不可达用N（65535）表示
4、需要pre_visit[] 存储遍历时候访问的每个顶点的前驱顶点，以便于后面将顶点C到其他顶点的完整路径进行打印；

代码：

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/**
 * Dijkstra单源最短路径算法（广度优先遍历方式）
 * @author gufusheng
 * @time 2021/11/11 11:11
 */
public class DijkstraTest {

    public static void main(String[] args) {
        char[] vertex = { 'A', 'B', 'C', 'D', 'E', 'F', 'G' };
        //邻接矩阵
        int[][] matrix = new int[vertex.length][vertex.length];
        final int N = 65535;// 表示不可以连接
        matrix[0]=new int[]{N,5,7,N,N,N,2};
        matrix[1]=new int[]{5,N,N,9,N,N,3};
        matrix[2]=new int[]{7,N,N,N,8,N,N};
        matrix[3]=new int[]{N,9,N,N,N,4,N};
        matrix[4]=new int[]{N,N,8,N,N,5,4};
        matrix[5]=new int[]{N,N,N,4,5,N,6};
        matrix[6]=new int[]{2,3,N,N,4,6,N};
        Graph graph = new Graph(matrix, vertex);  // 初始化顶点数组、邻接矩阵、未访问顶点数组、开始顶点到其他各个顶点的最短距离数组
        graph.dsj(2); //起始顶点下标
        graph.show(2);
    }


}
class Graph {
    int N = 65535;
    public char [] v; // 顶点数组
    public int [] already_visit; // 已经访问过的顶点，访问过为1，未访问为0
    public int [] pre_visit; // 前一个顶点下标（用于最后打印最短路径使用）
    public int [][] matrix; // 邻接矩阵
    public int [] dis; // 访问顶点到所有顶点的最小路径值

    public Graph(int [][] matrix, char [] v){
        this.v = v;
        this.matrix = matrix;
        already_visit = new int[v.length];
        Arrays.fill(already_visit, 0);
        dis = new int[v.length];
        Arrays.fill(dis, N);
        pre_visit = new int[v.length];
        Arrays.fill(pre_visit, 0);
    }

    public void dsj(int index) { // 访问的顶点下标
        // 更新第一个顶点
        // 设置出发顶点距离为0
        dis[index] = 0;
        update(index);
        pre_visit[index] = index;

        for (int i = 0; i < v.length; i++) {
            // 查找下一个需要遍历的 （与出发顶点路径最短） 且 （未访问过的顶点）
            index = nextIndex();
            // 更新顶点到出发点的最短距离
            update(index);
        }

    }

    // 查找下一个要遍历的邻接点
    public int nextIndex() {
        int min = N;
        int index = 0;
        for (int j = 0; j < already_visit.length; j++) {
            if (already_visit[j] == 0 && dis[j] < min) {
                min = dis[j];
                index = j;
            }
        }
        already_visit[index] = 1;
        return index;
    }

    public void update(int index) {
        already_visit[index] = 1;
        int len = 0;
        for (int i = 0; i < matrix[index].length; i++) {
            if (matrix[index][i] < N && already_visit[i] == 0) {
                len = dis[index] + matrix[index][i];
                 // （当前遍历顶点 至 其邻接顶点的路径）与 （当前遍历顶点 至 起始点的路径）之和
                 //  如果小于 （该邻接点 至 出发顶点的路径）
                 //  则 （将该和路径作为该邻接顶点到出发点的最短路径）
                if (len < dis[i]) {
                    dis[i] = dis[index] + matrix[index][i];
                    pre_visit[i] = index;
                }
            }
        }
    }

    public void show(int index) {
        for (int i = 0; i < v.length; i++) {
            System.out.print(v[i] + "(" + dis[i] + ")" + " ");
        }
        System.out.println('\n' + "==========================");

        // 打印出发点到各个顶点的最短路径
        for (int i = 0; i < v.length; i++) {
            System.out.println("(" + v[index] + "," + v[i] + ")");

            List<Character> str = new ArrayList<>();
            str.add(v[i]);
            int flag = pre_visit[i];
            str.add(v[flag]);
            while(index != flag) {
                flag = pre_visit[flag];
                str.add(v[flag]);
            }
            for (int j = str.size() - 1; j >= 0; j--) {
                if (j!=0)
                    System.out.print(str.get(j) + "->");
                else
                    System.out.println(str.get(j));
            }
        }
    }
}

输出：

A(7) B(12) C(0) D(17) E(8) F(13) G(9)
==========================
(C,A)
C->A
(C,B)
C->A->B
(C,C)
C->C
(C,D)
C->E->F->D
(C,E)
C->E
(C,F)
C->E->F
(C,G)
C->A->G