java实现弗洛伊德算法（Floyd）-------参考视频 韩顺平《java数据结构和算法》

如图所示：

完整代码如下：

package com.wqc.floyd;

import java.util.Arrays;

/**
 * @author 高瞻远瞩
 * @version 1.0
 * @motto 算法并不可怕, 可怕的是你不敢面对它, 加油！别浮躁~冲击大厂！！！
 * 弗洛伊德算法--》最短路径（各个顶点到其他顶点的最短路径）
 */
public class FloydAlgorithm {
    public static void main(String[] args) {
        char[] vertexes = {'A', 'B', 'C', 'D', 'E', 'F', 'G'};
        int[][] matrix = new int[vertexes.length][vertexes.length];
        final int N = 65535;
        matrix[0] = new int[]{0, 5, 7, N, N, N, 2};
        matrix[1] = new int[]{5, 0, N, 9, N, N, 3};
        matrix[2] = new int[]{7, N, 0, N, 8, N, N};
        matrix[3] = new int[]{N, 9, N, 0, N, 4, N};
        matrix[4] = new int[]{N, N, 8, N, 0, 5, 4};
        matrix[5] = new int[]{N, N, N, 4, 5, 0, 6};
        matrix[6] = new int[]{2, 3, N, N, 4, 6, 0};
        Graph graph = new Graph(vertexes.length, matrix, vertexes);
        graph.floyd();
        graph.show();
    }
}

class Graph {
    private int[][] pre;//记录前驱结点 初始化矩阵的每一行都为自己的索引的值 动态生成的
    private int[][] dis;//记录各个顶点到其他顶点的最短距离 初始化为邻接矩阵 动态生成的
    private char[] vertexes;//顶点数组

    public Graph(int len, int[][] matrix, char[] vertexes) {
        this.dis = matrix;
        this.vertexes = vertexes;
        pre = new int[len][len];
        //初始化前驱结点数组
        for (int i = 0; i < len; i++) {
            Arrays.fill(pre[i], i);
        }
    }

    //弗洛伊德算法
    public void floyd(){
        for (int i = 0; i < dis.length; i++) {//作为中间顶点  {'A', 'B', 'C', 'D', 'E', 'F', 'G'}
            for (int j = 0; j < dis.length; j++) {//作为起始顶点 {'A', 'B', 'C', 'D', 'E', 'F', 'G'}
                for (int k = 0; k < dis.length; k++) { //作为终点 {'A', 'B', 'C', 'D', 'E', 'F', 'G'}
                    int len = dis[j][i] + dis[i][k];//起始顶点到中间顶点的距离 + 中间顶点到终点的距离
                    if(len < dis[j][k]){ //如果这个距离 < 起始顶点到终点的距离 就更改
                        dis[j][k] = len;//更新最短距离
                        pre[j][k] = pre[j][i];//更新出发顶点的后继结点  终点的前驱结点
                    }
                }
                //A-A-A A-A-B A-A-C A-A-D A-A-E A-A-G
                //B-A-A B-A-B B-A-C B-A-D B-A-E B-A-G
                //...
                //G-A-A G-A-B G-A-C G-A-D G-A-E G-A-G
            }
            //当上面两层for循环结束  就更新了所有以A为中间顶点的所有线段的最短距离
            //然后进行下一次for循环  就开始所有以B为中间结点更新他们的最短距离
        }
    }

    //打印pre数组和dis数组
    public void show() {
        for (int i = 0; i < dis.length; i++) {
            //打印pre数组
            for (int j = 0; j < dis.length; j++) {
                System.out.print(vertexes[pre[i][j]] + " ");
            }
            System.out.println();
            //打印dis数组
            for (int j = 0; j < dis.length; j++) {
                System.out.print("顶点" + vertexes[i] + "到顶点" + vertexes[j] + "的最短距离=" + dis[i][j] + " ");
            }
            System.out.println();
        }
    }
}