初识 BFS和DFS

最新推荐文章于 2024-08-09 16:35:49 发布

大鹏小站

最新推荐文章于 2024-08-09 16:35:49 发布

阅读量260

点赞数

分类专栏： LeetCode

本文链接：https://blog.csdn.net/linjpg/article/details/109346324

版权

LeetCode 专栏收录该内容

18 篇文章 0 订阅

订阅专栏

本文介绍了树和图的遍历方法，包括BFS（宽度优先搜索）和DFS（深度优先搜索）。BFS利用队列实现，遵循先进先出原则；DFS利用栈实现，遵循先进后出原则。通过实例展示了两种遍历方式的不同路径，并提到了数据结构在遍历中的应用。同时，文章提及了JAVA中BFS和DFS的代码实现，包括邻接矩阵和邻接表的图表示方式。

摘要由CSDN通过智能技术生成

树的遍历
在这里插入图片描述
BFS：A B C D E F G H I

DFS: A B C E F D G H I
图的遍历
在这里插入图片描述
从A出发

BFS：A B C D E F （其中一种）

DFS：A B D F E C （其中一种）

数据结构

BFS：队列（先进先出）

在这里插入图片描述

步骤：1、首先A入队列，

        2、A出队列时，A的邻接结点B，C相应进入队列 

        3、B出队列时，B的邻接结点A，C，D中未进过队列的D进入队列

        4、C出队列时，C的邻接结点A，B，D，E中未进过队列的E进入队列

        5、D出队列时，D的邻接结点B，C，E，F中未进过队列的F进入队列

        6、E出队列，没有结点可再进队列

        7、F出队列

DFS：栈（先进后出）

在这里插入图片描述

步骤：1、首先A入栈，

        2、A出栈时，A的邻接结点B，C相应入栈  （这里假设C在下，B在上）

        3、B出栈时，B的邻接结点A，C，D中未进过栈的D入栈

        4、D出栈时，D的邻接结点B，C，E，F中未进过栈的E、F入栈（假设E在下，F在上）

        5、F出栈时，F没有邻接结点可入栈

        6、E出栈，E的邻接结点C，D已入过栈

        7、C出栈

代码（JAVA）
1、图有两种表示方式，邻接矩阵和邻接表

public static void main(String[] args) {
        String[] A = {"B","C"};
        String[] B = {"A","C","D"};
        String[] C = {"A","B","D","E"};
        String[] D = {"B","C","E","F"};
        String[] E = {"C","D"};
        String[] F = {"D"};
        Map<String,String[]> map = new HashMap();
        map.put("A",A);
        map.put("B",B);
        map.put("C",C);
        map.put("D",D);
        map.put("E",E);
        map.put("F",F);
        BFS(map,"A");
        DFS(map,"A");
    }

BFS 用队列实现

public static void BFS(Map<String,String[]> map,String start){
        Queue<String> queue = new LinkedList();
        queue.add(start);
        List seen =new ArrayList();
        seen.add(start);
        while (queue.size()>0){
            String vertex = queue.poll();
            String[] nodes = map.get(vertex);
            for (int i = 0; i < nodes.length; i++) {
                if (!seen.contains(nodes[i])){
                    seen.add(nodes[i]);
                    queue.add(nodes[i]);
                }
            }
            System.out.println(vertex);
        }
        System.out.println();
    }

DFS 用栈实现

public static void DFS(Map<String,String[]> map,String start){
        Stack<String> stack = new Stack<>();
        stack.add(start);
        List seen =new ArrayList();
        seen.add(start);
        while (stack.size()>0){
            String vertex = stack.pop();
            String[] nodes = map.get(vertex);
            for (int i = 0; i < nodes.length; i++) {
                if (!seen.contains(nodes[i])){
                    seen.add(nodes[i]);
                    stack.add(nodes[i]);
                }
            }
            System.out.println(vertex);
        }
        System.out.println();
    }