day17第六章二叉树（二刷）

今日任务

• 110.平衡二叉树
• 257.二又树的所有路径
• 404.左叶子之和

💡 递归法优先，有精力的时候再去掌握迭代法。

---

110.平衡二叉树

题目链接：

https://leetcode.cn/problems/balanced-binary-tree/description/

题目描述：

给定一个二叉树，判断它是否是高度平衡的二叉树。

本题中，一棵高度平衡二叉树定义为：

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

示例 1：

输入：root = [3,9,20,null,null,15,7]
输出：true

示例 2：

输入：root = [1,2,2,3,3,null,null,4,4]
输出：false

示例 3：

输入：root = []
输出：true

提示：

• 树中的节点数在范围 [0, 5000] 内
• 104 <= Node.val <= 104

题解代码：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
//二刷：递归法，后序遍历
    int getHeight(TreeNode* node){
        int res = 0;
        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;
        }

        if(abs(leftHeight-rightHeight) >  1){
            return -1;
        }
        else{
            res = 1+max(leftHeight,rightHeight);
        }
        return res;
    }
    bool isBalanced(TreeNode* root){
        int height = getHeight(root);
        if(height == -1){
            return false;
        }
        return true;
    }

//一刷：递归法，后序遍历
/*
    int getHeight(TreeNode* node){
        //使用后序遍历 的方式 ：左右根
        if(node == NULL){
            return 0;
        }

        //处理左
        int leftHeight = getHeight(node->left);
        if(leftHeight == -1){ //如果左子树已经不是平衡二叉树了，返回-1
            return -1;
        }

        //处理右
        int rightHeight = getHeight(node->right);
        if(rightHeight == -1){//如果右子树已经不是平衡二叉树了，返回-1
            return -1;
        }

        //处理根
        int res;
        if(abs(leftHeight-rightHeight) > 1){
            return -1;
        }
        else{
            res = 1+max(leftHeight,rightHeight);
        }

        return res;

    }

    bool isBalanced(TreeNode* root) {
        int result = getHeight(root);
        if(result == -1){
            return false;
        }
        else{
            return true;
        }
    }
    */
};

---

257.二又树的所有路径

题目链接：

https://leetcode.cn/problems/binary-tree-paths/description/

题目描述：

给你一个二叉树的根节点 root ，按 任意顺序 ，返回所有从根节点到叶子节点的路径。

叶子节点 是指没有子节点的节点。

示例 1：

输入：root = [1,2,3,null,5]
输出：["1->2->5","1->3"]

示例 2：

输入：root = [1]
输出：["1"]

提示：

• 树中节点的数目在范围 [1, 100] 内
• 100 <= Node.val <= 100

题解代码：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    //递归法 前序遍历
    void traversal(TreeNode* node, vector<int>& path, vector<string>& res){
        //使用前序
        //处理根
        path.push_back(node->val);

        if(node->left == NULL && node->right == NULL){
            string sPath;
            for(int i = 0; i < path.size()-1; i++){
                sPath += to_string(path[i]);
                sPath += "->";
            }
            sPath += to_string(path[path.size()-1]);
            res.push_back(sPath);
            return;
        }

        //处理左
        if(node->left != NULL){
            traversal(node->left,path,res);
            path.pop_back(); //回溯
        }

        //处理右
        if(node->right != NULL){
            traversal(node->right, path,res);
            path.pop_back(); //回溯
        }
    }

    vector<string> binaryTreePaths(TreeNode* root) {
        //存放当前路径
        vector<int> path;
        //存放最后要返回的结果
        vector<string> res;

        if(root == NULL){
            return res;
        }
        traversal(root, path,res);

        return res;
    }
};

---

404.左叶子之和

题目链接：

https://leetcode.cn/problems/sum-of-left-leaves/description/

题目描述：

给定二叉树的根节点 root ，返回所有左叶子之和。

示例 1：

输入: root = [3,9,20,null,null,15,7]
输出: 24
解释: 在这个二叉树中，有两个左叶子，分别是 9 和 15，所以返回 24

示例 2:

输入: root = [1]
输出: 0

提示:

• 节点数在 [1, 1000] 范围内
• 1000 <= Node.val <= 1000

题解代码：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    int sumOfLeftLeaves(TreeNode* root){
        if(root == NULL){
            return 0;
        }
        if(root->left==NULL && root->right==NULL){
            return 0;
        }
        int leftNum = sumOfLeftLeaves(root->left);
        if(root->left!=NULL && root->left->left==NULL && root->left->right==NULL){
            leftNum = root->left->val;
        }
        int rightNum = sumOfLeftLeaves(root->right);
        int sum = leftNum+rightNum;
        return sum;
    }
//一刷：递归法
/*
    int sumOfLeftLeaves(TreeNode* root) {
        if(root == NULL){
            return 0;
        }
        if(root->left == NULL && root->right ==NULL){ //如果遇到叶子结点
            return 0;
        }

        int leftNum = sumOfLeftLeaves(root->left);
        if(root->left != NULL && root->left->left == NULL && root->left->right == NULL){
            leftNum = root->left->val;
        }
        int rightNum = sumOfLeftLeaves(root->right);
        
        int sum = leftNum+rightNum;

        return sum;

    }
    */
};

---

总结

💡 求二叉树深度 和 二叉树高度的差异，求深度适合用前序遍历，而求高度适合用后序遍历。

💡 **回溯和递归都是相伴相生的。**

💡 **回溯和递归是一一对应的，有一个递归，就要有一个回溯**

递归三部曲

1. 递归函数函数参数以及返回值
2. 确定递归终止条件
3. 确定单层递归逻辑