Java实现深度优先遍历-DFS

最新推荐文章于 2024-02-21 17:55:54 发布
最新推荐文章于 2024-02-21 17:55:54 发布
阅读量716 收藏 2
点赞数
分类专栏： 数据结构与算法 文章标签： 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_37633306/article/details/114808558
版权

Java实现深度优先遍历-DFS

实现功能：使用深度优先遍历算法DFS计算地铁指定起点站和终点站之间的所有路径

1.构造地铁站点数据结构

地铁站点数据结构包含2个属性，1个站点名，1个邻接站点列表

import java.util.LinkedList;
import java.util.List;

public class StationNode {

    private String stationName;  // 站点名称
    private List <StationNode> neighborStationList;  //邻接站点list

    public StationNode(String stationName) {
        this.stationName = stationName;
        this.neighborStationList = new LinkedList<>();
    }

    public String getStationName() {
        return stationName;
    }

    public void setStationName(String stationName) {
        this.stationName = stationName;
    }


    public List<StationNode> getNeighborStationList() {
        return neighborStationList;
    }

    public void setNeighborStationList(List<StationNode> neighborStationList) {
        this.neighborStationList = neighborStationList;
    }

    // 判断node站点是否在邻接站点列表中
    public boolean nodeIsExistInList(StationNode node) {
        for(StationNode stationNode: neighborStationList) {
            if(stationNode.getStationName().equals(node.getStationName()))
                return true;
        }
        return false;
    }
}

2.深度优先遍历核心算法类

输入：所有的地铁站点Map-nodeMap，起点站名称-startStationName，终点站名称-endStationName

输出：起点站到终点站之间的所有路径

初始化 DFSCacul 算法类

  • 所有地铁站点Map-nodeMap

  • 未搜索的站点Map-notSearchMap

  • 已搜索的站点Map-isSearchMap

  • 起点站名称-startStationName

  • 终点站名称-endStationName

  • 遍历路径Map-pathMap

  • 栈结构List-nodeStack

初始化DFS计算
  • 将起点对应的地铁站点对象入栈
  • 调用 DFS 方法进行计算
DFS核心算法部分

伪代码

DFS() {
  if（ 未遍历站点不为空  ）
    if（ 栈结构List不为空 ）
      当前遍历地铁站点，stationNode = nodeStack 出栈元素
      从未遍历站点Map移除该站点，
      将该站点加入已遍历站点Map
      
      获得该站点的邻接站点列表 neighborStationList
      for遍历邻接站点列表
        if（ 邻接站点在未搜索的站点Map中 ）
          遍历路径Map放入，key--邻接站点名key，value--当前遍历地铁站点stationNode
          
          if（ 邻接站点名 == 终点站名 ）
            打印路径
          else 
            邻接站点入栈
      DFS   
 
    else
      从未遍历站点Map中随机取一个站点入栈;
      DFS();
  else
    算法结束;
}

完整代码

import java.util.*;

public class DFSCacul {

    private Map<String, StationNode> nodeMap;  // 初始站点Map
    private Map<String, StationNode> notSearchMap;  // 未搜索站点Map
    private Map<String, StationNode> isSearchMap;  //  已搜索站点Map
    private Map<String, StationNode> pathMap;   // 遍历路径Map
    private LinkedList <StationNode> nodeStack;  // 遍历节点栈
    private String startStationName;  // 开始站点名称
    private String endStationName;  // 终结站点名称

    public DFSCacul(Map<String, StationNode> map, String startStationName, String endStationName) {
        this.nodeMap = map;
        this.notSearchMap = map;
        this.isSearchMap = new HashMap<>();
        this.startStationName = startStationName;
        this.endStationName = endStationName;
        this.pathMap = new HashMap<>();
        this.nodeStack = new LinkedList<>();
    }

    public Map<String, StationNode> getPathMap() {
        return pathMap;
    }

    public void setPathMap(Map<String, StationNode> pathMap) {
        this.pathMap = pathMap;
    }

    //深度优先遍历初始化
    public void cacul() {

        System.out.println();
        System.out.println("遍历开始--");
        System.out.println("notSearchMap--" + notSearchMap.size());
        System.out.println("isSearchMap--" + isSearchMap.size());
        System.out.println();

        StationNode node = nodeMap.get(startStationName);
        nodeStack.addLast(node);
        DFS();

        System.out.println();
        System.out.println("遍历结束--");
        System.out.println("notSearchMap--" + notSearchMap.size());
        System.out.println("isSearchMap--" + isSearchMap.size());
        System.out.println();

    }

    public void DFS() {

        if(notSearchMap.size() != 0) {
            if(nodeStack.size() != 0) {
                StationNode stationNode = nodeStack.removeLast();  // 获取栈顶元素
                String stationName = stationNode.getStationName();
                isSearchMap.put(stationName,stationNode);  // 将站点放入已遍历集合
                notSearchMap.remove(stationName);  // 从站点集合中移除元素

                List<StationNode> neighborStationList = stationNode.getNeighborStationList(); // 获取出栈节点的邻接站点列表
                for(int i = 0; i < neighborStationList.size(); i++) {  // 从该节点的邻接节点列表中选取未被遍历的节点放入栈中
                    StationNode node = neighborStationList.get(i);
                    if(notSearchMap.containsKey(node.getStationName())) {

                        node = nodeMap.get(node.getStationName());
                        this.pathMap.put(node.getStationName(), stationNode);

                        if(node.getStationName().equals(endStationName)) {  // 邻接顶点包括终结节点，打印路径，继续遍历
                            printPath();
                        } else {
                            nodeStack.addLast(node);
                        }
                    }
                }
                DFS();
            } else {
                nodeStack.addLast(getRandStationNode());  // 当前栈为空时，从未被遍历的站点中随机选取元素入栈
                DFS();
            }
        }
    }

    // 从未被遍历的Map中随机获取一个站点
    public StationNode getRandStationNode() {
        StationNode stationNode = null;
        int rand = new Random().nextInt(this.notSearchMap.size());
        int i = 0;
        for(String stationName : this.notSearchMap.keySet()) {
            if(i == rand) {
                System.out.println("随机选取站--" + stationName);
                stationNode = nodeMap.get(stationName);
            }
            i ++;
        }
        return stationNode;
    }


    public void printPath() {

        LinkedList<StationNode> stationList = new LinkedList<>();
        String stationName = endStationName;
        stationList.addLast(nodeMap.get(endStationName));

        while(!stationName.equals(startStationName)) {
            stationList.addFirst(pathMap.get(stationName));
            stationName = pathMap.get(stationName).getStationName();
        }

        System.out.println();
        System.out.println("获得一条遍历路径————");
        for(int i = 0; i < stationList.size(); i++) {
            StationNode stationNode = stationList.get(i);
            System.out.println(stationNode.getStationName());
        }
        System.out.println();
    }
}

3.数据初始化及测试

测试类

import java.util.HashMap;
import java.util.Map;

/**
 * 深度优先遍历计算所有地铁线路
 * 此处使用南京地铁部分线路进行测试
 */

public class DFSMain {

//    line1 = "1号线";
    private static final String line1Station = "迈皋桥站-红山动物园站-南京站-新模范马路站-玄武门站-鼓楼站-" +
            "珠江路站-新街口站-张府园站-三山街站-中华门站-安德门站-天隆寺站-软件大道站-" +
            "花神庙站-南京南站-双龙大道站-河定桥站-胜太路站-百家湖站-小龙湾站-竹山路站-天印大道站-" +
            "龙眠大道站-南医大·江苏经贸学院站-南京交院站-中国药科大学站";

//    line2 = "2号线";
    private static final String line2Station = "油坊桥站-雨润大街站-元通站-奥体东站-兴隆大街站-集庆门大街站-云锦路站-莫愁湖站-"  +
            "汉中门站-上海路站-新街口站-大行宫站-西安门站-明故宫站-苜蓿园站-下马坊站-孝陵卫站-钟灵街站-马群站-金马路站-" +
            "仙鹤门站-学则路站-仙林中心站-羊山公园站-南大仙林校区站-经天路站";

//    line3 = "3号线";
    private static final String line3Station = "林场站-星火路站-东大成贤学院站-泰冯路站-天润城站-柳州东路站-上元门站-五塘广场站-" +
            "小市站-南京站-新庄站-鸡鸣寺站-浮桥站-大行宫站-常府街站-夫子庙站-武定门站-雨花门站-卡子门站-大明路站-明发广场站-南京南站-" +
            "宏运大道站-胜太西路站-天元西路-九龙湖站-诚信大道站-东大九龙湖校区站-秣周东路站";

//    line4 = "4号线";
    private static final String line4Station = "龙江站-草场门站-云南路站-鼓楼站-鸡鸣寺站-九华山站-岗子村站-蒋王庙站-王家湾站-聚宝山站-" +
            "徐庄站-金马路站-汇通路站-灵山站-东流站-孟北站-桦墅站-仙林湖站";

//    line10 = "10号线";
    private static final String line10Station = "雨山路站-文德路站-龙华路站-南京工业大学站-浦口万汇城站-临江.青奥体育公园站-江心洲站-" +
            "绿博园站-梦都大街站-奥体中心站-元通站-中胜站-小行站-安德门站";

    public static void main(String [] args) {
        Map<String, StationNode> map = new HashMap<>();
        InitData.initStation(map,line1Station);
        InitData.initStation(map,line2Station);
        InitData.initStation(map,line3Station);
        InitData.initStation(map,line4Station);
        InitData.initStation(map,line10Station);

        DFSCacul cacuPath = new DFSCacul(map,"油坊桥站","新街口站");
        cacuPath.cacul();
    }
}

数据初始化类

import java.util.HashMap;
import java.util.Map;

/**
 * 深度优先遍历计算所有地铁线路
 * 此处使用南京地铁部分线路进行测试
 */

public class DFSMain {

    private static final String line1 = "1号线";
    private static final String line2 = "2号线";
    private static final String line3 = "3号线";
    private static final String line4 = "4号线";
    private static final String line10 = "10号线";

    private static final String line1Station = "迈皋桥站-红山动物园站-南京站-新模范马路站-玄武门站-鼓楼站-" +
            "珠江路站-新街口站-张府园站-三山街站-中华门站-安德门站-天隆寺站-软件大道站-" +
            "花神庙站-南京南站-双龙大道站-河定桥站-胜太路站-百家湖站-小龙湾站-竹山路站-天印大道站-" +
            "龙眠大道站-南医大·江苏经贸学院站-南京交院站-中国药科大学站";

    private static final String line2Station = "油坊桥站-雨润大街站-元通站-奥体东站-兴隆大街站-集庆门大街站-云锦路站-莫愁湖站-"  +
            "汉中门站-上海路站-新街口站-大行宫站-西安门站-明故宫站-苜蓿园站-下马坊站-孝陵卫站-钟灵街站-马群站-金马路站-" +
            "仙鹤门站-学则路站-仙林中心站-羊山公园站-南大仙林校区站-经天路站";

    private static final String line3Station = "林场站-星火路站-东大成贤学院站-泰冯路站-天润城站-柳州东路站-上元门站-五塘广场站-" +
            "小市站-南京站-新庄站-鸡鸣寺站-浮桥站-大行宫站-常府街站-夫子庙站-武定门站-雨花门站-卡子门站-大明路站-明发广场站-南京南站-" +
            "宏运大道站-胜太西路站-天元西路-九龙湖站-诚信大道站-东大九龙湖校区站-秣周东路站";

    private static final String line4Station = "龙江站-草场门站-云南路站-鼓楼站-鸡鸣寺站-九华山站-岗子村站-蒋王庙站-王家湾站-聚宝山站-" +
            "徐庄站-金马路站-汇通路站-灵山站-东流站-孟北站-桦墅站-仙林湖站";


    private static final String line10Station = "雨山路站-文德路站-龙华路站-南京工业大学站-浦口万汇城站-临江.青奥体育公园站-江心洲站-" +
            "绿博园站-梦都大街站-奥体中心站-元通站-中胜站-小行站-安德门站";

    public static void main(String [] args) {
        Map<String, StationNode> map = new HashMap<>();
        InitData.initStation(map,line1Station);
        InitData.initStation(map,line2Station);
        InitData.initStation(map,line3Station);
        InitData.initStation(map,line4Station);
        InitData.initStation(map,line10Station);

        DFSCacul cacuPath = new DFSCacul(map,"油坊桥站","新街口站");
        cacuPath.cacul();
    }
}

4.实现效果

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

贼賊大宝
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Graph-DFS_WFS.zip_java无向图_wfs遍历_深度优先遍历
09-24
深度优先遍历，宽度优先遍历. 程序从图文本中读取图的矩阵。 矩阵包括有向图或无向图
java--DFS深度搜索方法
m0_73932182的博客
02-12 2673
解析DFS（深度搜索）方法，使用java，包含完整代码
基于Java的深度优先遍历（DFS）和广度优先遍历（BFS）
Robin的博客
12-08 3014
什么是深度/广度优先遍历(DFS/BFS)？ 深度优先遍历简称DFS（Depth First Search），广度优先遍历简称BFS（Breadth First Search），它们是遍历图当中所有顶点的两种方式。
图的遍历-----深度优先遍历（dfs）,广度优先遍历（bfs）【java详解】
最新发布
2302_79862386的博客
02-21 1654
图的遍历是指，从给定图中任意指定的顶点（称为初始点）出发，按照某种搜索方法沿着图的边访问图中的所有顶点，使每个顶点仅被访问一次，这个过程称为图的遍历。遍历过程中得到的顶点序列称为图遍历序列。深度优先搜索（DFS，Depth First Search）广度优先搜索（BFS，Breadth First Search）
【Java入门每日一练】使用DFS深度优先遍历文件夹
大三软件工程在读，喜爱编程，分享。
11-03 872
DFS算法实现文件夹的遍历，简单易懂！！
DFS(深度优先搜索算法)——Java实现(含例题）
m0_46669446的博客
03-13 3189
基本概念 深度优先搜索算法（Depth First Search，简称DFS）：一种用于遍历或搜索树或图的算法。 沿着树的深度遍历树的节点，尽可能深的搜索树的分支。当节点v的所在边都己被探寻过或者在搜寻时结点不满足条件，搜索将回溯到发现节点v的那条边的起始节点。整个进程反复进行直到所有节点都被访问为止。属于盲目搜索,最糟糕的情况算法时间复杂度为O(!n)。 回溯法 回溯法（探索与回溯法）是一种选优搜索法，又称为试探法，按选优条件向前搜索，以达到目标。但当探索到某一步时，发现原先选择并不优或达不到目标，
Java实现深度优先搜索算法（DFS）
06-14
深度优先搜索使用递归来实现。我们从指定的起始顶点开始，并将其标记为已访问。然后，对于起始顶点的每个邻居顶点，如果它尚未被访问过，则调用递归的dfs()方法进行深度优先搜索。 在示例代码中，我们以顶点0作为...
邻接矩阵存储图的深度优先遍历
06-05
深度优先遍历（DFS）是一种经典的图遍历算法，其基本思想是：从某个起始节点开始，依次遍历该节点的所有邻居节点；然后递归遍历这些邻居节点的未被访问过的邻居节点，直到所有节点都被遍历为止。
环路检测和打印（基于DFS--深度优先遍历）
09-14
环路检测和打印（基于DFS--深度优先遍历） 简单的swing界面
DFS.rar_dfs_dfs java_图的遍历_无向图 java
09-22
有向图或者无向图的深度优先遍历，给出遍历的节点序列
深度优先遍历DFS 非递归算法理解与Java实现(TreeNode树状结构非数组输入)
ptyp222的博客
10-05 1247
问题 给出一个类TreeNode，如何对其进行非递归的DFS进行遍历？ /* * public class TreeNode { * int val = 0; * TreeNode left = null; * TreeNode right = null; * } */ 思路 数据结构 非递归进行图的遍历会用到两种数据结构，栈与队列。考虑到两种数据结构的特性，不难想出栈更适合深度优先遍历，队列更适合广度优先遍历。 算法细节 针对深度优先遍历算法这里不多加赘述了，总结起来DFS就是一
DFS(深度搜索)无向图遍历(JAVA手把手深入解析)
热门推荐
红目香薰
02-11 5万+
DFS(深度搜索)无向图遍历(JAVA手把手深入解析) 前言 DFS深度优先 无向图 DFS全局变量定义 1、节点 2、节点数 3、根据图创建数组 4、状态记录数组 四个全局变量 DFS代码 1、DFS启动·进入到递归搜索中 2、深度递归 节点控制（深搜核心）： 3、遍历节点 4、最终输出： 5、输出效果： 完整代码对照 总结
Java实现Dfs算法（基本讲解）
gaoqiandr的博客
02-18 1560
本文主要介绍的是如何使用Java来实现Dfs算法
java实现dfs算法完成二维数组的遍历
a929549977的博客
05-30 476
dfs算法的java实现，递归遍历，二维数组遍历
【Java算法之dfs 与bfs详解】
qjjspl_的博客
04-08 1万+
Java算法之dfs 与bfs1. dfs1.1 递归1.2 非递归2. bfs2.1 常见两类问题 1. dfs 深度优先遍历(Depth First Search, 简称 DFS) 深度优先遍历各个节点，需要使用到栈（Stack）这种数据结构。Stack的特点是是先进后出，首先将右节点压入栈中，在将左节点压入栈中，这样出栈顺序就是先左节点再右节点。 DFS是图论里面的一种搜索算法，他可以由一个根节点出发，遍历所有的子节点，进而把图中所有的可以构成树的集合都搜索一遍，达到全局搜索的目的。所以很多问题都可以
java dfs 算法
weixin_68397667的博客
03-16 1005
图的遍历：DFS 可以用于图的遍历，通过深度优先的方式访问所有节点。状态空间搜索：DFS 可以用于搜索问题的状态空间，例如在八皇后问题中，每个状态都是一个棋盘上的布局，使用 DFS 可以搜索所有可能的布局，找到其中的解。连通性判断：DFS 可以用于判断图是否是连通的，即是否存在从一个节点到另一个节点的路径。路径搜索：DFS 可以用于搜索从一个节点到另一个节点的路径。生成树的构建：DFS 可以用于构建图的生成树，例如深度优先搜索生成树（DFS Tree），它是从起点开始访问所有可达节点的生成树。
Java实现图的深度优先遍历和广度优先遍历，深度广度优先遍历详解
04-16 2753
邻接矩阵实现图，Java实现数据结构，Java实现图的深度优先遍历，广度优先遍历
Java数据结构与算法----搜索篇（DFS与BFS）
stu_kk的博客
03-25 1716
DFS与BFS算法
java深度优先遍历dfs
10-11
Java中深度优先遍历（DFS）可以通过递归实现，以下是一个简单的示例代码： ```java public void dfs(Node node) { if (node == null) { return; } System.out.print(node.val + " "); node.visited = true; ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值