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

110.平衡二叉树

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

递归三部曲：

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

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

2）终止条件

递归过程中遇到空节点为终止，返回0，即高度为0

3）单层递归逻辑

分别求左右子树的高度，若差值小于等于1，则返回该根节点的高度，否则返回-1。

class Solution {
   /**
     * 递归法
     */
    public boolean isBalanced(TreeNode root) {
        return getHeight(root) != -1;
    }

    private int getHeight(TreeNode root) {
        if (root == null) {
            return 0;
        }
        int leftHeight = getHeight(root.left);
        if (leftHeight == -1) {
            return -1;
        }
        int rightHeight = getHeight(root.right);
        if (rightHeight == -1) {
            return -1;
        }
        // 左右子树高度差大于1，return -1表示已经不是平衡树了
        if (Math.abs(leftHeight - rightHeight) > 1) {
            return -1;
        }
        return Math.max(leftHeight, rightHeight) + 1;
    }
}

257. 二叉树的所有路径

递归三部曲：

1）参数和返回值：

参数：当前传入根节点，每一条路径path（仅存放数字），结果集res；返回值：void无返回值

2）递归终止条件：

遇到叶子节点

3）单层逻辑：

前序遍历，根左右，需要先处理中间节点，记录路径上的节点，放进path中，然后递归+回溯：

把根节点从path里去掉，因为含有根节点的path已经在前面的递归里往下进行了，后面其他的运行就要去掉这个节点去寻找其他的节点了。

class Solution {
    /**
     * 递归法
     */
    public List<String> binaryTreePaths(TreeNode root) {
        List<String> res = new ArrayList<>();// 存最终的结果
        if (root == null) {
            return res;
        }
        List<Integer> paths = new ArrayList<>();// 作为结果中的路径
        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.左叶子之和  

递归三部曲：

1）参数和返回值：

参数：当前节点（根节点）；返回值：这个根节点的左子树的和的数值

2）终止条件：

遍历到空节点/叶子节点（因为叶子节点没有左子树了）

3）单层逻辑：

如果一个节点root，root.left！=null但是root.left.left==null&&root.left.right==null说明左子树存在，存下root.left.val。然后递归求左子树左叶子和右子树左叶子的和。

class Solution {
    
    public int sumOfLeftLeaves(TreeNode root) {
        //终止条件
        if(root==null) return 0;
        if(root.left==null&&root.right==null) return 0;

        int sum = 0;
        
        if(root.left!=null&&root.left.left==null&&root.left.right==null){
            sum = root.left.val;
        }
        

        return sum+sumOfLeftLeaves(root.left)+sumOfLeftLeaves(root.right);

    }
}

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

要充分利用完全二叉树的这个条件，在完全二叉树中，除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。若最底层为第 h 层，则该层包含 1~ 2^(h-1) 个节点。

递归三部曲：

1）参数和返回值：

参数：当前节点（根节点）；返回值：当前节点为根节点的子树的节点数

2）终止条件：

遇到空节点，返回0；

3）单层逻辑：

计算从该节点出发左子树深度和右子树的深度，如果相同，说明这个子树是满二叉树，节点数量为(2 << leftDepth) - 1，返回。递归左子树和右子树计算节点总数。

class Solution {
    /**
     * 针对完全二叉树的解法
     *
     * 满二叉树的结点数为：2^depth - 1
     */
    public int countNodes(TreeNode root) {
        if (root == null) return 0;
        TreeNode left = root.left;
        TreeNode right = root.right;
        int leftDepth = 0, rightDepth = 0; // 这里初始为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;
    }
}