【力扣一刷】代码随想录day17 ( 110.平衡二叉树、257. 二叉树的所有路径、404.左叶子之和 ）

目录

【110.平衡二叉树】 

方法  递归 - 后序遍历（求高度差）

【257. 二叉树的所有路径】

方法  递归 - 前序遍历

【404.左叶子之和】

方法  递归 - 后序遍历

---

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

方法  递归 - 后序遍历（求高度差）

思路：设置res的初始值为true，递归获取每个节点的最大高度，在单层递归中，获取左右节点的高度差，如果不符合平衡二叉树的条件，则设置res为false，即当所有节点都满足平衡二叉树的条件时，res保持true。

/**
 * 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 {
    boolean res = true;
    public boolean isBalanced(TreeNode root) {
        // 后序遍历，获取左右节点的最大高度，获取高度差，大于1则不平衡
        getHeight(root);
        return res;
    }

    // 1、确定参数和返回值
    public int getHeight (TreeNode root){
        // 2、确定终止条件
        if (root == null) return 0;

        // 3、确定单层递归逻辑：左右中，获取左节点和右节点的高度，计算高度差
        int leftHeight = getHeight(root.left);
        int rightHeight = getHeight(root.right);
        if (Math.abs(leftHeight - rightHeight) > 1) res = false;
        return Math.max(leftHeight, rightHeight) + 1;
    }
}

---

【257. 二叉树的所有路径】

方法  递归 - 前序遍历

思路：从根节点开始到叶子节点的路径，必须前序遍历（先访问中节点，再访问左右节点），如果遇到叶子节点，就将字符串add入路径集合paths中

1、确定参数和返回值。

• 目的是更新当前节点所在路径和存储所有路径。
• 因此，输入参数要传入当前节点和到达该节点前的路径，所有路径存储在成员变量中，不需要返回值

2、确定终止条件

• 如果节点为null，直接return返回

3、确定单层递归逻辑

• A. 更新到达当前节点后的路径
• B. 如果当前节点为叶子节点，则将路径存入paths中(注意：要删掉最后一个 ->）
• C. 继续访问左右节点

/**
 * 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 {
    List<String> paths = new ArrayList<>();
    public List<String> binaryTreePaths(TreeNode root) {
        // 从根节点开始到叶子节点的路径，必须前序遍历，如果遇到叶子节点，就将字符串add入路径集合paths中
        getPath(root, "");
        return paths;
    }

    // 1、确定参数和返回值，目的是更新当前节点所在路径和存储所有路径
    // 因此，输入参数要传入当前节点和到达该节点前的路径，所有路径存储在成员变量中，不需要返回值
    public void getPath(TreeNode root, String path){
        // 2、确定终止条件
        if (root == null) return;
        
        // 3、确定单层递归逻辑
        // A. 更新到达当前节点后的路径
        path = path + Integer.toString(root.val) + "->";
        
        // B. 如果当前节点为叶子节点，则将路径存入路径集合paths中(注意：要删掉最后一个 ->)
        if (root.left == null && root.right == null) paths.add(path.substring(0, path.length() - 2));
        
        // C. 继续访问左右节点
        getPath(root.left, path);
        getPath(root.right, path);
    }
}

---

【404.左叶子之和】

方法  递归 - 后序遍历

思路：

1、确定参数和返回值：

• 参数传入当前节点，返回当前节点包含的所有左叶子之和

2、确定终止条件：

• 如果节点为null，则返回0

3、确定单层递归逻辑：

• 如果包含左叶子节点，则返回左叶子节点的val + 右子树所有左叶子节点的和
• 如果不包含左叶子节点，则获取左右子树的所有左叶子节点之和

/**
 * 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 {
    // 后序遍历，先获取左右子树所有左叶子的和，作为当前节点所有左叶子的和
    // 1、确定参数和返回值，参数传入当前节点，返回当前节点包含的所有左叶子之和
    public int sumOfLeftLeaves(TreeNode root) {
        // 2、确定终止条件
        if (root == null) return 0;

        // 3、确定单层递归逻辑：
        // 如果包含左叶子节点，则返回左叶子节点的val
        if (root.left != null && (root.left.left == null && root.left.right == null)){
            return root.left.val + sumOfLeftLeaves(root.right);
        }
        // 如果不包含左叶子节点，则获取左右子树的所有左叶子节点之和
        else {
            return sumOfLeftLeaves(root.left) + sumOfLeftLeaves(root.right);
        }
    }
}