海智算法训练营第十四天 | 第六章二叉树part02 | BFS层序遍历十道题

学习目标：

• 102.二叉树的层序遍历
• 107.二叉树的层次遍历II
• 199.二叉树的右视图
• 637.二叉树的层平均值
• 429.N叉树的层序遍历
• 515.在每个树行中找最大值
• 116.填充每个节点的下一个右侧节点指针
• 117.填充每个节点的下一个右侧节点指针II
• 104.二叉树的最大深度
• 111.二叉树的最小深度

因为比较好理解，所以直接做题，下面都是对应题的代码。

 

1..二叉树的层序遍历

 这个题最简单也是最模板的

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> res = new ArrayList<>();
        if(root == null) return res;
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        while(!queue.isEmpty()){
            List<Integer> ans = new ArrayList<>();
            int size = queue.size();
            while(size -- > 0){
                TreeNode temp = queue.poll();
                ans.add(temp.val);
                if(temp.left != null) queue.add(temp.left);
                if(temp.right != null) queue.add(temp.right);
            }
            res.add(ans);
        }
        return res;
    }
}

2..二叉树的层次遍历II

 加个翻转就可以了

class Solution {
    public List<List<Integer>> levelOrderBottom(TreeNode root) {
        List<List<Integer>> res = new ArrayList<>();
        if(root == null) return res;
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        while(!queue.isEmpty()){
            List<Integer> ans = new ArrayList<>();
            int size = queue.size();
            while(size -- > 0){
                TreeNode temp = queue.poll();
                ans.add(temp.val);
                if(temp.left != null) queue.add(temp.left);
                if(temp.right != null) queue.add(temp.right);
            }
            res.add(ans);
        }
        Collections.reverse(res);
        return res;
    }
}

3.二叉树的右视图

class Solution {
    public List<Integer> rightSideView(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        if(root == null) return res;
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        while(!queue.isEmpty()){
            int size = queue.size();
            TreeNode temp = null;
            while(size -- > 0){
                temp = queue.poll();
                if(temp.left != null) queue.add(temp.left);
                if(temp.right != null) queue.add(temp.right);
            }
            res.add(temp.val);
        }
        return res;
    }
}

4.二叉树的层平均值

class Solution {
    public List<Double> averageOfLevels(TreeNode root) {
        List<Double> res = new ArrayList<>();
        if(root == null) return res;
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        while(!queue.isEmpty()){
            int size = queue.size();
            int len = size;
            double average = 0;
            while(size -- > 0){
                TreeNode temp = queue.poll();
                average += temp.val;
                if(temp.left != null) queue.add(temp.left);
                if(temp.right != null) queue.add(temp.right);
            }
            
            res.add(average / len);
        }
        return res;
    }
}

5.N叉树的层序遍历

class Solution {
    public List<List<Integer>> levelOrder(Node root) {
        List<List<Integer>> res = new ArrayList<>();
        if(root == null) return res;
        Queue<Node> queue = new LinkedList<>();
        queue.add(root);
        while(!queue.isEmpty()){
            int size = queue.size();
            List<Integer> ans = new ArrayList<>();
            while(size -- > 0){
                Node temp = queue.poll();
                ans.add(temp.val);
                for(Node node : temp.children){
                    queue.add(node);
                }
            }

            res.add(ans);
        }
        return res;
    }
}

6.在每个树行中找最大值

 

class Solution {
    public List<Integer> largestValues(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        if(root == null) return res;
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        while(!queue.isEmpty()){
            List<Integer> ans = new ArrayList<>();
            int size = queue.size();
            while(size -- > 0){
                TreeNode temp = queue.poll();
                ans.add(temp.val);
                if(temp.left != null) queue.add(temp.left);
                if(temp.right != null) queue.add(temp.right);
            }
            res.add(Collections.max(ans));
        }
        return res;
    }
}

7.填充每个节点的下一个右侧节点指针

 

class Solution {
    public Node connect(Node root) {
        if(root == null) return null;
        Queue<Node> queue = new LinkedList<>();
        queue.add(root);
        while(!queue.isEmpty()){
            int size = queue.size();
            while(size -- > 0){
                Node temp = queue.poll();
                if(size == 0) temp.next = null;
                else temp.next = queue.peek();
                if(temp.left != null) queue.add(temp.left);
                if(temp.right != null) queue.add(temp.right);
            }

        }
        return root;
    }
}

8.填充每个节点的下一个右侧节点指针II

 和上题没区别的,疑惑子

class Solution {
    public Node connect(Node root) {
        if(root == null) return null;
        Queue<Node> queue = new LinkedList<>();
        queue.add(root);
        while(!queue.isEmpty()){
            int size = queue.size();
            while(size -- > 0){
                Node temp = queue.poll();
                if(size == 0) temp.next = null;
                else temp.next = queue.peek();
                if(temp.left != null) queue.add(temp.left);
                if(temp.right != null) queue.add(temp.right);
            }

        }
        return root;
    }
}

9.二叉树的最大深度

 

class Solution {
    public int maxDepth(TreeNode root) {
        int res = 0;
        if(root == null) return res;
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        while(!queue.isEmpty()){
            List<Integer> ans = new ArrayList<>();
            int size = queue.size();
            res ++;
            while(size -- > 0){
                TreeNode temp = queue.poll();
                ans.add(temp.val);
                if(temp.left != null) queue.add(temp.left);
                if(temp.right != null) queue.add(temp.right);
            }
        }
        return res;

    }
}

10.二叉树的最小深度

class Solution {
    public int minDepth(TreeNode root) {
        int res = 0;
        if(root == null) return res;
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        it:while(!queue.isEmpty()){
            int size = queue.size();
            res ++;
            while(size -- > 0){
                TreeNode temp = queue.poll();
                if(temp.left == null && temp.right == null) break it;
                if(temp.left != null) queue.add(temp.left);
                if(temp.right != null) queue.add(temp.right);
            }
        }
        return res;

    }
}

 

学习时长：2h

总结：这次学习了层序遍历，也就是广度优先搜索，用栈较好理解。