代码随想录算法Day13|（二叉树part3）110.平衡二叉树、257. 二叉树的所有路径、404.左叶子之和、222.完全二叉树的节点个数

110.平衡二叉树

[257. 二叉树的所有路径](#257. 二叉树的所有路径)

404.左叶子之和

222.完全二叉树的节点个数

110.平衡二叉树

题目链接： https://leetcode.cn/problems/balanced-binary-tree/description/

文章讲解： https://programmercarl.com/0110.%E5%B9%B3%E8%A1%A1%E4%BA%8C%E5%8F%89%E6%A0%91.html

解题分析：

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

求高度是从下到上去查所以需要后序遍历（左右中）。

递归三步曲分析：

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

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

如果当前传入节点为根节点的二叉树已经不是二叉平衡树了，可以返回-1 来标记已经不符合平衡树的规则了。

2.明确终止条件：

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

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

判断以当前传入节点为根节点的二叉树是否是平衡二叉树，看其左子树高度和其右子树高度的差值。如果差值小于等于1，则返回当前二叉树的高度，否则返回-1，表示已经不是二叉平衡树了。

本题代码：

java 复制代码

/**
 * 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 isBalanced(TreeNode root) {
        return getHeight(root) != -1;
    }

    public int getHeight(TreeNode node){
        if(node == null){
            return 0;
        }
        int leftHeight = getHeight(node.left);
        if(leftHeight == -1){
            return -1;
        }
        int rightHeight = getHeight(node.right);
        if(rightHeight == -1){
            return -1;
        }

        // 左右子树高度差大于1，return -1表示已经不是平衡树了
        if(Math.abs(leftHeight - rightHeight) > 1){   
            return -1;
        }
        return 1 + Math.max(leftHeight,rightHeight);
    }
}

257. 二叉树的所有路径

题目链接： https://leetcode.cn/problems/binary-tree-paths/description/

文章讲解： https://programmercarl.com/0257.%E4%BA%8C%E5%8F%89%E6%A0%91%E7%9A%84%E6%89%80%E6%9C%89%E8%B7%AF%E5%BE%84.html

解题分析：

本题要求从根节点到叶子的路径，所以需要前序遍历，这样才方便让父节点指向孩子节点，找到对应的路径；同时本题涉及回溯，因为我们记录一个路径后，需要回溯来回退再进入另一个路径。

采用递归方法:

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

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

java 复制代码

void traversal(TreeNode root, List<Integer> paths, List<String> res)

2.确定递归终止条件:

本题要找到叶子节点就终止，即开始结束的处理逻辑了（把路径放进result里，数值之间用"->"连接，最后将结果转为String类型）

当一节点的左右孩子都为空的时候，该节点为叶子结点

java 复制代码

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

3.确定单层递归逻辑:

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

java 复制代码

paths.add(root.val);    // 前序遍历，中

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

递归完一次，要做回溯，因为新的路径需要删除之前旧路径的节点，回溯和递归是一一对应的，有一个递归，就要有一个回溯，要写在一个花括号里。

java 复制代码

if(root.left != null){
            traversal(root.left,paths,res);
            paths.remove(paths.size()-1);   // 回溯
        }
        if(root.right != null){
            traversal(root.right,paths,res);
            paths.remove(paths.size()-1);   // 回溯
        }

本题代码：

java 复制代码

/**
 * 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<String> binaryTreePaths(TreeNode root) {
        List<String> res = new LinkedList<>();    // 存最终的结果
        if(root == null){
            return res;
        }
        List<Integer> paths = new LinkedList<>(); // 作为结果中的路径
        traversal(root,paths,res);
        return res;
    }

    private void traversal(TreeNode root, List<Integer> paths, List<String> res){
        paths.add(root.val);    // 前序遍历，中
        if(root.left == null && root.right == null){  // 遇到叶子结点
            StringBuilder sb = new StringBuilder();   // StringBuilder用来拼接字符串，速度更快
            for(int i = 0; i < paths.size()-1; i++){
                sb.append(paths.get(i)).append("->");
            }
            sb.append(paths.get(paths.size()-1));    // 记录最后一个节点
            res.add(sb.toString());                  // 收集一个路径
            return;
        }

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

404.左叶子之和

题目链接： https://leetcode.cn/problems/sum-of-left-leaves/description/

文章讲解： https://programmercarl.com/0404.%E5%B7%A6%E5%8F%B6%E5%AD%90%E4%B9%8B%E5%92%8C.html

解题分析：

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

递归三部曲：

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

传入树的根节点，返回值为左叶子节点之和int类型。

2.确定终止条件：

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

java 复制代码

if(root == null){
    return 0;
}

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

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

左叶子结点判断依据：节点A的左孩子不为空，且左孩子的左右孩子都为空，那么A节点的左孩子为左叶子节点。

java 复制代码

(root.left != null && root.left.left == null && root.left.right == null)

本题代码：

java 复制代码

/**
 * 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 int sumOfLeftLeaves(TreeNode root) {
        if(root == null){
            return 0;
        }
        int leftValue = sumOfLeftLeaves(root.left);    // 左
        if(root.left != null && root.left.left == null && root.left.right == null){   // 左子树就是一个左叶子的情况
            leftValue = root.left.val; 
        }
        int rightValue = sumOfLeftLeaves(root.right);  // 右
        int sum = leftValue + rightValue;              // 中
        return sum;
    }
}

222.完全二叉树的节点个数

题目链接： https://leetcode.cn/problems/count-complete-tree-nodes/description/

文章讲解： https://programmercarl.com/0222.%E5%AE%8C%E5%85%A8%E4%BA%8C%E5%8F%89%E6%A0%91%E7%9A%84%E8%8A%82%E7%82%B9%E4%B8%AA%E6%95%B0.html#%E7%AE%97%E6%B3%95%E5%85%AC%E5%BC%80%E8%AF%BE

解题分析：

1.通用递归法

1）确定递归函数的参数和返回值：

参数就是传入树的根节点，返回以该节点为根节点二叉树的节点数量int类型。

2）确定终止条件：

如果为空节点，就返回0，表示节点数为0。

java 复制代码

if(root == null){
    return 0;
}

3）确定单层递归的逻辑：

先求它的左子树的节点数量，再求右子树的节点数量，最后取总和再加1 （加1是因为算上当前中间节点）就是目前节点为根节点的节点数量。

2.完全二叉树法

即完全二叉树分为两种情况：

1）满二叉树：直接用公式：节点数 = 2^树深度 - 1

2）非满二叉树（最后一层叶子结点没有满）：分别递归左孩子，和右孩子，递归到某一深度一定会有左孩子或者右孩子为满二叉树，然后依然可以按照情况1）来计算，如下图所示：

如何判断是不是满二叉树？在完全二叉树中，如果递归向左遍历的深度等于递归向右遍历的深度，那说明就是满二叉树，否则不是。

本题代码：

1.通用递归法

java 复制代码

/**
 * 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 int countNodes(TreeNode root) {
        if(root == null){
            return 0;
        }
        return countNodes(root.left) + countNodes(root.right) + 1;
    }
}

2.完全二叉树法

java 复制代码

/**
 * 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 int countNodes(TreeNode root) {
        if(root == null){
            return 0;
        }
        TreeNode left = root.left;
        TreeNode right = root.right;
        int leftDepth = 0;  // 这里初始为0是有目的的，为了下面求指数方便
        int rightDepth = 0;
        while(left != null){   // 求左子树深度
            left = left.left;
            leftDepth++;
        }
        while(right != null){  // 求右子树深度
            right = right.right;
            rightDepth++;
        }
        if(leftDepth == rightDepth){    
            return (2 << leftDepth) - 1;    // 注意(2<<1) 相当于2^2，所以leftDepth初始为0
        }
        return countNodes(root.left) + countNodes(root.right) + 1;
    }
}