数据结构-LeetCode刷题(树）(下)

(LeetCode 101)对称二叉树

给你一个二叉树的根节点 root ， 检查它是否轴对称。

方法一 递归实现

• 问题已理解

class Solution {
    public boolean isSymmetric(TreeNode root) {
        if(root == null){
            return true;
        }
        //递归调用，比较左右结点
        return deepCheck(root.left,root.right);
    }

    boolean deepCheck(TreeNode left,TreeNode right){
        //递归终止条件：两个结点都空
        //有一个为空
        //两个结点值不同
        if(left == null && right == null){
            return true;
        }
        if(left == null || right == null){
            return false;
        }
        if(left.val != right.val){
            return false;
        }
        //再比较左子树的右结点和右子树的左结点
        //以及左子树的左结点和右子树的右结点
        return deepCheck(left.left,right.right) && deepCheck(left.right,right.left);
    }
}

方法二 借助队列

先入后出的特性，同样也能实现递归的遍历

• 问题已理解

1. 如图所示，当判断完2 2后，3 3和4 4入队列。
2. 先出其中一个，此时继续将已出队列的左右子结点按固定顺序入队列。
3. 它们没有子结点，但由于队列非空，即还能进入while循环，但循环里的null判断会跳出当前循环
4. 此时，再将剩下的一对数字入队列进行判断。

public boolean isSymmetric(TreeNode root) {
        Queue<TreeNode> q = new LinkedList<TreeNode>();
        TreeNode u = root.left;
        TreeNode v = root.right;
        if(root == null || (u == null && v == null)){
            return true;
        }
        q.offer(u);
        q.offer(v);
        while(!q.isEmpty()){
            u = q.poll();
            v = q.poll();
            if(u == null && v == null){
                continue;  //会结束当次while循环                
            }
            if((u == null || v == null) || (u.val != v.val)){
                return false;
            }

            q.offer(u.left);
            q.offer(v.right);

            q.offer(u.right);
            q.offer(v.left);
        }
        return true;
    }

(LeetCode 104)二叉树的最大深度

给定一个二叉树 root ，返回其最大深度。
二叉树的 最大深度 是指从根节点到最远叶子节点的最长路径上的节点数。

方法一 递归实现

1. 问题已理解

class Solution {
    public int maxDepth(TreeNode root) {
        if(root == null){
            return 0;
        }else{
            return Math.max(maxDepth(root.left),maxDepth(root.right)) + 1;
        }
    }
}

方法二 队列实现

1. size用于记录本层级的结点是否处理完毕
   即while(size > 0)一轮循环结束，就代表当前层级处理完毕
2. depth用于记录深度，也是一轮循环后+1，代表当前层级以计算在内

 public int maxDepth(TreeNode root) {
        if(root == null){
            return 0;
        }
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        int depth = 0;
        while(!queue.isEmpty()){
            int size = queue.size();
            while(size > 0){
                TreeNode node = queue.poll();
                if(node.left != null){
                    queue.offer(node.left);
                }
                 if(node.right != null){
                    queue.offer(node.right);
                }
                size--;
            }
            depth++;
        }
        return depth;
    }

(LeetCode 110)平衡二叉树

给定一个二叉树，判断它是否是高度平衡的二叉树。

本题中，一棵高度平衡二叉树定义为：
一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1 。

方法 递归

1. 由于是针对每一个结点的左右子树，所以我们自下往上遍历
2. 最底下的结点访问完，其深度的计算+1
3. 判断每个结点的左右子树，其深度差是否大于1
4. 不断向上，若深度差不大于1，则取两者的最大值+1 作为这一支子树的最大深度

• 问题已理解

class Solution {
    public boolean isBalanced(TreeNode root) {
        if(root == null){
            return true;
        }
        return helper(root) != -1;
    }

    private int helper(TreeNode root){
        if(root == null){
            return 0;
        }
        int left = helper(root.left);
        int right = helper(root.right);

        if(left == -1 || right == -1 || Math.abs(left - right) > 1){
            return -1;
        }
        return Math.max(left,right) + 1;
    }
}

(LeetCode 226)反转二叉树

给你一棵二叉树的根节点 root ，翻转这棵二叉树，并返回其根节点。

方法 递归

从下往上，反转左右子树

• 问题已理解

class Solution {
    public TreeNode invertTree(TreeNode root) {
        if(root == null){
            return null;
        }
        invertTree(root.left);
        invertTree(root.right);
        TreeNode temp = root.left;
        root.left = root.right;
        root.right = temp;
        return root;
    }
}