文章目录

• 前言
• 一、解法一：双递归
• 二、高效解法：后序剪枝
• 总结

---

前言

一道简单题，连错五六遍。。。

重点是把二叉树这种双递归的解题模板记住，记得有个二叉树简单题也是这样双递归，错了很多遍

就是主递归的返回逻辑一直搞不清楚，还是太笨了。。。

一、解法一：双递归

制造一个计算树节点的高度的方法depth()；【此为第一个递归方法】

主递归方法isBanlance()：
若节点为空，返回true
若左右子树绝对值 <= 1, 此为正确的第一个条件【不知道我设不符合就错是不是对的】
返回左右子树调用主递归的与

由于上面三个条件必须同时成立才行，因此可以简化为1行返回：
return Math.abs(depth(root.left) - depth(root.right)) && isBalance(root.left) && isBalance(root.right);

    public boolean isBalanced(TreeNode root) {
        if (root == null) return true;
        return  Math.abs(depth(root.left) - depth(root.right)) <= 1 && isBalanced(root.left) && isBalanced(root.right);
    }

    public int depth(TreeNode root) {
        if (root == null) return 0;
        if (root.left == null && root.right == null) return 1;
        return Math.max(depth(root.left), depth(root.right)) + 1;
    }

试了一下，逗比写法也是可以的。。。

 public boolean isBalanced(TreeNode root) {
        if (root == null) return true;
        int l = depth (root.left);
        int r = depth (root.right);
        if (Math.abs(l - r) > 1) return false;
        return isBalanced(root.left) && isBalanced(root.right);
    }

    public int depth(TreeNode root) {
        if (root == null) return 0;
        if (root.left == null && root.right == null) return 1;
        return Math.max(depth(root.left), depth(root.right)) + 1;
    }

二、高效解法：后序剪枝

对树进行后序遍历int check()：
退出条件：
若root == null , return 0;

其他情况：返回树深度或者-1；

若到某个节点，左树深度与右树深度大于1，则返回-1
当左右子树有一个返回-1，直接返回-1；

当check()返回值为-1时，主方法返回false；

 public boolean isBalanced(TreeNode root) {
        if (root == null) return true;
        return check(root) >= 0;
    }

    public int check(TreeNode root) {
        if (root == null) return 0;
        int l = check(root.left);
        if (l == -1) return -1;
        int r = check(root.right);
        if (r == -1) return -1;

        if (Math.abs(l - r) > 1) return -1;
        return Math.max(l, r) + 1;
    }

总结

（1）双递归的返回值一般都是 A(root) && B(root.left) && B(root.right)
“&&”要和“||”灵活切换，往往两种方法采取的逻辑不是一样的，因此彼此之间可能是或

（2）剪枝我也想到了，但是却不知道怎么保证既能传递会高度又能传递会boolean
搞来搞去只能用捞方法。
利用原始的c语言的int当对错倒是非常值的学习的。
有时候问题很简单，稍稍转化一下就行.

---

今天刷的第二题：误打误撞用了双指针，窃喜一波

 public int[] twoSum(int[] nums, int target) {
        if (nums == null || nums.length <= 1) return new int[0];
        int len = nums.length;
        int b = len - 1;
        for (int i = 0; i <= b; i++) {
            while (nums[i] + nums[b] > target) b--;
            if (nums[i] + nums[b] == target) return new int[]{nums[i], nums[b]};
        }

        return null;
    }

真实双指针：

 public int[] twoSum(int[] nums, int target) {
        int high = nums.length - 1, low = 0;

        while(low < high) {
            if (nums[low] + nums[high] < target) low++;
            else if (nums[low] + nums[high] > target) high--;
            else return new int[]{nums[low], nums[high]};
        }
        return null;
    }

原理是一样的，但是还没形成用这个方法的反射神经。

在有序问题上，最常见的做法是：二分法
其次是双指针

在链表问题上，最常见的做法也是双指针。