Dijkstra 算法 Java实现

最新推荐文章于 2024-08-27 00:15:00 发布
最新推荐文章于 2024-08-27 00:15:00 发布
阅读量849 收藏 1
点赞数 1
分类专栏： java-算法 文章标签： 算法 java dijkstra 算法导论
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Em_dark/article/details/56670726
版权

最近看文章看到Dijkstra 算法,想起大学的时候学习的算法导论这门课程

突然就想用java来实现下这个算法了,

以下就来介绍一下这个算法吧.

Dijkstra 算法主要是用来解决有向图单个点到其他点的最短路径的问题

然后我根据这个有向图来编写了Dijkstra 算法

这里写图片描述

public static void main(String[] args) {
        //定义一个有向图
        //定义一个集合,所有点的集合
        List<String> DOT=new ArrayList<>();
        DOT.add("A");
        DOT.add("B");
        DOT.add("C");
        DOT.add("D");
        DOT.add("E");
        DOT.add("F");
        DOT.add("G");
        //定义一个集合,所有边到边的距离
        Map<String,Integer> EGED=new HashMap<>();
        EGED.put("AB",8);
        EGED.put("AE",4);
        EGED.put("AF",2);
        EGED.put("BA",8);
        EGED.put("BE",7);
        EGED.put("BC",6);
        EGED.put("CB",6);
        EGED.put("CD",6);
        EGED.put("DC",6);
        EGED.put("DE",9);
        EGED.put("DG",7);
        EGED.put("EA",4);
        EGED.put("EB",7);
        EGED.put("ED",9);
        EGED.put("EG",11);
        EGED.put("EF",3);
        EGED.put("FA",2);
        EGED.put("FE",3);
        EGED.put("FG",5);
        EGED.put("GE",11);
        EGED.put("GF",5);
        EGED.put("GD",7);
        //创建一个被选中的点的集合
        LinkedList<String> choose=new LinkedList<>();
        String Next=loop("A",DOT,choose,EGED);
        String Next1=loop(Next,DOT,choose,EGED);
        String Next2=loop(Next1,DOT,choose,EGED);
        String Next3=loop(Next2,DOT,choose,EGED);
        String Next4=loop(Next3,DOT,choose,EGED);
        String Next5=loop(Next4,DOT,choose,EGED);
        System.out.println("A"+"---"+Next+"---"+Next1+"---"+Next2+"---"+Next3+"---"+Next4+"---"+Next5);
    }

    public static String loop(String startPot,List DOT,List choose,Map<String,Integer> EGED){
        //把起始点放入,这里我们选择A
        choose.add(startPot);
        DOT.remove(startPot);
        //在边的集合中找到A开始的边
        System.out.println(EGED.entrySet());
        Map<String,Integer> map=new HashMap<>();
        for (String s:EGED.keySet()) {
            String TheKey=findroad(s,startPot+"\\w");
            if (!("").equals(TheKey))
            {
                if (map.isEmpty())
                {
                    map.put(TheKey,EGED.get(TheKey));
                }else{

                    if (map.values().iterator().next()>EGED.get(TheKey)){
                        map.clear();
                        map.put(TheKey,EGED.get(TheKey));
                    }
                }
            }
        }
        String Next="";
        System.out.println(map.entrySet());
        for (String s:map.keySet()) {
            Next=s.substring(1);
        }
        System.out.println(Next);
        //找到最短路径之后就把所有和这个点相关的路径删除
        List a=new ArrayList<>();
        for (String sD:EGED.keySet()) {
            String TheKey=findroad(sD,"\\w*"+startPot+"\\w*");
            if (!("").equals(TheKey))
            {
                a.add(TheKey);
            }
        }
        for (int i = 0; i < a.size(); i++) {
            EGED.remove(a.get(i));
        }
        System.out.println(EGED.entrySet());
        return Next;
    }
    public static String findroad(String bian,String regEx){
        Pattern pattern=Pattern.compile(regEx);
        Matcher matcher=pattern.matcher(bian);
        if (matcher.find())
        {
            return bian;
        }else{
            return "";
        }
    }

以上是代码
以下是运行输出

[GD=7, FA=2, GE=11, GF=5, EA=4, FE=3, EB=7, ED=9, DC=6, CB=6, BA=8, AB=8, BC=6, AE=4, AF=2, BE=7, CD=6, DE=9, EG=11, EF=3, DG=7, FG=5]
[AF=2]
F
[GD=7, GE=11, GF=5, FE=3, EB=7, ED=9, DC=6, CB=6, BC=6, BE=7, CD=6, DE=9, EG=11, EF=3, DG=7, FG=5]
[GD=7, GE=11, GF=5, FE=3, EB=7, ED=9, DC=6, CB=6, BC=6, BE=7, CD=6, DE=9, EG=11, EF=3, DG=7, FG=5]
[FE=3]
E
[GD=7, GE=11, EB=7, ED=9, DC=6, CB=6, BC=6, BE=7, CD=6, DE=9, EG=11, DG=7]
[GD=7, GE=11, EB=7, ED=9, DC=6, CB=6, BC=6, BE=7, CD=6, DE=9, EG=11, DG=7]
[EB=7]
B
[GD=7, DC=6, CB=6, BC=6, CD=6, DG=7]
[GD=7, DC=6, CB=6, BC=6, CD=6, DG=7]
[BC=6]
C
[GD=7, DC=6, CD=6, DG=7]
[GD=7, DC=6, CD=6, DG=7]
[CD=6]
D
[GD=7, DG=7]
[GD=7, DG=7]
[DG=7]
G
[]
A---F---E---B---C---D---G

这是初版吧…没时间了..有时间在update一下,

其实dijkstra 算法的核心就是,在一堆有向图中,找一个起始点,然后查看和该点的连接中,最小的那个点,当作下一个起始点, 在本例中,A是出发点,第一次调用该循环的时候,AF-2是最小的,数值是2,所以F点是第二遍的起始点,但是我们已经用过了A,所以在下次循环里面的与A点相关的点我们都给删除掉,在进行循环,当边的那个集合为空时就给退出循环,路径也就找出来了.
当然,本文是最基础的实现,很多东西没考虑好,比如,很多个点怎么办,大量数据的时候怎么办,这么多循环的效率肯定非常低,
欢迎大家给建议,来提升该算法的性能,哈哈哈哈.
以上
2017-2-23

Em_dark
关注
专栏目录
java实现Dijkstra算法
南 墙
07-22 2万+
1 问题描述 何为Dijkstra算法？ Dijkstra算法功能：给出加权连通图中一个顶点，称之为起点，找出起点到其它所有顶点之间的最短距离。 Dijkstra算法思想：采用贪心法思想，进行n-1次查找（PS:n为加权连通图的顶点总个数，除去起点，则剩下n-1个顶点），第一次进行查找，找出距离起点最近的一个顶点，标记为已遍历；下一次进行查找时，从未被遍历中的顶点寻找距离起点最近的一个顶点， 标记...
Dijkstra算法Java实现示例
05-02
以下是Java语言实现Dijkstra算法的一个简单示例，这个示例假设你有一个图的邻接矩阵表示，并且所有边的权重都是正数。 代码定义了一个DijkstraExample类，其中包含了Dijkstra算法的实现。dijkstra方法接受一个图的...
【最短路径算法】之 Dijkstra 算法：附Java示例代码
最新发布
欢迎拜读我的作品，喜欢的领域请给我留言
08-27 1128
卫星导航系统如何在最短的时间内找到从起点到终点的最短路线？这个（和类似的）问题将在本系列关于“最短路径”算法的文章中得到解决。本部分介绍Dijkstra 算法- 以其发明者艾兹格·W·迪科斯彻（Edsger W. Dijkstra）的名字命名。Dijkstra 算法针对图中给定的起始节点，找到到所有其他节点（或到给定的目标节点）的最短距离。2. Dijkstra 算法 – 示例用一个例子来解释Dijkstra 算法是最好的。下图显示了一张虚构的道路地图。带有字母的圆圈代表地点；
迪杰斯特拉算法（Java）
weixin_48544279的博客
09-15 4551
迪杰斯特拉（Dijkstra）算法是典型最短路径算法，用于计算一个顶点到其他顶点的最短路径。它的主要特点是以起始点为中心向外层层扩展（广度优先搜索思想），直到扩展到终点为止。算法过程设置出发顶点为v，顶点集合V{ v1， v2,vi …} ，v到V中各顶点的距离构成距离集合Dis，Dis{ d1，d2，di…}，Dis集合记录着b到图中各顶点的距离(到自身距离为0，v 到vi距离对应为di)1）从Dis中选择值最小的di移出Dis集合，同时移出V集合中对应的顶点vi，此时的v到vi即是最短路径。
Dijkstra算法实现（java）
weixin_43698993的博客
02-08 4723
一、Dijkstra算法介绍   Dijkstra（迪杰斯特拉）算法是求解单源最短路径的经典算法，其原理也是基于贪心策略的。 二、Dijkstra算法原理   Dijkstra算法设置一个集合SSS记录已求得的最短路径的顶点，初始时把源点v0v_{0}v0​放入SSS，集合SSS每并入一个新顶点viv_{i}vi​，都要修改源点v0v_{0}v0​到集合V−SV-SV−S中顶点当前的最短路径长度值。   在构造的过程中还设置了两个辅助数组： （1）dist[]：记录从源点v0v_{0}v0​到其他各顶点当
Dijkstra算法的 java 实现
CHOOOU的博客
07-25 586
求无权最短路径，使用广度优先搜索即可。如果是有权图，就要用Dijkstra算法。Dijkstra算法是一种贪婪算法。读者可以结合输出和注释尝试理解。代码import java.util.Arrays;public class Test { //无限大 static int INF = Integer.MAX_VALUE; //dis保存某点到各点的花费，不可到为INF
Dijkstra算法java实现
07-31
在这个Java实现中，我们将深入探讨Dijkstra算法的工作原理、如何用Java代码来实现它，以及该算法在实际问题中的应用。 Dijkstra算法的基本思想是通过贪心策略，每次选择当前未访问节点中距离起点最近的一个，并更新...
JAVA实现Dijkstra算法
qq_40313024的博客
08-24 425
JAVA实现Dijkstra算法 本题以此有向图为例 算法思想： 假设有两个顶点集合S和T,集合S中存放图中已找到最短路径的顶点，集合T中存放图中剩余顶点。初始状态时，集合S中只包含源点V0,然后不断从集合T中选取到顶点V0路径长度最短的顶点Vu并入到集合S中。集合S每并入一个新的顶点Vu，都要修改顶点V0到集合T中顶点的最短路径长度值。不断重复此过程，直到集合T中的顶点全部并入集合S中为止，循环...
迪杰斯特拉算法的Java实现
02-24
迪杰斯特拉算法的Java实现
java实现迪杰斯特拉算法
10-20
java实现迪杰斯特拉算法，学过计算机的应该都知道迪杰斯特拉算法，这里不再赘述。（为了凑资源描述文字啊！）
Dijkstra算法实现（JAVA）
zmingyang的博客
05-12 1534
DIjkstra算法介绍 迪杰斯特拉算法(Dijkstra)是由荷兰计算机科学家狄克斯特拉于1959 年提出的，因此又叫狄克斯特拉算法。是从一个顶点到其余各顶点的最短路径算法，解决的是有权图中最短路径问题。迪杰斯特拉算法主要特点是从起始点开始，采用贪心算法的策略，每次遍历到始点距离最近且未访问过的顶点的邻接节点，直到扩展到终点为止。 DIjkstra算法思想 算法开始选择一个顶点s作为开始节点。d表示各个节点距s的距离，p表示路径。Dijkstra算法按阶段进行，正像无权最短路径算法一样。在每个阶段，Dij
Dijkstra算法（Java实现）
为梦起航
07-23 1296
Dijkstra提出按各顶点与源点v间的路径长度的递增次序，生成到各顶点的最短路径的算法。即先求出长度最短的一条最短路径，再参照它求出长度次短的一条最短路径，依次类推，直到从源点v 到其它各顶点的最短路径全部求出为止。 下面是代码实现： package com.algorithm.impl; public class Dijkstra { private static int M = 10
Java实现之迪杰斯特拉(Dijkstra)算法
qq_64580912的博客
11-27 2090
迪杰斯特拉(Dijkstra)算法是典型最短路径算法，用于计算一个结点到其他结点的最短路径。它的主要特点是以起始点为中心向外层层扩展(广度优先搜索思想)，直到扩展到终点为止。
(HW)Dijkstra算法(Java)
anjiao6409的博客
05-18 138
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实现
It's just a matter of time.
12-09 3960
迪科斯彻(Dijkstra)算法使用了广度优先搜索解决非负权有向图的单源最短路径问题，算法最终得到一个最短路径树。 在一个有向非负权重的图中，可以知道如AC>AB,这AC+CB>AB，这一不等式有点贪心算法的思想，每次选择时都做出贪心选择。在迪科斯彻算法中就是使用了上面的原理进行求解的。具体的介绍可以wiki一下：http://zh.wikipedia.org/wiki/Dijkstra算法.里面已经包含了伪代码。下面是Java版的实现代码，需要注意的是这里没有使用伪代码中的优先队列，而是使用一个布尔类型的
Dijkstra算法的java实现
Maxwell_7
03-28 2949
Dijkstra算法：用于单源最短路径的求解。用于计算给定的一个源节点到其他各个节点之间的最短路径。 该算法的思路是：已选定的节点集为A，待选的节点集为B。开始时节点A中仅包含源节点。 选择B中距离源节点最近的一个点，然后将它加入到节点集A中。该点加入后，更新B中所有节点到A的路径长度（借助刚加入的点）。之后重复这一步骤，直至所有点都加入。 以下图为例，做一个说明：
dijkstra算法java实现
06-22
Dijkstra算法是一种用于寻找图中两点之间最短路径的贪心算法，通常用于解决单源最短路径问题。在Java中实现Dijkstra算法，你可以按照以下步骤进行： 1. 初始化：创建一个优先队列（通常使用`PriorityQueue`或自定义最小堆），存储顶点和它们的距离（初始时距离为无穷大，源节点距离为0）。 2. 创建邻接表或邻接矩阵表示图。 3. 主循环： a. 从队列中取出当前最短距离的节点。 b. 更新与其相邻节点的距离，如果通过当前节点到达更短，更新距离，并标记该节点已访问。 c. 将未访问的邻居节点加入队列。 4. 当队列为空或找到目标节点时，算法结束。此时队列中的最后一个元素即为目标节点，且所有节点的距离值即是最短路径。 以下是简单的Java代码实现： ```java import java.util.*; public class Dijkstra { private final int V; // 图的顶点数 private List<List<Edge>> adj; // 邻接列表 private int[] dist; // 存储每个节点到源的距离 // 边类，包含起点、终点和权重 class Edge implements Comparable<Edge> { int src, dest, weight; public Edge(int src, int dest, int weight) { this.src = src; this.dest = dest; this.weight = weight; } @Override public int compareTo(Edge other) { return Integer.compare(this.weight, other.weight); } } public Dijkstra(int v, List<List<Edge>> adj) { this.V = v; this.adj = adj; dist = new int[V]; Arrays.fill(dist, Integer.MAX_VALUE); dist = 0; } // Dijkstra算法核心部分 public void dijkstra() { PriorityQueue<Edge> pq = new PriorityQueue<>(); pq.add(new Edge(0, 0, 0)); // 元素为 (距离, 节点, 来源) while (!pq.isEmpty()) { Edge curr = pq.poll(); int u = curr.dest; // 当前节点 if (dist[u] < curr.weight) continue; // 已经找到更短路径，跳过 for (Edge e : adj.get(u)) { int v = e.dest, alt = dist[u] + e.weight; if (alt < dist[v]) { dist[v] = alt; pq.removeIf(edge -> edge.src == v); // 如果找到更短路径，移除旧路径 pq.offer(new Edge(v, alt, u)); // 添加新路径 } } } } // 返回源节点到所有其他节点的最短距离 public int[] printDistances() { return dist; } // 示例用法 public static void main(String[] args) { List<List<Edge>> adj = new ArrayList<>(); // 图的邻接列表构建 // 填充邻接列表... Dijkstra dijkstraAlg = new Dijkstra(V, adj); dijkstraAlg.dijkstra(); int[] shortestDist = dijkstraAlg.printDistances(); } } ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值