leetcode 刷题_day15_二叉树02_层级遍历 & 翻转

层序遍历 10 题

思路

借助队列，层级一层循环，层内元素一层循环
后续的层级遍历题目，都可以以类似的代码解决

解题方法

复杂度

• 时间复杂度:

添加时间复杂度, 示例： $O(n)$

• 空间复杂度:

添加空间复杂度, 示例： $O(n)$

Code

/**
 * 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>> result = new ArrayList<>();

        checkTree(root, result);

        return result;
    }

    private void checkTree(TreeNode node, List<List<Integer>> result) {
        if (node == null) {
            return;
        }

        // 新建辅助队列，根节点首先入队列
        Deque<TreeNode> deque = new LinkedList<>();
        deque.addLast(node);

        // 层级遍历，队列为空说明遍历完成
        while(!deque.isEmpty()) {
            // 每一层级从左到右的数值列表
            List<Integer> itemList = new ArrayList<>();
            // 先获取当前队列的长度，此时队列长度正好为本层级节点个数
            int count = deque.size();

            // 遍历当前层
            while(count > 0) {
                TreeNode item = deque.pollFirst();
                itemList.add(item.val);

                // 将左右子节点放入队列
                if (item.left != null) {
                    deque.addLast(item.left);
                }
                if (item.right != null) {
                    deque.addLast(item.right);
                }

                count--;
            }

            result.add(itemList);

        }
    }
}

226.翻转二叉树

思路

使用深度优先的前序/后序遍历法，对每个节点的左右子节点操作就行

解题方法

复杂度

• 时间复杂度:

$O(n)$

• 空间复杂度:

$O(n)$

Code

  /**
 * 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;
        }

        swapNode(root);
        invertTree(root.left);
        invertTree(root.right);
        return root;
    }

    private void swapNode(TreeNode root) {
        TreeNode node = root.left;
        root.left = root.right;
        root.right = node;
    }
}

101.对称二叉树

思路

1. 二叉树是否对称，要比较的是根节点的左子树与右子树是不是相互翻转的
2. 比较的是两个子树的里侧和外侧的元素是否相等
3. 因为要遍历两棵树而且要比较内侧和外侧节点，所以准确的来说是一个树的遍历顺序是左右中，一个树的遍历顺序是右左中，从整体上讲，是后序遍历

解题方法

后序遍历的变种，此处使用递归

复杂度

• 时间复杂度:

添加时间复杂度, 示例： $O(n)$

• 空间复杂度:

添加空间复杂度, 示例： $O(n)$

Code

  
  /**
 * 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) {
        // 退出条件
        // 1. 存在null的情况
        if (left != null && right == null) {
            return false;
        }
        if (left == null && right != null) {
            return false;
        }
        if (left == null && right == null) {
            return true;
        }
        // 2. 值不相等
        if (left.val != right.val) {
            return false;
        }

        // 值相等，单层递归逻辑
        // 比较外侧
        boolean outside = compare(left.left, right.right);
        // 比较里侧
        boolean inside = compare(left.right, right.left);
        return outside && inside;
    }
}