2022.05.04 剑指offer 55-1，55-2，64，68-1，68-2

学习剑指offer18、19天

55-1 二叉树的深度

• 法一：
  该方法可以理解为计算的是高度，根节点的高度即为叶节点的深度。树的高度等于左子树的高度与右子树的高度的最大值加1，使用递归来实现。

class Solution {
    // 每个节点的高度，为左节点的高度和右节点的高度最大值+1
    public int maxDepth(TreeNode root) {
        if(root == null) return 0;
        return Math.max(maxDepth(root.left), maxDepth(root.right)) + 1;
    }
}

• 法二：
  该方法是深度，从根节点遍历到叶节点，根节点的深度为1，每次递归深度+1，遍历到叶节点时更新最大深度

class Solution {
    // 深度是从上至下
    int max = 0;
    public int maxDepth(TreeNode root) {
        if(root == null) return 0;
        // 根节点的深度为1
        searchDepth(root, 1);
        return max;
    }
    public void searchDepth(TreeNode root, int cur){
        // 遍历到叶节点，更新深度
        if(root.left == null && root.right == null){
            max = Math.max(max, cur);
            return;
        }
        if(root.left != null) searchDepth(root.left, cur + 1);
        if(root.right != null) searchDepth(root.right, cur + 1);
    }
}

• 法三
  使用广度优先

class Solution {
    public int maxDepth(TreeNode root) {
        if(root == null) return 0;
        Deque<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        int count = 0;
        while(!queue.isEmpty()){
            int size = queue.size();
            count++;
            while(size-- > 0){
                TreeNode node = queue.removeFirst();
                if(node.left != null) queue.addLast(node.left);
                if(node.right != null) queue.addLast(node.right);
            }
        }
        return count; 
    }
}

55-2 判断是否为平衡二叉树

如果某二叉树中任意节点的左右子树的深度相差不超过1，那么它就是一棵平衡二叉树。

• 后序遍历+剪枝
  判断每个节点的左右子树的深度差值，如果小于等于1，则返回差值；如果大于1，则证明不是平衡二叉树，返回-1。对于-1来说，直接剪枝。

class Solution {
    //深度是从上至下，但是这个是看以每个节点为根节点的深度，所以采用高度会更好，从下至上
    public boolean isBalanced(TreeNode root) {
        if(root == null) return true;
        if(subBalanced(root) != -1) return true;
        return false; 
    }

    public int subBalanced(TreeNode root){
        if(root.left == null && root.right == null){
            return 1;
        }
        int left = 0, right = 0;
        if(root.left != null) left = subBalanced(root.left);
        if(root.right != null) right = subBalanced(root.right);
        if(left == -1 || right == -1 || Math.abs(left - right) > 1) return -1;
        return Math.max(left, right) + 1;
    }
}

68-1 二叉搜索树的最近公共祖先
给定一个二叉搜索树, 找到该树中两个指定节点的最近公共祖先。

因为给定的是二叉搜索树，所以可以利用二叉搜索树的性质，根节点大于左子树的值，小于右子树的值，所以就有三种情况

1. 若root.val < p.val 则p、q在root的右子树
2. 若root.va; > q.val 则p、q在root的左子树
3. 若root在p, q中间，则root是最近公共祖先

• 递归方法

class Solution {
    TreeNode result;
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        // 保证p在左 q在右
        if(p.val > q.val){
            TreeNode temp = p;
            p = q;
            q = temp;
        }
        findAncestor(root, p, q);
        return result;
    }

    public void findAncestor(TreeNode root, TreeNode p, TreeNode q){
        if(p.val <= root.val && q.val >= root.val){
            result = root;
            return;
        } 
        if(p.val > root.val) findAncestor(root.right, p, q);
        else findAncestor(root.left, p, q);
    }
}

• 迭代方法

public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        // 保证p在左 q在右
        if(p.val > q.val){
            TreeNode temp = p;
            p = q;
            q = temp;
        }
        while(root != null){
            if(p.val > root.val) root = root.right;
            else if(q.val < root.val) root = root.left;
            else break;
        }
        return root;
    }

68-2 二叉树的最近公共祖先

本题不是二叉搜索树，所以不能利用结点的值的性质。如果root是最近公共祖先，则有三种情况。

1. p和q在root的两侧
2. p=root，且q为p的子节点
3. q=root，且p为q的子节点

    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        // 要找到p、q的具体位置，如果root为空，则证明该路径没有p和q
        if(root == null || root == p || root == q) return root;
        TreeNode left = lowestCommonAncestor(root.left, p, q);
        TreeNode right = lowestCommonAncestor(root.right, p, q);
        //如果left和right均为空 则代表p和q没有在root的子树下
        if(left == null && right == null) return null;
        // 如果left或者right有一个为空，则代表节点在不为空的那侧
        if(left == null) return right;
        if(right == null) return left;
        // 最后一种情况是p和q在root两侧 最近公共祖先为root
        return root;
    }

64 计算1+2…+n

题目要求不可以使用乘除法、if,while等关键词
可以在递归的基础上，修改递归结束判断条件，之前用if，现在用逻辑运算符的短路效应

• if(A && B) 如果A为false，则不需要判断B
• if(A || B) 如果A为true，则不需要判断B

对于本题来说，当n <= 0 时，条件终止，所以可以使用 n > 1 && sumNums(n - 1)进行判断，当n <= 0 时，不需要再判断B

    int sum = 0;
    public int sumNums(int n) {
        sum += n;
        // x 只是一个辅助判断
        boolean x =  n > 1 && sumNums(n - 1) > 0;
        return sum;
    }