力扣记录：二叉树1二叉树的遍历(2)——层序遍历

Kiwi_fruit

已于 2022-05-28 17:01:15 修改

阅读量176

点赞数

文章标签： leetcode 算法数据结构

于 2022-05-03 17:09:13 首次发布

本文链接：https://blog.csdn.net/Kiwi_fruit/article/details/124158342

版权

本文探讨了102-111号编程题目的解决方案，包括二叉树的层序遍历、层次遍历II、右视图、层平均值、N叉树层序遍历、树行最大值、节点连接等，展示了如何利用队列进行迭代和递归操作，以及针对特定问题的优化技巧。

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

本次题目

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

102 二叉树的层序遍历

层序遍历：迭代（使用队列）或递归。注意：在每次循环取出每层元素时队列长度变化，循环长度应固定为队列初始长度（该层元素个数）。

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        //定义可变二维数组返回结果
        List<List<Integer>> result = new ArrayList<List<Integer>>();
        //当二叉树为空时直接返回
        if(root == null) return result;
        //定义队列处理节点
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        //初始化，将根节点放入队列
        TreeNode node = root;
        queue.offer(node);
        //开始迭代，层序遍历，当队列为空时结束
        while(!queue.isEmpty()){
            //定义每层元素个数，即需要取出的节点个数
            int L = queue.size();
            //定义可变数组返回每层结果
            List<Integer> res = new ArrayList<Integer>();
            //循环取出L个元素，并将取出元素的左右孩子入队
            for(int i = 0; i < L; i++){
                node = queue.poll();
                //放入该层结果数组
                res.add(node.val);
                //取出元素的左右孩子入队
                if(node.left != null) queue.offer(node.left);
                if(node.right != null) queue.offer(node.right);
            }
            //将每层结果存入二维数组
            result.add(res);
        }
        //返回结果
        return result;
    }
}

107 二叉树的层次遍历II

同上102，最后结果数组行反转。

//同102
//最后结果数组行反转
        List<List<Integer>> result2 = new ArrayList<List<Integer>>();
        for(int i = result.size() - 1; i >= 0; i--){
            result2.add(result.get(i));
        }
        //返回结果
        return result2;

199 二叉树的右视图

同上102，只有当遍历到该层最后一个元素时将其添加到结果数组。

class Solution {
    public List<Integer> rightSideView(TreeNode root) {
        //定义可变数组返回结果
        List<Integer> result = new ArrayList<Integer>();
        //当二叉树为空时直接返回
        if(root == null) return result;
        //定义队列处理节点
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        //初始化，将根节点放入队列
        TreeNode node = root;
        queue.offer(node);
        //开始迭代，层序遍历，当队列为空时结束
        while(!queue.isEmpty()){
            //定义每层元素个数
            int L = queue.size();
            //循环，取出第L个元素，并将取出元素的左右孩子入队
            for(int i = 0; i < L; i++){
                node = queue.poll();
                //只存入第L个元素
                if(i == L - 1) result.add(node.val);
                //取出元素的左右孩子入队
                if(node.left != null) queue.offer(node.left);
                if(node.right != null) queue.offer(node.right);
            }
        }
        //返回结果
        return result;
    }
}

637 二叉树的层平均值

同上102，将结果数组每层求均值再存入结果数组。注意：返回Double。

class Solution {
    public List<Double> averageOfLevels(TreeNode root) {
        //定义可变数组返回结果
        List<Double> result = new ArrayList<Double>();
        //当二叉树为空时直接返回
        if(root == null) return result;
        //定义队列处理节点
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        //初始化，将根节点放入队列
        TreeNode node = root;
        queue.offer(node);
        //开始迭代，层序遍历，当队列为空时结束
        while(!queue.isEmpty()){
            //定义每层元素个数，即需要取出的节点个数
            int L = queue.size();
            //定义double计算每层元素之和
            double sum = 0.0;
            //循环取出L个元素，并将取出元素的左右孩子入队
            for(int i = 0; i < L; i++){
                node = queue.poll();
                //求和
                sum += node.val;
                //取出元素的左右孩子入队
                if(node.left != null) queue.offer(node.left);
                if(node.right != null) queue.offer(node.right);
            }
            //求平均值，将其存入二维数组
            result.add(sum/L);
        }
        //返回结果
        return result;
    }
}

429 N叉树的层序遍历

同上102，每个节点可能有多个孩子，但是不影响，每层的元素个数按取出元素的所有孩子个数计算。

class Solution {
    public List<List<Integer>> levelOrder(Node root) {
        //定义可变二维数组返回结果
        List<List<Integer>> result = new ArrayList<List<Integer>>();
        //当二叉树为空时直接返回
        if(root == null) return result;
        //定义队列处理节点
        Queue<Node> queue = new LinkedList<Node>();
        //初始化，将根节点放入队列
        Node node = root;
        queue.offer(node);
        //开始迭代，层序遍历，当队列为空时结束
        while(!queue.isEmpty()){
            //定义每层元素个数，即需要取出的节点个数
            int L = queue.size();
            //定义可变数组返回每层结果
            List<Integer> res = new ArrayList<Integer>();
            //循环取出L个元素，并将取出元素的所有孩子入队
            for(int i = 0; i < L; i++){
                node = queue.poll();
                //放入该层结果数组
                res.add(node.val);
                //取出元素的所有孩子入队
                if(node.children != null){
                    List<Node> chs = node.children;
                    for(int j = 0; j < chs.size(); j++){
                        queue.offer(chs.get(j));
                    }
                }
            }
            //将每层结果存入二维数组
            result.add(res);
        }
        //返回结果
        return result;
    }
}

515 在每个树行中找最大值

同上102，求结果数组每层的最大值，再存入结果数组。注意：List求最大值Collections.max()。

class Solution {
    public List<Integer> largestValues(TreeNode root) {
        //定义可变二维数组返回结果
        List<Integer> result = new ArrayList<Integer>();
        //当二叉树为空时直接返回
        if(root == null) return result;
        //定义队列处理节点
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        //初始化，将根节点放入队列
        TreeNode node = root;
        queue.offer(node);
        //开始迭代，层序遍历，当队列为空时结束
        while(!queue.isEmpty()){
            //定义每层元素个数，即需要取出的节点个数
            int L = queue.size();
            //定义可变数组存储每层元素
            List<Integer> res = new ArrayList<Integer>();
            //循环取出L个元素，并将取出元素的左右孩子入队
            for(int i = 0; i < L; i++){
                node = queue.poll();
                //放入该层结果数组
                res.add(node.val);
                //取出元素的左右孩子入队
                if(node.left != null) queue.offer(node.left);
                if(node.right != null) queue.offer(node.right);
            }
            //将每层最大值存入二维数组
            result.add(Collections.max(res));
        }
        //返回结果
        return result;
    }
}

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

同上102，每层的前一个节点指向后一个节点，最后一个节点指向null（不用修改）。

class Solution {
    public Node connect(Node root) {
        //当二叉树为空时直接返回
        if(root == null) return root;
        //定义队列处理节点
        Queue<Node> queue = new LinkedList<Node>();
        //初始化，将根节点放入队列
        queue.offer(root);
        //开始迭代，层序遍历，当队列为空时结束
        while(!queue.isEmpty()){
            //定义每层元素个数，即需要取出的节点个数
            int L = queue.size();
            //先取出第一个元素
            Node node = queue.poll();
            //取出元素的左右孩子入队
            if(node.left != null) queue.offer(node.left);
            if(node.right != null) queue.offer(node.right);
            //循环取出L-1个元素，当前元素next指向其并将其左右孩子入队
            for(int i = 1; i < L; i++){
                //取出next指向的元素
                Node next = queue.poll();
                //取出元素的左右孩子入队
                if(next.left != null) queue.offer(next.left);
                if(next.right != null) queue.offer(next.right);
                //修改当前元素next然后修改当前元素
                node.next = next;
                node = next;
            }
        }
        return root;
    }
}

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

同上116，116是完美二叉树但是本题不是，但是不影响，每层元素是按上层取出元素的左右孩子节点构成。

104 二叉树的最大深度

同上102，不用记录每层元素，定义整数记录层数，最后返回。

class Solution {
    public int maxDepth(TreeNode root) {
        //定义整数返回结果
        int result = 0;
        //当二叉树为空时直接返回
        if(root == null) return result;
        //定义队列处理节点
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        //初始化，将根节点放入队列
        TreeNode node = root;
        queue.offer(node);
        //开始迭代，层序遍历，当队列为空时结束
        while(!queue.isEmpty()){
            //定义每层元素个数，即需要取出的节点个数
            int L = queue.size();
            //循环取出L个元素，并将取出元素的左右孩子入队
            for(int i = 0; i < L; i++){
                node = queue.poll();
                //取出元素的左右孩子入队
                if(node.left != null) queue.offer(node.left);
                if(node.right != null) queue.offer(node.right);
            }
            //层数加1
            result++;
        }
        //返回结果
        return result;
    }
}

111 二叉树的最小深度

同上104，当该层有一个节点的左右孩子都为空时，即为最小深度。注意：循环开始时层数先加1。

class Solution {
    public int minDepth(TreeNode root) {
        //定义整数返回结果
        int result = 0;
        //当二叉树为空时直接返回
        if(root == null) return result;
        //定义队列处理节点
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        //初始化，将根节点放入队列
        TreeNode node = root;
        queue.offer(node);
        //开始迭代，层序遍历，当队列为空时结束
        while(!queue.isEmpty()){
            //层数加1
            result++;
            //定义每层元素个数，即需要取出的节点个数
            int L = queue.size();
            //循环取出L个元素，并将取出元素的左右孩子入队
            for(int i = 0; i < L; i++){
                node = queue.poll();
                //取出元素的左右孩子入队
                if(node.left != null) queue.offer(node.left);
                if(node.right != null) queue.offer(node.right);
                //当该层有一个节点的左右孩子都为空时，即为最小深度，直接返回
                if(node.left == null && node.right == null) return result;
            }
        }
        //返回结果
        return result;
    }
}