33二叉树——BFS深度优先遍历

最新推荐文章于 2024-05-11 14:30:05 发布

Elaine202391

最新推荐文章于 2024-05-11 14:30:05 发布

阅读量68

点赞数

分类专栏： LeetCode刷题之路文章标签：宽度优先深度优先算法 1024程序员节

本文链接：https://blog.csdn.net/Elaine2391/article/details/133993922

版权

LeetCode刷题之路专栏收录该内容

38 篇文章 0 订阅

订阅专栏

广度优先算法（Breadth-First Search，BFS）

LeetCode之路——107. 二叉树的层序遍历 II

分析

广度优先算法（Breadth-First Search，BFS）

BFS是一种用于遍历或搜索树状数据结构的算法，其中它首先探索树的广度，然后逐层访问各层的节点。在二叉树中，广度优先算法通常使用队列来实现。BFS逐层遍历树，从根节点开始，然后依次访问每一层的节点，然后再继续下一层。这种遍历方式通常用于寻找最短路径，或在树中查找特定节点时非常有用。

以下是广度优先遍历二叉树的Java代码示例，(想不清楚的情况下手动debug一边就理通了)：

import java.util.LinkedList;
import java.util.Queue;

class TreeNode {
    int data;
    TreeNode left;
    TreeNode right;

    public TreeNode(int data) {
        this.data = data;
    }
}

// 广度优先遍历（BFS）
void breadthFirstSearch(TreeNode root) {
    if (root == null) return;
    Queue<TreeNode> queue = new LinkedList<>();
    queue.offer(root); // 将根节点入队

    while (!queue.isEmpty()) {
        TreeNode node = queue.poll(); // 出队并访问节点
        System.out.print(node.data + " ");

        if (node.left != null) {
            queue.offer(node.left); // 左子节点入队
        }
        if (node.right != null) {
            queue.offer(node.right); // 右子节点入队
        }
    }
}

public static void main(String[] args) {
    TreeNode root = new TreeNode(1);
    root.left = new TreeNode(2);
    root.right = new TreeNode(3);
    root.left.left = new TreeNode(4);
    root.left.right = new TreeNode(5);

    breadthFirstSearch(root);
}

LeetCode之路——107. 二叉树的层序遍历 II

给你二叉树的根节点 root ，返回其节点值 自底向上的层序遍历 。（即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）

示例 1：

输入：root = [3,9,20,null,null,15,7]
输出：[[15,7],[9,20],[3]]

示例 2：

输入：root = [1]
输出：[[1]]

示例 3：

输入：root = []
输出：[]

提示：

树中节点数目在范围 [0, 2000] 内
-1000 <= Node.val <= 1000

分析

可以在二叉树——DFS深度优先遍历的基础上，反转最后的结果就解决了。

class Solution {
    public List<List<Integer>> levelOrderBottom(TreeNode root) {
        List<List<Integer>> resList = new ArrayList<List<Integer>>();
        bfsPreorder(root,resList);
        return resList;
    }

     /**
     * 前序遍历BFS
     * @param node
     * @param resList
     */
    public static void bfsPreorder(TreeNode node, List<List<Integer>> resList) {
        if (node == null) return;
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(node);

        while (!queue.isEmpty()){
            int len = queue.size();
            List<Integer> list = new ArrayList<>();

            while (len > 0) {
                TreeNode curr = queue.poll(); // 出队并访问节点
                list.add(curr.val);

                if(curr.left != null) {
                    queue.offer(curr.left); // 入队左子节点
                }
                if(curr.right != null) {
                    queue.offer(curr.right); // 入队右子节点
                }
                len--;
            }
            resList.add(list);
        }
        // 反转结果集合
        Collections.reverse(resList);
    }
}