最短路径-Dijkstra算法(Java实现)

最新推荐文章于 2024-08-27 00:15:00 发布
最新推荐文章于 2024-08-27 00:15:00 发布
阅读量2.2k 收藏 16
点赞数 6
文章标签： 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43269370/article/details/103394947
版权
算法应用
  • 指定一个起点，得到该起点到图的其他所有节点的最短路径
核心思想
  • Dijkstra算法是一种动态规划算法，核心思想是找出指定起点到某个节点的最短路径，就要先找出到达该节点的前一个节点的最短路径
  • 执行过程要记录指定起点到其余节点最短路径的路径权值以及当前最短路径终点的前驱节点，并可能随时更新
算法思路
  1. 从指定起点开始，找出所有邻接节点，更新起点到邻接节点路径权值和记录的前驱节点，从中选出路径权值最小的一个节点，作为下一轮的起点
  2. 从次轮起点开始，重复第一轮的操作
  3. 每一轮更新记录的路径权值，是把 “记录得原始起点到该目标节点的路径总权值” 与 “记录中原始起点到本轮起点的路径权值 + 本轮起点到邻接节点的权值” 比较，保留小的
  4. 更新了权值的同时要记得更新路径终点的前驱节点
  5. 每一轮都将此轮的起点设置为已访问，并且寻找邻接节点时也要跳过那些已访问的
  6. 所有节点都"已访问"时结束
注意
  • 一个节点一旦被指定为下一轮的起点，也就是"已访问"，则该节点的最短路径以及前驱节点已经找到
  • 每一轮选出的下一轮的起点, 不可能再找出另外的路径使得起点到达选出的点的路径权值更小，比如从A到D权值3, 假定D节点就是A到所有节点中路径最短的，假如A能通过另外的节点到达D并且路径更短，比如A-1-E-1-D权值为2, 则这一轮取出的节点将是E而不是D
算法实现
图的实现
  • 此实现方法没有节点类
  • 采用邻接矩阵，并用顶点索引代表顶点
  • 邻接矩阵int[][] matrix
    • matrix[i][j]表示从索引i的节点指向索引j的节点的权值
    • 权值为0表示两点不连接或者自身与自身不连接
  • 使用枚举来定义节点的状态enum Status { UNDISCOVERD, VISITED }
  • 枚举数组Status[] statuses记录每个节点的状态
enum Status {  // 节点对象的状态
    // 未被发现, 已被遍历
    UNDISCOVERD, VISITED
}
public class Graph<T> {
    private int N; // N个节点
    public int[][] matrix;  // 邻接矩阵
    private Status[] statuses;  // 保存每个节点的状态
    private T[] datas;  // 保存每个节点的数据
}
具体过程
  • 算法主体方法void DijkstraPath(int index)，index就是指定原始起点
  • int[] weights存放指定起点到各个点的路径权值(初始值设定为整型最大值，动态更新)
  • int[] prevs记录指定起点到每个节点的最短路径中, 终点节点的前驱节点(将起点的前驱索引设置为负数，表示没有前驱)
  • int from每一轮指定的起点索引(循环的辅助索引)，初始化为原始起点索引
        // 数组存放该点到各个点的路径权值
        int[] weights = new int[N];
        // 将每个默认权值设置为整型最大值
        for (int i = 0; i < N; i++) {
            weights[i] = Integer.MAX_VALUE;
        }
        // 数组记录指定节点到每个节点的最短路径中, 终点节点的前驱节点
        // 动态规划: 找到到达某个节点的最短路径, 先找到到达他的上一个节点的最短路径
        int[] prevs = new int[N];
        prevs[index] = -1;  // 负数表示该点没有前驱
        // 循环所用的辅助索引
        int from = index;
  • 补充三个方法
    1. boolean isAllVisited()判断是否所有节点都是"已访问"，检查所有节点的状态，只要有一个是未被访问UNDISCOVERD，就返回false
    2. int indexOfMin(int[] nums)找出给定数组中最小值的索引，过滤掉已访问的节点，把未访问的节点索引加入集合List<Integer> remain，remain.add(i)用于每轮循环结束前，找出未被访问且在weights中记录的路径权值最小的节点的索引
    3. List<Integer> allPrevs(int[] prevs, int index)从记录所有节点的前驱索引的数组prevs找出原始节点到指定索引index的节点的最短路径上除了原始起点和终点外的所有中间节点，并记录在栈Stack<Integer> prevStack中，最后依次弹出存到List<Integer> result中，用于最后输出查看结果
      用prev作为辅助变量，逐层往上寻找前驱，只要当前节点前驱索引不是-1 while (prevs[prev] != -1)也就是当前节点不是原始起点(上面已经把原始起点的前驱索引设置为-1)，就把当前节点加入栈prevStack.add(prev)，最后只要栈不空!prevStack.isEmpty()，就弹出栈顶加入集合result.add(prevStack.pop())
    /**
     * 检查是否全部被遍历(只要有一个是未被遍历返回false)
     *
     * @return boolean
     */
    private boolean isAllVisited() {
        for (Status status : statuses) {
            if (status == Status.UNDISCOVERD) {
                return false;
            }
        }
        return true;
    }

    /**
     * 找到数组中最小的值的索引
     *
     * @return int
     */
    private int indexOfMin(int[] nums) {
        // 记录剩余的未访问的节点
        List<Integer> remain = new ArrayList<>();
        for (int i = 0; i < N; i++) {
            if (statuses[i] == Status.UNDISCOVERD) {
                remain.add(i);
            }
        }
        if (remain.size() == 0) {
            return 0;  // 这里返回什么都行, 因为所有节点会在下一循环全部设置为已访问, 从而循环内无任何操作
        }
        int minIndex = remain.get(0);
        for (int j : remain) {
            if (nums[j] < nums[minIndex]) {
                minIndex = j;
            }
        }
        return minIndex;
    }

    /**
     * 指定节点, 按路径顺序返回该节点的所有前驱节点
     *
     * @param prevs 记录前驱节点的数组
     * @param index 指定节点
     * @return java.util.List<java.lang.Integer>
     */
    private List<Integer> allPrevs(int[] prevs, int index) {
        // 记录指定节点到达指定起点的最短路径沿途的节点
        Stack<Integer> prevStack = new Stack<>();
        int prev = prevs[index];
        // 前面设置的算法最开始指定的起点的前驱索引为-1在这里起作用
        // 只要前驱的前驱索引不为最开始指定的起点
        while (prevs[prev] != -1) {
            // 把前驱索引加入栈
            prevStack.add(prev);
            // 下次循环要检查此次循环前驱节点的前驱节点, 所以更新变量
            prev = prevs[prev];
        }

        // 方便遍历, 倒序输出
        List<Integer> result = new ArrayList<>();
        while (!prevStack.isEmpty()) {
            result.add(prevStack.pop());
        }
        return result;
    }
  • 只要不是所有节点都是"已访问"while (!isAllVisited())，则循环执行
    1. 将每一轮的起点设置为"已访问"VISITED
    2. 查看邻接矩阵中与指定节点邻接的节点
      1. int newWeight表示可能的新路径权值: 从最开始的指定起点到本轮起点到该节点的路径权值总和
        由于最开始weights数组所有值初始化为整型最大值，所以判断if (weights[from] == Integer.MAX_VALUE)该本轮起点在weights中记录的权值是不是整型最大值，是就说明这个节点第一次被查找(这种情况只在第一轮循环中会出现)，newWeight = matrix[from][i]则可能的新权值直接设置为起点到该邻接节点的边权值，否则设置为newWeight = weights[from] + matrix[from][i]"原始起点到本轮起点的路径权值 + 本轮起点到该邻接节点的边权值"，
      2. if (statuses[i] == Status.UNDISCOVERD && matrix[from][i] > 0 && newWeight < weights[i])如果该节点未被访问，且是邻接节点，并且如果newWeight小于weights中记录的原始起点到该节点的路径权值，则更新该节点的最小路径值, 更新该节点的前驱为本轮起点weights[i] = newWeight，prevs[i] = from
      3. from = indexOfMin(weights)设定下一轮的起点为未被访问且是weights数组中记录的路径权值中最小的一个节点
        // 循环所用的辅助索引
        int from = index;
        // 只要不是全部被遍历
        while (!isAllVisited()) {
            // 将这个节点设置为已访问
            statuses[from] = Status.VISITED;
            // 查看邻接矩阵中与指定节点邻接的节点
            for (int i = 0; i < N; i++) {
                // 可能的新路径权值: 从最开始的指定起点到本轮起点到该节点的路径权值总和
                int newWeight;
                if (weights[from] == Integer.MAX_VALUE) {
                    newWeight = matrix[from][i];
                } else {
                    newWeight = weights[from] + matrix[from][i];
                }
                // 如果节点未访问, 且是邻接节点
                if (statuses[i] == Status.UNDISCOVERD && matrix[from][i] > 0
                        // 并且如果小于weights中记录的该节点原来的路径权值
                        && newWeight < weights[i]) {
                    // 则更新该节点的最小路径值, 更新该节点的前驱为本轮起点
                    weights[i] = newWeight;
                    prevs[i] = from;
                }
            }
            // 下轮起点from设置为: weights数组中数值最小的并且未访问的节点
            from = indexOfMin(weights);
        }
  • 整个while循环结束之后，就可以检查输出结果
    • datas[index]是输出起点保存的数据，datas数组是图类的成员变量，保存每个节点储存的数据，比如我用的是每个节点保存一个字母，方便观察
    • 遍历每个节点，得到每个节点与起点的路径上的所有中间节点List<Integer> nodesInPath = allPrevs(prevs, i)，再遍历nodesInPath依次输出边的权值matrix[prevs[j]][j](这里prevs[j]和j可以倒过来，因为用的是无向图)，输出节点数据datas[j]最后在跟上总路径权值weights[i]
        System.out.println("指定起点为:" + datas[index]);
        for (int i = 0; i < N; i++) {
            if (i != index) {  // 除去最开始指定的起点
                List<Integer> nodesInPath = allPrevs(prevs, i);
                System.out.print("起点" + datas[index] + "到" + datas[i] + "点的最短路径是: " + datas[index]);
                for (int j :nodesInPath) {
                    System.out.print("-" + matrix[prevs[j]][j] + "-" + datas[j]);
                }
                System.out.println("-" + matrix[prevs[i]][i] + "-" + datas[i] + ", 路径权值总和为: " + weights[i]);
            }
        }
测试
  • graph7个节点一次保存7个字母"ABCDEFG"
  • 邻接矩阵int[][] matrix所表示的图请看下方图片
  • graph.makeUndirected()是把图变成无向图，也就是使得邻接矩阵沿左对角线对称
  • 查看分别以每个节点为起点时，到其他节点的最短路径的情况，graph.initStatuses()是把所有节点的状态设置为未访问，graph.DijkstraPath(i)就是算法主体的方法
    public static void main(String[] args) {
        Graph<String> graph = new Graph<>(7);
        graph.setDatas(new String[]{"A", "B", "C", "D", "E", "F", "G"});
        int[][] matrix = {
                {0, 7, 3, 2, 2, 0, 0},
                {0, 0, 1, 0, 0, 0, 0},
                {0, 0, 0, 0, 4, 3, 0},
                {0, 0, 0, 0, 1, 10, 2},
                {0, 0, 0, 0, 0, 4, 2},
                {0, 0, 0, 0, 0, 0, 7},
                {0, 0, 0, 0, 0, 0, 0}};
        graph.setMatrix(matrix);
        graph.makeUndirected();
        for (int i = 0; i < 7; i++) {
            graph.initStatuses();
            graph.DijkstraPath(i);
        }
    }

图

  • 输出结果

指定起点为:A
起点A到B点的最短路径是: A-3-C-1-B, 路径权值总和为: 4
起点A到C点的最短路径是: A-3-C, 路径权值总和为: 3
起点A到D点的最短路径是: A-2-D, 路径权值总和为: 2
起点A到E点的最短路径是: A-2-E, 路径权值总和为: 2
起点A到F点的最短路径是: A-2-E-4-F, 路径权值总和为: 6
起点A到G点的最短路径是: A-2-D-2-G, 路径权值总和为: 4

指定起点为:B
起点B到A点的最短路径是: B-1-C-3-A, 路径权值总和为: 4
起点B到C点的最短路径是: B-1-C, 路径权值总和为: 1
起点B到D点的最短路径是: B-1-C-3-A-2-D, 路径权值总和为: 6
起点B到E点的最短路径是: B-1-C-4-E, 路径权值总和为: 5
起点B到F点的最短路径是: B-1-C-3-F, 路径权值总和为: 4
起点B到G点的最短路径是: B-1-C-4-E-2-G, 路径权值总和为: 7

指定起点为:C
起点C到A点的最短路径是: C-3-A, 路径权值总和为: 3
起点C到B点的最短路径是: C-1-B, 路径权值总和为: 1
起点C到D点的最短路径是: C-3-A-2-D, 路径权值总和为: 5
起点C到E点的最短路径是: C-4-E, 路径权值总和为: 4
起点C到F点的最短路径是: C-3-F, 路径权值总和为: 3
起点C到G点的最短路径是: C-4-E-2-G, 路径权值总和为: 6

指定起点为:D
起点D到A点的最短路径是: D-2-A, 路径权值总和为: 2
起点D到B点的最短路径是: D-1-E-4-C-1-B, 路径权值总和为: 6
起点D到C点的最短路径是: D-1-E-4-C, 路径权值总和为: 5
起点D到E点的最短路径是: D-1-E, 路径权值总和为: 1
起点D到F点的最短路径是: D-1-E-4-F, 路径权值总和为: 5
起点D到G点的最短路径是: D-2-G, 路径权值总和为: 2

指定起点为:E
起点E到A点的最短路径是: E-2-A, 路径权值总和为: 2
起点E到B点的最短路径是: E-4-C-1-B, 路径权值总和为: 5
起点E到C点的最短路径是: E-4-C, 路径权值总和为: 4
起点E到D点的最短路径是: E-1-D, 路径权值总和为: 1
起点E到F点的最短路径是: E-4-F, 路径权值总和为: 4
起点E到G点的最短路径是: E-2-G, 路径权值总和为: 2

指定起点为:F
起点F到A点的最短路径是: F-3-C-3-A, 路径权值总和为: 6
起点F到B点的最短路径是: F-3-C-1-B, 路径权值总和为: 4
起点F到C点的最短路径是: F-3-C, 路径权值总和为: 3
起点F到D点的最短路径是: F-4-E-1-D, 路径权值总和为: 5
起点F到E点的最短路径是: F-4-E, 路径权值总和为: 4
起点F到G点的最短路径是: F-4-E-2-G, 路径权值总和为: 6

指定起点为:G
起点G到A点的最短路径是: G-2-D-2-A, 路径权值总和为: 4
起点G到B点的最短路径是: G-2-E-4-C-1-B, 路径权值总和为: 7
起点G到C点的最短路径是: G-2-E-4-C, 路径权值总和为: 6
起点G到D点的最短路径是: G-2-D, 路径权值总和为: 2
起点G到E点的最短路径是: G-2-E, 路径权值总和为: 2
起点G到F点的最短路径是: G-2-E-4-F, 路径权值总和为: 6

完整代码
enum Status {  // 节点对象的状态
    // 未被发现, 已被遍历
    UNDISCOVERD, VISITED
}
public class Graph<T> {
    private int N; // N个节点
    public int[][] matrix;  // 邻接矩阵
    private Status[] statuses;  // 保存每个节点的状态
    private T[] datas;  // 保存每个节点的数据
    public Graph(int N) {
        this.N = N;
        matrix = new int[N][N];
        statuses = new Status[N];
        datas = (T[]) new Object[N];  // 泛型数组实例化
        initStatuses();
    }

    /**
     * 用传进来的矩阵初始化图的邻接矩阵
     *
     * @param matrix 传进来用于初始化邻接矩阵的矩阵
     * @return void
     */
    public void setMatrix(int[][] matrix) {
        this.matrix = matrix;
    }

    /**
     * 使图变成无向图(把邻接矩阵镜像化)
     *
     * @return void
     */
    public void makeUndirected() {
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                if (matrix[i][j] > 0 && matrix[i][j] != matrix[j][i]) {
                    matrix[j][i] = matrix[i][j];
                }
            }
        }
    }

    public void setDatas(T[] datas) {
        this.datas = datas;
    }

    /**
     * 初始化状态数组
     *
     * @return void
     */
    public void initStatuses() {
        for (int i = 0; i < N; i++) {
            statuses[i] = Status.UNDISCOVERD;
        }
    }

    /**
     * 邻接矩阵保存的信息是从一个节点指向另一个节点的信息
     *
     * @param from   从这个节点
     * @param to     指向这个节点
     * @param weight 路径权重
     * @return void
     */
    public void setMatrix(int from, int to, int weight) {
        matrix[from][to] = weight;
    }

    /**
     * 最短路径-迪杰斯特拉算法(找出某个点到其他所有点的最短路径)
     *
     * @param index 指定某个点
     * @return void
     */
    public void DijkstraPath(int index) {
        // 每一轮选出的路径权值最小的节点, 则不可能再找出另外的路径权值更小
        // 比如从A到D是2, 则这一轮取出D节点, 假如有A能通过另外的节点到达D并且更短,
        // 比如A-1-E-1-D, 则上一轮取出的节点将是E而不是D
        // 数组存放该点到各个点的路径权值
        int[] weights = new int[N];
        // 将每个默认权值设置为整型最大值
        for (int i = 0; i < N; i++) {
            weights[i] = Integer.MAX_VALUE;
        }
        // 数组记录指定节点到每个节点的最短路径中, 终点节点的前驱节点
        // 动态规划: 找到到达某个节点的最短路径, 先找到到达他的上一个节点的最短路径
        int[] prevs = new int[N];
        prevs[index] = -1;  // 负数表示该点没有前驱
        // 循环所用的辅助索引
        int from = index;
        // 只要不是全部被遍历
        while (!isAllVisited()) {
            // 将这个节点设置为已访问
            statuses[from] = Status.VISITED;
            // 查看邻接矩阵中与指定节点邻接的节点
            for (int i = 0; i < N; i++) {
                // 可能的新路径权值: 从最开始的指定起点到本轮起点到该节点的路径权值总和
                int newWeight;
                if (weights[from] == Integer.MAX_VALUE) {
                    newWeight = matrix[from][i];
                } else {
                    newWeight = weights[from] + matrix[from][i];
                }
                // 如果节点未访问, 且是邻接节点
                if (statuses[i] == Status.UNDISCOVERD && matrix[from][i] > 0
                        // 并且如果小于weights中记录的该节点原来的路径权值
                        && newWeight < weights[i]) {
                    // 则更新该节点的最小路径值, 更新该节点的前驱为本轮起点
                    weights[i] = newWeight;
                    prevs[i] = from;
                }
            }
            // 下轮起点from设置为: weights数组中数值最小的并且未访问的节点
            from = indexOfMin(weights);
        }
        // 输出结果
        System.out.println("指定起点为:" + datas[index]);
        for (int i = 0; i < N; i++) {
            if (i != index) {  // 除去最开始指定的起点
                List<Integer> nodesInPath = allPrevs(prevs, i);
                System.out.print("起点" + datas[index] + "到" + datas[i] + "点的最短路径是: " + datas[index]);
                for (int j :nodesInPath) {
                    System.out.print("-" + matrix[prevs[j]][j] + "-" + datas[j]);
                }
                System.out.println("-" + matrix[prevs[i]][i] + "-" + datas[i] + ", 路径权值总和为: " + weights[i]);
            }
        }
    }

    /**
     * 指定节点, 按路径顺序返回该节点的所有前驱节点
     *
     * @param prevs 记录前驱节点的数组
     * @param index 指定节点
     * @return java.util.List<java.lang.Integer>
     */
    private List<Integer> allPrevs(int[] prevs, int index) {
        // 记录指定节点到达指定起点的最短路径沿途的节点
        Stack<Integer> prevStack = new Stack<>();
        int prev = prevs[index];
        // 前面设置的算法最开始指定的起点的前驱索引为-1在这里起作用
        // 只要前驱的前驱索引不为最开始指定的起点
        while (prevs[prev] != -1) {
            // 把前驱索引加入栈
            prevStack.add(prev);
            // 下次循环要检查此次循环前驱节点的前驱节点, 所以更新变量
            prev = prevs[prev];
        }

        // 方便遍历, 倒序输出
        List<Integer> result = new ArrayList<>();
        while (!prevStack.isEmpty()) {
            result.add(prevStack.pop());
        }
        return result;
    }

    /**
     * 检查是否全部被遍历(只要有一个是未被遍历返回false)
     *
     * @return boolean
     */
    private boolean isAllVisited() {
        for (Status status : statuses) {
            if (status == Status.UNDISCOVERD) {
                return false;
            }
        }
        return true;
    }

    /**
     * 找到数组中最小的值的索引
     *
     * @return int
     */
    private int indexOfMin(int[] nums) {
        List<Integer> remain = new ArrayList<>();
        for (int i = 0; i < N; i++) {
            if (statuses[i] == Status.UNDISCOVERD) {
                remain.add(i);
            }
        }
        if (remain.size() == 0) {
            return 0;  // 这里返回什么都行, 因为所有节点会在下一循环全部设置为已访问, 从而循环内无任何操作
        }
        int minIndex = remain.get(0);
        for (int j : remain) {
            if (nums[j] < nums[minIndex]) {
                minIndex = j;
            }
        }
        return minIndex;
    }

    public static void main(String[] args) {
        Graph<String> graph = new Graph<>(7);
        graph.setDatas(new String[]{"A", "B", "C", "D", "E", "F", "G"});
        int[][] matrix = {
                {0, 7, 3, 2, 2, 0, 0},
                {0, 0, 1, 0, 0, 0, 0},
                {0, 0, 0, 0, 4, 3, 0},
                {0, 0, 0, 0, 1, 10, 2},
                {0, 0, 0, 0, 0, 4, 2},
                {0, 0, 0, 0, 0, 0, 7},
                {0, 0, 0, 0, 0, 0, 0}};
        graph.setMatrix(matrix);
        graph.makeUndirected();
        for (int i = 0; i < 7; i++) {
            graph.initStatuses();
            graph.DijkstraPath(i);
        }
    }
}

希望我写明白了
如果你看完之后，知道如何实现这个算法，我会很开心
觉得我写的还行的话，麻烦给老弟点个赞

这里再不要脸的推一下自己写的另外的算法详解
最小生成树-Prim算法(Java实现)
最小生成树-Kruskal算法(Java实现)

谢谢~

Gogoing_刻苦驴
关注
JAVA实践Dijkstra算法求最短路径距离
薛定谔的猫窝
07-21 2221
前言Dijkstra算法用于求指定顶点到其他顶点的最短距离，时间复杂度O(N^2)，据说可以使用堆优化到O(log N)，然而还不会。 其特点是（对我来说）非常容易求得路径，和对应的距离。 缺陷也是存在的，此算法不能处理负权边。即距离为负时，就挂了。 此文内容同样参考《啊哈，算法》另外个人感觉代码可能有错，还望有心人指点。功能实现输入一个顶点输出路径 输出与路径对应的距离 如果存在不可到达
java实现Dijkstra算法
南 墙
07-22 2万+
1 问题描述 何为Dijkstra算法？ Dijkstra算法功能：给出加权连通图中一个顶点，称之为起点，找出起点到其它所有顶点之间的最短距离。 Dijkstra算法思想：采用贪心法思想，进行n-1次查找（PS:n为加权连通图的顶点总个数，除去起点，则剩下n-1个顶点），第一次进行查找，找出距离起点最近的一个顶点，标记为已遍历；下一次进行查找时，从未被遍历中的顶点寻找距离起点最近的一个顶点， 标记...
【最短路径算法】之 Dijkstra 算法：附Java示例代码
欢迎拜读我的作品，喜欢的领域请给我留言
08-27 1280
卫星导航系统如何在最短的时间内找到从起点到终点的最短路线？这个（和类似的）问题将在本系列关于“最短路径”算法的文章中得到解决。本部分介绍Dijkstra 算法- 以其发明者艾兹格·W·迪科斯彻（Edsger W. Dijkstra）的名字命名。Dijkstra 算法针对图中给定的起始节点，找到到所有其他节点（或到给定的目标节点）的最短距离。2. Dijkstra 算法 – 示例用一个例子来解释Dijkstra 算法是最好的。下图显示了一张虚构的道路地图。带有字母的圆圈代表地点；
最短路径算法之Dijkstra算法(java实现)
weixin_30279751的博客
06-30 413
前言 　　Dijkstra算法是最短路径算法中为人熟知的一种，是单起点全路径算法。该算法被称为是“贪心算法”的成功典范。本文接下来将尝试以最通俗的语言来介绍这个伟大的算法，并赋予java实现代码。 一、知识准备： 　　1、表示图的数据结构 　　用于存储图的数据结构有多种，本算法中笔者使用的是邻接矩阵。 　图的邻接矩阵存储方式是用两个数组来表示图。一个一维数组存储图中顶...
java 最短路径算法
{丸の子}
08-05 340
[code="java"] package org.iaiai.suanfa; import java.util.ArrayList; /** * * * Title: Dijkstra.java * * * E-Mail: 176291935@qq.com * * * QQ: 176291935 * * * Http:...
[Java学习]最短路径计算——Dijkstra算法
Admzy的博客
12-10 2571
系列文章目录 文章目录系列文章目录前言一、朴素Dijstra算法1.算法介绍2.具体题目描述：二、堆优化的Dijstra算法1.算法描述2.具体题目描述：总结 前言 最近在看关于求最短路径的一些算法，因此专门整理一下，以方便后续的复习。 求最短路径的情形主要分为以下两种：（1）单源最短路径；（2）多元汇最短路径。而单源最短路经中包括所有边数的权都是正数的，和边数有负数的这两种。针对不同的问题，可以分别用不同的算法进行求解。 下图表示不同问题所应用的不同算法，以及算法的复杂度： 这篇文章主要介绍一些D
JAVA算法：Dijkstra最短路径算法
梅森上校的博客 业精于勤荒于嬉，形成于思毁于随。
07-07 1250
JAVA算法：Dijkstra最短路径算法 基础知识：迪杰斯特拉算法(Dijkstra)是由荷兰计算机科学家狄克斯特拉于1959 年提出的，因此又叫狄克斯特拉算法。是从一个顶点到其余各顶点的最短路径算法，解决的是有权图中最短路径问题。迪杰斯特拉算法主要特点是以起始点为中心向外层层扩展，直到扩展到终点为止。 问题描述：在有向图 G=(V,E) 中，假设每条边 E[i] 的长度为 w[i]，找到由...
dijkstra最短路径算法视频_最短路径-Dijkstra算法(Java实现)
weixin_39777488的博客
12-31 193
算法应用指定一个起点，得到该起点到图的其他所有节点的最短路径核心思想Dijkstra算法是一种动态规划算法，核心思想是找出指定起点到某个节点的最短路径，就要先找出到达该节点的前一个节点的最短路径执行过程要记录指定起点到其余节点最短路径的路径权值以及当前最短路径终点的前驱节点，并可能随时更新算法思路从指定起点开始，找出所有邻接节点，更新起点到邻接节点路径权值和记录的前驱节点，从中选出路径权值最小的一...
单源最短路径（ Dijkstra算法）JAVA实现
04-11
总的来说，Dijkstra算法是解决单源最短路径问题的基石，Java实现使其能够方便地应用于各种实际场景。通过对`Dijkstra.java`文件的理解和学习，你可以深入掌握这一重要算法，并将其运用到自己的项目中。
最短路径-Dijkstra-欧洲旅行 数据结构实验
06-22
这个实验是基于Dijkstra算法，一种广泛用于寻找图中两点间最短路径的算法。在这个特定的场景下，我们假设有一个覆盖整个欧洲的铁路系统，每个城市被视为图中的一个节点，而铁路连接则作为边。我们的任务是计算出从一...
shortest-path-problem-master_最短路径_dijkstra算法_
10-03
1. **单源最短路径**：Dijkstra算法只适用于寻找从一个特定起点（源节点）到图中所有其他节点的最短路径，而非多源最短路径问题。 2. **非负权边**：Dijkstra算法假设图中的边权值都是非负的，因为如果存在负权边，...
两个城市的最短路径dijkstra算法Java代码
07-04
数据结构java类的dijkstra算法实现两城市最短路径
最短路径算法（Dijkstra算法、Floyd-Warshall算法）
LX的专栏
04-18 936
最短路径算法是解决图论中节点之间最短路径问题的经典算法。以下是两种常见的最短路径算法：Dijkstra算法和Floyd-Warshall算法。
图解最短路径之迪杰斯特拉算法（Java实现）
热门推荐
编码强迫症患者
05-10 3万+
概述 迪杰斯特拉算法是由荷兰计算机科学家狄克斯特拉于1959 年提出的，因此又叫狄克斯特拉算法。是从一个顶点到其余各顶点的最短路径算法，解决的是有权图中最短路径问题。迪杰斯特拉算法主要特点是以起始点为中心向外层层扩展，直到扩展到终点为止。迪杰斯特拉算法采用的是贪心策略，将Graph中的节点集分为最短路径计算完成的节点集S和未计算完成的节点集T，每次将从T中挑选V0->Vt最小的节点Vt加入......
Dijkstra最短路径算法 java实现
qq_35222441的博客
03-08 245
原理就不多介绍了，在韩顺平老师代码的基础上作了一些简化，更易于阅读和理解。附原代码与简化后的代码 原代码 package com.atguigu.dijkstra; import java.util.Arrays; public class DijkstraAlgorithm { public static void main(String[] args) { char[] verte...
【LeetCode】700. 二叉搜索树中的搜索（Java）
小楊同学的笔记本
10-13 129
给定二叉搜索树（BST）的根节点和一个值。 你需要在BST中找到节点值等于给定值的节点。 返回以该节点为根的子树。 如果节点不存在，则返回 NULL。 /** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode(int x) { val = x; } * } */ class
迪杰斯特拉（Dijkstra）算法 Java实现（最短路径）
CmdSmith的博客
02-24 1万+
基本思想 通过Dijkstra计算图G中的最短路径时，需要指定起点vs(即从顶点vs开始计算)。 此外，引进两个集合S和U。S的作用是记录已求出最短路径的顶点，而U则是记录还未求出最短路径的顶点(以及该顶点到起点vs的距离)。 初始时，S中只有起点vs；U中是除vs之外的顶点，并且U中顶点的路径是"起点vs到该顶点的路径"。然后，从U中找出路径最短的
(HW)Dijkstra算法(Java)
anjiao6409的博客
05-18 148
1 import java.util.Comparator; 2 import java.util.HashMap; 3 import java.util.LinkedList; 4 import java.util.List; 5 import java.util.Map; 6 import java.util.PriorityQueue; ...
最短路径问题-Dijkstra算法(Java)
最新发布
09-25
以下是使用Java实现Dijkstra算法的基本步骤： 1. 初始化：创建一个优先队列（通常用`PriorityQueue`），将起点的距离设为0，其余节点距离设为无穷大。同时，标记所有节点为未访问。 2. 主循环：每次从未访问过的...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值