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

目录

广度优先算法（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 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> levelOrderBottom(TreeNode root) {
        List> resList = new ArrayList>();
        bfsPreorder(root,resList);
        return resList;
    }
​
     /**
     * 前序遍历BFS
     * @param node
     * @param resList
     */
    public static void bfsPreorder(TreeNode node, List> resList) {
        if (node == null) return;
        Queue queue = new LinkedList<>();
        queue.offer(node);
​
        while (!queue.isEmpty()){
            int len = queue.size();
            List 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);
    }
}

• 时间复杂度：O(n)

• 空间复杂度：O(n)