代码随想录算法训练营第十五天 | 二叉树part02

题目：

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

---

学习内容：

层序遍历其实就是图论中的广度优先搜索。

二叉树的层序遍历

1. 迭代法。具体思路很简单，使用一个队列来维护每层的元素。使用一个while遍历每一层，再用一个while遍历每层的所有元素，templist来保存，最后add到res。

/**
 * 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>> levelOrder(TreeNode root) {
        List<List<Integer>> resList = new ArrayList<List<Integer>> (); // 最终的结果值
        Queue<TreeNode> que = new LinkedList<TreeNode>();
        if (root == null) return resList;
        que.add(root); // 先将头节点root加入队列

        while (!que.isEmpty()) {
            List<Integer> tempList = new ArrayList<Integer> (); // 定义一个用来保存每层所有元素的templist
            int size = que.size(); // 定义每层的大小，用于遍历一层
            while (size > 0) {
                // 弹出上一层的每个元素，并添加到templist
                TreeNode treenode = que.poll();
                tempList.add(treenode.val);
                // 将左右孩子（如果有）添加到que
                if (treenode.left != null) que.add(treenode.left);
                if (treenode.right != null) que.add(treenode.right);
                size--;
            }
            resList.add(tempList); // 将一层的元素添加到res
        }
        return resList;
    }
}

226.翻转二叉树

使用前序和后序遍历进行反转，把每个节点的左右孩子翻转一下，使用递归法：
写递归的三步骤：

• 确定递归函数（往往要自己写）的参数和返回值；
• 确定递归函数的终止条件；
• 确定单层递归的逻辑；
  为什么不能用中序？？
  因为可能会交换两次。
  前序遍历：

/**
 * 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 root; // 终止条件
        // 前序遍历 中左右
        swapChildren(root); // 遇到中间节点交换
        invertTree(root.left); // 左
        invertTree(root.right); // 右
        return root;
    }
    public 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);
    }
    public 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 leftRes = compare(left.left, right.right);
        boolean rightRes = compare(left.right, right.left);
        
         return leftRes&&rightRes;
    }
}

学习时间：

2024.3.21