代码随想录算法训练营第十五天|二叉树的层序遍历（以一打十吖）、226.翻转二叉树、101.对称二叉树

十道题区别与联系

题目序号	区别概述
102.二叉树的层序遍历	该题是二叉树迭代法层序遍历的模板题目。
107.二叉树的层序遍历II	从叶子节点所在层到根节点所在的层，逐层从左向右遍历，即相对102来说，把内层列表的遍历顺序做了翻转处理，逆序遍历内层列表即可。
199.二叉树的右视图	预设场景为遍历最右侧结点，即结果列表中保留每层遍历的结点的最右侧结点即可。
37.二叉树的层平均值	以数组的形式返回每一层节点的平均值即可，使用sum即时记录每层的加和，遍历完成后与每层size相除即可。
429.N叉树的层序遍历	层序遍历时控制每层个数的方式有所区别。
515.在每个树行中找最大值	记录每层的局部最大值，每次遍历时都和整体最大值相比较，取整体最大值和局部最大值的较大值作为下次遍历的整体最大值。
116.填充每个结点的下一个右侧结点指针	遍历每层时加入了指针连接操作（即当前结点不为最右结点时，就让当前结点next指向待弹出的右侧结点，最右侧结点的next指针初始化时即为null无需处理）
117.填充每个结点的下一个右侧结点指针||	与116的区别：116是若不为最后一个结点则连接下一个结点，这个是若不为第一个结点，则将当前结点左边结点连接上当前结点。
104.二叉树的最大深度	与模板相比，即定义整体二叉树深度变量，每次层序遍历时自增一即可记录二叉树最大深度。
111.二叉树的最小深度	与104不同点在于，增加了首次遇见最后一层结点时返回当前结点深度的操作，通过定义了新的数据结构实现，新数据结构记录了当前的结点和当前结点的深度。

102.二叉树的层序遍历

• 刷题https://leetcode.cn/problems/binary-tree-level-order-traversal/description/
• 文章讲解https://programmercarl.com/0102.%E4%BA%8C%E5%8F%89%E6%A0%91%E7%9A%84%E5%B1%82%E5%BA%8F%E9%81%8D%E5%8E%86.html
• 视频讲解https://www.bilibili.com/video/BV1GY4y1u7b2/?vd_source=af4853e80f89e28094a5fe1e220d9062

• 题解1（迭代法）：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    //二叉树层序遍历迭代法
    //存储结果
    public List<List<Integer>> resultList = new ArrayList<List<Integer>>();
    //主函数
    public List<List<Integer>> levelOrder(TreeNode root) {
        checkFun(root);
        return resultList;
    }
    //借助队列
    public void checkFun(TreeNode cur){
        //若为空，则直接返回
        if(cur == null){
            return;
        }
        //创建链辅助队列，并加入根结点
        Queue<TreeNode> que = new LinkedList<TreeNode>();
        que.offer(cur);
        //当辅助队列内非空
        while(!que.isEmpty()){
            List<Integer> itemList = new ArrayList<Integer>();
            int len = que.size();
            while(len > 0){
                TreeNode tempNode = que.poll();
                itemList.add(tempNode.val);

                if(tempNode.left != null){
                    que.offer(tempNode.left);
                }
                if(tempNode.right != null){
                    que.offer(tempNode.right);
                }
                len--;
            }
            resultList.add(itemList);
        }
    }
}

• 题解2（递归法）：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    //二叉树的递归层序遍历
    //二维数组存储遍历结果
    public List<List<Integer>> resultList = new ArrayList<List<Integer>>();
    //递归遍历
    public void checkFun(TreeNode cur, Integer deep){
        //若传入二叉树为空，则直接返回
        if(cur == null){
            return;
        }
        //传入二叉树非空，则先遍历深度+1
        deep++;
        //当前遍历结果中层数小于当前deep,则进行遍历
        if(resultList.size() < deep){
            //层级增加时，list的Item增加，利用list索引值进行层级界定
            List<Integer> item = new ArrayList<Integer>();
            resultList.add(item);
        }
        //将当前遍历结点加入结果数组
        resultList.get(deep - 1).add(cur.val);
        checkFun(cur.left, deep);
        checkFun(cur.right,deep);
    }

    //主函数
    public List<List<Integer>> levelOrder(TreeNode root) {
        checkFun(root, 0);
        return resultList;
    }
}

107.二叉树的层序遍历II

• 刷题https://leetcode.cn/problems/binary-tree-level-order-traversal-ii/description/

• 题解：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    //与102的区别是:
    //在将每层的内层数组加入列表时，每次都加在列表的第一个位置上。
    public List<List<Integer>> levelOrderBottom(TreeNode root) {
        // 存储最终结果
        List<List<Integer>> result = new LinkedList<List<Integer>>();
        //如果传入二叉树为空，则直接返回
        if(root == null){
            return result;
        }
        //定义辅助队列
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        //加入根结点，开始算法
        queue.offer(root);
        //辅助队列非空
        while(!queue.isEmpty()){
            //定义当前层的容器
            List<Integer> temp = new LinkedList<Integer>();
            //初始化容器大小
            int size = queue.size();
            //开始遍历当前size的层
            for(int i = 0; i < size; i++){
                //从辅助队列中弹出队首，放入当前容器
                TreeNode cur = queue.poll();
                temp.add(cur.val);
                //分别加入当前弹出元素的左孩子和右孩子
                if(cur.left != null){
                    queue.offer(cur.left);
                }
                if(cur.right != null){
                    queue.offer(cur.right);
                }
            }
            //遍历完成当前层，加入最终结果集
            result.add(0,temp);
        }
        return result;
    }
}

199.二叉树的右视图

• 刷题https://leetcode.cn/problems/binary-tree-right-side-view/description/

• 题解：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    //与之前的又有区别：
    //只需要最右边的结点，不再需要定义嵌套列表
    public List<Integer> rightSideView(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        if(root == null){
            return result;
        }
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while(!queue.isEmpty()){
            int size = queue.size();
            //遍历当前层的所有结点
            for(int i = 0; i < size; i++){
                TreeNode cur = queue.poll();
                if(cur.left != null){
                    queue.offer(cur.left);
                }
                if(cur.right != null){
                    queue.offer(cur.right);
                }
                //若元素在当前层最后一个,则将这个元素加入结果集合
                if(i == size - 1){
                    result.add(cur.val);
                }
            }
        }
        return result;
    }
}

637.二叉树的层平均值

• 刷题https://leetcode.cn/problems/average-of-levels-in-binary-tree/description/

• 题解：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    //不同点在于需要在遍历每层元素时将每层的元素做累加，
    //遍历完该层元素后即计算该层元素均值并接入结果集。
    public List<Double> averageOfLevels(TreeNode root) {
        List<Double> averages = new ArrayList<Double>();
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        queue.offer(root);
        while(!queue.isEmpty()){
            double sum = 0;
            int size = queue.size();
            for(int i = 0; i < size; i++){
                TreeNode cur = queue.poll();
                sum += cur.val;
                if(cur.left != null){
                    queue.offer(cur.left);
                }
                if(cur.right != null){
                    queue.offer(cur.right);
                }
            }
            //遍历完一层后，计算该层均值
            averages.add(sum / size);
        }
        return averages;
    }
}

429.N叉树的层序遍历

• 刷题https://leetcode.cn/problems/n-ary-tree-level-order-traversal/description/

• 题解：

/*
// Definition for a Node.
class Node {
    public int val;
    public List<Node> children;

    public Node() {}

    public Node(int _val) {
        val = _val;
    }

    public Node(int _val, List<Node> _children) {
        val = _val;
        children = _children;
    }
};
*/

class Solution {
    //不同点是:n叉树用null分割，和遍历孩子结点的方式的改变。
    public List<List<Integer>> levelOrder(Node root) {
        List<List<Integer>> result = new ArrayList<List<Integer>>();
        if(root == null){
            return result;
        }
        //改为使用双向队列辅助
        //debug点:此处使用队列接口中的双向接口的数组实现形式
        Queue<Node> queue = new ArrayDeque<Node>();
        queue.offer(root);
        while(!queue.isEmpty()){
            int size = queue.size();
            List<Integer> temp = new ArrayList<Integer>();
            for(int i = 0;i < size; i++){
                Node cur = queue.poll();
                temp.add(cur.val);
                for(Node child : cur.children){
                    queue.offer(child);
                }
            }
            result.add(temp);
        }
        return result;
    }
}

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

• 刷题https://leetcode.cn/problems/find-largest-value-in-each-tree-row/description/

• 题解：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    //不同点:记录遍历的每层的最大值
    public List<Integer> largestValues(TreeNode root) {
        List<Integer> result = new ArrayList<Integer>();
        if(root == null){
            return result;
        }
        Queue<TreeNode> queue = new ArrayDeque<TreeNode>();
        queue.offer(root);
        while(!queue.isEmpty()){
            int size = queue.size();
            int maxValue = Integer.MIN_VALUE;
            while(size > 0){
                size--;
                TreeNode temp = queue.poll();
                maxValue = Math.max(maxValue, temp.val);
                if(temp.left != null){
                    queue.offer(temp.left);
                }
                if(temp.right != null){
                    queue.offer(temp.right);
                }
            }
            result.add(maxValue);
        }
        return result;
    }
}

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

• 刷题https://leetcode.cn/problems/populating-next-right-pointers-in-each-node/description/

• 题解：

/*
// Definition for a Node.
class Node {
    public int val;
    public Node left;
    public Node right;
    public Node next;

    public Node() {}
    
    public Node(int _val) {
        val = _val;
    }

    public Node(int _val, Node _left, Node _right, Node _next) {
        val = _val;
        left = _left;
        right = _right;
        next = _next;
    }
};
*/

class Solution {
    //不同点是:每层的遍历中加入了指针连接操作
    public Node connect(Node root) {
        if(root == null){
            return root;   
        }
        //初始化队列同时将第一层节点加入队列中
        Queue<Node> queue = new LinkedList<Node>();
        queue.add(root);
        //循环迭代层数
        while(!queue.isEmpty()){
            int size = queue.size();
            for(int i = 0; i < size; i++){
                //队首取出元素
                Node cur = queue.poll();
                //连接,若不是最后一个，则连接右边结点(即下一个结点)
                //最后一个结点初始化时已自动指向null
                if(i < size - 1){
                    cur.next = queue.peek();
                }
                //拓展下一层节点
                if(cur.left != null){
                    queue.add(cur.left);
                }
                if(cur.right != null){
                    queue.add(cur.right);
                }
            }
        }
        return root;
    }
}

117.填充每个结点的下一个右侧结点指针||

• 刷题https://leetcode.cn/problems/populating-next-right-pointers-in-each-node-ii/description/

• 题解：

/*
// Definition for a Node.
class Node {
    public int val;
    public Node left;
    public Node right;
    public Node next;

    public Node() {}
    
    public Node(int _val) {
        val = _val;
    }

    public Node(int _val, Node _left, Node _right, Node _next) {
        val = _val;
        left = _left;
        right = _right;
        next = _next;
    }
};
*/

class Solution {
    //与116的区别：
    //116是若不为最后一个结点则连接下一个结点
    //这个是若不为第一个结点，则将当前结点左边结点连接上当前结点
    public Node connect(Node root) {
        if(root == null){
            return root;
        }
        Queue<Node> queue = new ArrayDeque<Node>();
        queue.offer(root);
        while(!queue.isEmpty()){
            int size = queue.size();
            Node last = null;
            for(int i = 0; i < size; i++){
                Node cur = queue.poll();
                if(cur.left != null){
                    queue.offer(cur.left);
                }
                if(cur.right != null){
                    queue.offer(cur.right);
                }
                //若不是当前层第一个结点，则将上一个结点的next指针指向当前结点并继续向下遍历
                if(i != 0){
                    last.next = cur;
                }
                last = cur;
            }
        }
        return root;
    }
}

104.二叉树的最大深度

• 刷题https://leetcode.cn/problems/maximum-depth-of-binary-tree/description/

• 题解：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public int maxDepth(TreeNode root) {
        if(root == null){
            return 0;
        }
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        queue.offer(root);
        int result = 0;
        while(!queue.isEmpty()){
            int size = queue.size();
            //层次遍历
            while(size != 0){
                TreeNode cur = queue.poll();
                if(cur.left != null){
                    queue.offer(cur.left);
                }
                if(cur.right != null){
                    queue.offer(cur.right);
                }
                size--;
            }
            //层数加一
            result++;
        }
        return result;
    }
}

111.二叉树的最小深度

• 刷题https://leetcode.cn/problems/minimum-depth-of-binary-tree/description/

• 题解：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    //定义数据结构，记录树中结点及每个结点所在的层数
    class QueueNode{
        TreeNode node;
        int depth;
        public QueueNode(TreeNode node, int depth){
            this.node = node;
            this.depth = depth;
        }
    }
    //不同点在于，增加了首次遇见最后一层结点时返回当前结点深度的操作。
    //通过定义数据结构实现。
    public int minDepth(TreeNode root) {
        if(root == null){
            return 0;
        }
        Queue<QueueNode> queue = new LinkedList<QueueNode>();
        queue.offer(new QueueNode(root,1));
        while(!queue.isEmpty()){
            QueueNode curDepth = queue.poll();
            TreeNode cur = curDepth.node;
            int depth = curDepth.depth;
            //若左右结点均为空，说明已遍历到最后一层，返回高度
            //放在最前面，一旦遇见最后一层的结点即返回最小深度
            if(cur.left == null && cur.right == null){
                return depth;
            }
            if(cur.left != null){
                queue.offer(new QueueNode(cur.left, depth + 1));
            }
            if(cur.right != null){
                queue.offer(new QueueNode(cur.right, depth + 1));
            }
        }
        //若失败，返0
        return 0;
    }
}

226.翻转二叉树

• 刷题https://leetcode.cn/problems/invert-binary-tree/description/
• 文章讲解https://programmercarl.com/0226.%E7%BF%BB%E8%BD%AC%E4%BA%8C%E5%8F%89%E6%A0%91.html
• 视频讲解https://www.bilibili.com/video/BV1sP4y1f7q7/?vd_source=af4853e80f89e28094a5fe1e220d9062

• 题解（后序递归法）：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    //迭代法翻转二叉树
    public TreeNode invertTree(TreeNode root) {
        if(root == null){
            return null;
        }
        invertTree(root.left);
        invertTree(root.right);
        swapChildren(root);
        return root;
    }

    private void swapChildren(TreeNode root){
        TreeNode temp = root.left;
        root.left = root.right;
        root.right = temp;
    }
}

101.对称二叉树

• 刷题
• 文章讲解
• 视频讲解

• 题解（递归法）：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    //递归法
    public boolean isSymmetric(TreeNode root) {
        return compare(root.left, root.right);
    }
    private boolean compare(TreeNode left, TreeNode right){
        //出口部分
        if(left == null && right != null){
            return false;
        }
        if(left != null && right == null){
            return false;
        }
        if(left == null && right == null){
            return true;
        }
        if(left.val != right.val){
            return false;
        }
        //递归部分
        //外侧
        boolean compareOutside = compare(left.left, right.right);
        //内侧
        boolean compareInside = compare(left.right, right.left);
        //只有当外侧和内测判断结束后均相等，说明改二叉树可以翻转，是对称二叉树
        return compareInside && compareOutside;
    }
}