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

文档讲解：代码随想录

状态：已完成

110.平衡二叉树

题外话

咋眼一看这道题目和104.二叉树的最大深度 (opens new window)很像，其实有很大区别。

这里强调一波概念：

• 二叉树节点的深度：指从根节点到该节点的最长简单路径边的条数。
• 二叉树节点的高度：指从该节点到叶子节点的最长简单路径边的条数。

但leetcode中强调的深度和高度很明显是按照节点来计算的，如图：

思路

递归

此时大家应该明白了既然要求比较高度，必然是要后序遍历。

递归三步曲分析：

• 1.明确递归函数的参数和返回值

参数：当前传入节点。 返回值：以当前传入节点为根节点的树的高度。

那么如何标记左右子树是否差值大于1呢？

如果当前传入节点为根节点的二叉树已经不是二叉平衡树了，还返回高度的话就没有意义了。

所以如果已经不是二叉平衡树了，可以返回-1 来标记已经不符合平衡树的规则了。

• 2.明确终止条件

递归的过程中依然是遇到空节点了为终止，返回0，表示当前节点为根节点的树高度为0

代码如下：

• 3.明确单层递归的逻辑

如何判断以当前传入节点为根节点的二叉树是否是平衡二叉树呢？当然是其左子树高度和其右子树高度的差值。

分别求出其左右子树的高度，然后如果差值小于等于1，则返回当前二叉树的高度，否则返回-1，表示已经不是二叉平衡树了。

代码如下：

class Solution {
    public boolean isBalanced(TreeNode root) {
        int height = getHeight(root);
        if (height < 0){
            return false;
        }
        return true;
    }
    //递归法
    //递归三部曲
    //1.确定参数及返回值
    int getHeight(TreeNode node){
        //2.确定递归终止条件
        if (node == null){return 0;}
        //3.确定单层递归逻辑
        int left = getHeight(node.left);
        if (left < 0){return left;}
        int right = getHeight(node.right);
        if (right < 0){return right;}

        if (Math.abs(left - right) > 1){//说明不是平衡二叉树
            return -1;
        }
        return 1 + Math.max(left,right);
    }
}

---

257. 二叉树的所有路径

思路

这道题目要求从根节点到叶子的路径，所以需要前序遍历，这样才方便让父节点指向孩子节点，找到对应的路径。

在这道题目中将第一次涉及到回溯，因为我们要把路径记录下来，需要回溯来回退一个路径再进入另一个路径。

前序遍历以及回溯的过程如图：

我们先使用递归的方式，来做前序遍历。要知道递归和回溯就是一家的，本题也需要回溯。

递归

• 1.递归函数参数以及返回值

要传入根节点，记录每一条路径的path，和存放结果集的result，这里递归不需要返回值，代码如下：

void getPaths(TreeNode node,List<String> result,List<Integer> paths){

• 2.确定递归终止条件

在写递归的时候都习惯了这么写：

if (cur == NULL) {
    终止处理逻辑
}

但是本题的终止条件这样写会很麻烦，因为本题要找到叶子节点，就开始结束的处理逻辑了（把路径放进result里）。

那么什么时候算是找到了叶子节点？ 是当 cur不为空，其左右孩子都为空的时候，就找到叶子节点。

所以本题的终止条件是：

if (node.left == null && node.right == null){
    终止处理逻辑
}

为什么没有判断cur是否为空呢，因为下面的逻辑可以控制空节点不入循环。

再来看一下终止处理的逻辑。

有些人的代码也没有回溯,但其实是有回溯的，只不过隐藏在函数调用时的参数赋值里

 if (node.left == null && node.right == null){
            // StringBuilder用来拼接字符串，速度更快
            StringBuilder sb = new StringBuilder();
            //处理集合中前size - 1个元素
            for (int i = 0; i < paths.size() - 1; i++) {
                sb.append(paths.get(i)).append("->");
            }
            //处理最后一个元素
            sb.append(paths.get(paths.size() - 1));
            //保存到结果集中
            result.add(sb.toString());
            return;
        }

• 3.确定单层递归逻辑

因为是前序遍历，需要先处理中间节点，中间节点就是我们要记录路径上的节点，先放进path中。

paths.add(node.val);//中

然后是递归和回溯的过程，上面说过没有判断 node 是否为空，那么在这里递归的时候，如果为空就不进行下一层递归了。

所以递归前要加上判断语句，下面要递归的节点是否为空

此时还没完，递归完，要做回溯啊，因为path 不能一直加入节点，它还要删节点，然后才能加入新的节点。

那么回溯要怎么回溯呢，如下：

        // 递归和回溯是同时进行，所以要放在同一个花括号里
        //左
        if (node.left != null){
            getPaths(node.left,result,paths);
            //回溯
            paths.remove(paths.size() - 1);
        }
        //右
        if (node.right != null){
            getPaths(node.right,result,paths);
            //回溯
            paths.remove(paths.size() - 1);
        }

全部代码如下：

class Solution {
    public List<String> binaryTreePaths(TreeNode root) {
        //用于记录结果集
        List<String> result = new ArrayList<>();
        //根节点为空直接返回
        if (root == null){return result;}
        List<Integer> paths = new ArrayList<>();
        getPaths(root,result,paths);
        return result;
    }
    //遍历方法：前序遍历【中左右】
    //递归三部曲之 确定 方法返回值 及 参数
    void getPaths(TreeNode node,List<String> result,List<Integer> paths){
        paths.add(node.val);//中
        //递归三部曲之 确定递归结束条件
        if (node.left == null && node.right == null){
            // StringBuilder用来拼接字符串，速度更快
            StringBuilder sb = new StringBuilder();
            //处理集合中前size - 1个元素
            for (int i = 0; i < paths.size() - 1; i++) {
                sb.append(paths.get(i)).append("->");
            }
            //处理最后一个元素
            sb.append(paths.get(paths.size() - 1));
            //保存到结果集中
            result.add(sb.toString());
            return;
        }
        // 递归和回溯是同时进行，所以要放在同一个花括号里
        //左
        if (node.left != null){
            getPaths(node.left,result,paths);
            //回溯
            paths.remove(paths.size() - 1);
        }
        //右
        if (node.right != null){
            getPaths(node.right,result,paths);
            //回溯
            paths.remove(paths.size() - 1);
        }
    }
}

---

404.左叶子之和

思路一

前序遍历【中左右】

难点：

       1.无法判断当前结点是否为左节点

                定义一个参数 boolean isLeft ，true -> 当前结点是左节点，fasle -> 当前结点是右节点

直接见代码：

class Solution {
    public int sumOfLeftLeaves(TreeNode root) {
        //用于手机所有左叶子的值
        List<Integer> list = new ArrayList<>();
        if (root == null){return 0;}
        getLeftSum(root,list,false);
        int sum = 0;
        for (Integer integer : list) {
            sum += integer;
        }
        return sum;
    }
    //递归三部曲
    //1.确定返回值及参数
    //  isLeft :
    //  true -> 当前结点是左节点
    //  fasle -> 当前结点不是左节点
    void getLeftSum(TreeNode node,List<Integer> list,boolean isLeft){
        //2.确定递归终止条件
        if (node == null) {return ;}
        //3.确定单层递归逻辑
        // 前序遍历【中左右】
        //中
        if (isLeft && node.left == null && node.right == null ){
            list.add(node.val);
        }
        //左
        if (node.left != null){
            getLeftSum(node.left,list,true);
        }
        //右
        if (node.right != null){
            getLeftSum(node.right,list,false);
        }
    }
}

思路二

首先要注意是判断左叶子，不是二叉树左侧节点，所以不要上来想着层序遍历。

因为题目中其实没有说清楚左叶子究竟是什么节点，那么我来给出左叶子的明确定义：节点A的左孩子不为空，且左孩子的左右孩子都为空（说明是叶子节点），那么A节点的左孩子为左叶子节点

大家思考一下如下图中二叉树，左叶子之和究竟是多少？

大家思考一下如下图中二叉树，左叶子之和究竟是多少？

 其实是0，因为这棵树根本没有左叶子！

但看这个图的左叶子之和是多少？

相信通过这两个图，大家对最左叶子的定义有明确理解了。

那么判断当前节点是不是左叶子是无法判断的，必须要通过节点的父节点来判断其左孩子是不是左叶子。

如果该节点的左节点不为空，该节点的左节点的左节点为空，该节点的左节点的右节点为空，则找到了一个左叶子，判断代码如下：

if (root.left != null && root.left.left == null && root.left.right == null) { 
    左叶子节点处理逻辑
}

#递归法

递归的遍历顺序为后序遍历（左右中），是因为要通过递归函数的返回值来累加求取左叶子数值之和。

递归三部曲：

• 1.确定递归函数的参数和返回值

判断一个树的左叶子节点之和，那么一定要传入树的根节点，递归函数的返回值为数值之和，所以为int

使用题目中给出的函数就可以了。

• 2.确定终止条件

如果遍历到空节点，那么左叶子值一定是0

if (root == NULL) return 0;

注意，只有当前遍历的节点是父节点，才能判断其子节点是不是左叶子。 所以如果当前遍历的节点是叶子节点，那其左叶子也必定是0，那么终止条件为：

if (root == NULL) return 0;
if (root->left == NULL && root->right== NULL) return 0; //其实这个也可以不写，如果不写不影响结果，但就会让递归多进行了一层。

• 3.确定单层递归的逻辑

当遇到左叶子节点的时候，记录数值，然后通过递归求取左子树左叶子之和，和 右子树左叶子之和，相加便是整个树的左叶子之和。

代码如下：

int leftValue = sumOfLeftLeaves(root->left);    // 左
if (root->left && !root->left->left && !root->left->right) {
    leftValue = root->left->val;
}
int rightValue = sumOfLeftLeaves(root->right);  // 右

int sum = leftValue + rightValue;               // 中
return sum;

整体递归代码如下：

//有些转不过来，下次在做这道题尝试着跟着卡哥的思路捋一捋
class Solution {
    public int sumOfLeftLeaves(TreeNode root) {
        //对节点进行非空判断
        //2.确定终止条件
        if(root == null){return 0;}
        //3.确定单层循环逻辑
        //左
        int leftVal = sumOfLeftLeaves(root.left);
        //右
        int rightVal = sumOfLeftLeaves(root.right);
        //中
        //确认为左叶子
        int num = 0;
        if (root.left != null && root.left.left == null && root.left.right == null){
            num = root.left.val;
        }
        return num + leftVal + rightVal;
    }
}

总结

这道题目要求左叶子之和，其实是比较绕的，因为不能判断本节点是不是左叶子节点。

此时就要通过节点的父节点来判断其左孩子是不是左叶子了。

平时我们解二叉树的题目时，已经习惯了通过节点的左右孩子判断本节点的属性，而本题我们要通过节点的父节点判断本节点的属性。

---

以上为我做题时候的相关思路，自己的语言组织能力较弱，很多都是直接抄卡哥的，有错误望指正。