BFS-tree类-用queue的基本款们

最新推荐文章于 2025-03-14 09:38:16 发布

HelloWorld^_^

最新推荐文章于 2025-03-14 09:38:16 发布

阅读量246

点赞数

分类专栏： leetcode 文章标签：数据结构

本文链接：https://blog.youkuaiyun.com/sinat_21555157/article/details/106644075

版权

leetcode 专栏收录该内容

30 篇文章

订阅专栏

本文探讨BFS在处理树结构问题时的应用，主要涉及二叉树的层次遍历、锯齿形层次遍历、倒序层次遍历、右视图以及N-ary树的层次遍历。通过将遍历与访问分离，根据题目要求决定何时访问节点。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

BFS有两种用途（我分的类哈哈），1）tree; 2）graph。本文写tree的。tree的挺多的，这篇写基本款们，就是简单的。

题目	简介
102. Binary Tree Level Order Traversal	最基本
103. Binary Tree Zigzag Level Order Traversal	加一个奇偶行flag
107. Binary Tree Level Order Traversal II	从叶子到根
199. Binary Tree Right Side View	只求侧视图
429. N-ary Tree Level Order Traversal	二叉树–>多叉树

102. Binary Tree Level Order Traversal

在这里插入图片描述
就是模板啦，写了很多遍了。

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> ret = new ArrayList<>();
        if (root == null) {return ret;}
        Queue<TreeNode> q = new LinkedList<>();
        q.add(root);
        while (!q.isEmpty()) {
            int len = q.size();
            List<Integer> level = new ArrayList<>();
            for (int i = 0; i < len; i++) {
                TreeNode cur = q.poll(); //slower if using remove()
                level.add(cur.val);
                if (cur.left != null) {q.add(cur.left);}
                if (cur.right != null) {q.add(cur.right);}
            }
            ret.add(level);
        }
        return ret;
    }
}

103. Binary Tree Zigzag Level Order Traversal

在这里插入图片描述
和102一样，就是多了一个奇偶行的flag：goRight。

class Solution {
    public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
        List<List<Integer>> ret = new ArrayList<>();
        if (root == null) {return ret;}
        Queue<TreeNode> q = new LinkedList<>();
        boolean goRight = true;//奇偶行的flag
        q.add(root);
        while (!q.isEmpty()) {
            int len = q.size();
            List<Integer> level = new ArrayList<>();
            for (int i = 0; i < len; i++) {
                TreeNode cur = q.poll();
                if (goRight == true) {
                    level.add(cur.val);
                } else {
                    level.add(0, cur.val);
                }
                if (cur.left != null) {q.add(cur.left);}
                if (cur.right != null) {q.add(cur.right);}
            }
            ret.add(level);
            goRight = !goRight;
        }
        return ret;
    }
}

107. Binary Tree Level Order Traversal II

在这里插入图片描述
和102几乎一样，除了逆序加入result。

class Solution {
    public List<List<Integer>> levelOrderBottom(TreeNode root) {
        List<List<Integer>> ret = new ArrayList<>();
        if (root == null) {return ret;}
        Queue<TreeNode> q = new LinkedList<>();
        q.add(root);
        while (!q.isEmpty()) {
            List<Integer> level = new ArrayList<>();
            int len = q.size();
            for (int i = 0; i < len; i++) {
                TreeNode cur = q.poll();
                level.add(cur.val);
                if (cur.left != null) {q.add(cur.left);}
                if (cur.right != null) {q.add(cur.right);}
            }
            ret.add(0, level);//逆序加入result
        }
        return ret;
    }
}

199. Binary Tree Right Side View

在这里插入图片描述
和102几乎一样，更简单了，都不要所有结果，只要每行最后一个。
思考这种tree的问题的时候，把“遍历”和“访问”分开，先想怎么遍历，但遍历到某个点，不一定会访问，根据题目要求来决定是否访问。

class Solution {
    public List<Integer> rightSideView(TreeNode root) {
        List<Integer> ret = new ArrayList<>();
        if (root == null) {return ret;}
        Queue<TreeNode> q = new LinkedList<>();
        q.add(root);
        while (!q.isEmpty()) {
            int len = q.size();
            for (int i = 0; i < len; i++) {
                TreeNode cur = q.poll();
                if (i == len - 1) {ret.add(cur.val);}
                if (cur.left != null) {q.add(cur.left);}
                if (cur.right != null) {q.add(cur.right);}
            }
        }
        return ret;
    }
}

429. N-ary Tree Level Order Traversal

在这里插入图片描述
和102几乎一样，除了把left,right换成for (Node child : cur.children)。貌似children是保证非null的，就不用检查Null，直接丢进queue里即可。

class Solution {
    public List<List<Integer>> levelOrder(Node root) {
        List<List<Integer>> ret = new ArrayList<>();
        if (root == null) {return ret;}
        Queue<Node> q = new LinkedList<>();
        q.add(root);
        while (!q.isEmpty()) {
            List<Integer> level = new ArrayList<>();
            int len = q.size();
            for (int i = 0; i < len; i++) {
                Node cur = q.poll();
                level.add(cur.val);
                for (Node child : cur.children) {
                    q.add(child);
                }
            }
            ret.add(level);
        }
        return ret;
    }
}