day17二叉树part04 | 110.平衡二叉树 257. 二叉树的所有路径 404.左叶子之和

110.平衡二叉树 （优先掌握递归）

平衡二叉树就是一颗根节点的左右两个子树的高度差绝对值不超过1。
根据这个定义，有必要深刻理解一下高度和深度的定义，以下内容来自代码随想录：
二叉树节点的深度（到地下，也就是到根）：从根节点到该节点的最长简单路径边的条数
二叉树节点的高度（到地上，也就是到叶节点）：从该节点到叶子结点的最长简单路径边的条数

因为求深度可以从上到下去查 所以需要前序遍历（中左右），而高度只能从下到上去查，所以只能后序遍历（左右中）

有的同学一定疑惑，为什么104.二叉树的最大深度中求的是二叉树的最大深度，也用的是后序遍历。
那是因为代码的逻辑其实是求的根节点的高度，而根节点的高度就是这棵树的最大深度，所以才可以使用后序遍历。

class Solution {
public:
    // 1.确定返回值和参数, 返回-1表示已经不平衡了
    int getHeight(TreeNode* node) {
        // 2.确定终止条件，当前节点为根节点，高度为0
        if (node == nullptr) return 0;

        // 3.确定单层的处理逻辑
        // 如何判断以当前传入节点为根节点的二叉树是否是平衡二叉树呢？
        // 当然是其左子树高度和其右子树高度的差值。
        int lheight = getHeight(node->left);
        int rheight = getHeight(node->right);
        
        // 分别求出其左右子树的高度，然后如果差值小于等于1，
        // 则返回当前二叉树的高度，否则返回-1，表示已经不是二叉平衡树了。
        if (lheight == -1)
            return -1;
        if (rheight == -1)
            return -1;
        
        int height;
        // 该树所有节点的左右子树的深度相差不超过 1。
        if (abs(lheight - rheight) <= 1) {
            // 以当前节点为根节点的树的最大高度
            height = max(lheight, rheight) + 1;
        }
        else {
            height = -1;
        } 
        return height;

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

    }
};

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

**257. 二叉树的所有路径 （优先掌握递归） **

class Solution {
public:
    void trival(TreeNode* node, vector<int>&path, vector<string>& result) {
        // 中
        path.push_back(node->val);        

        // 如果是叶子节点，那么就得到了一条符合条件的路径，加入到result中
        if (!node->left && !node->right) {
            // 将vector<int>转成string
            string spath = "";
            for (int i = 0; i < path.size() - 1; i++) {
                spath += to_string(path[i])+"->";
            }
            spath += to_string(path[path.size() - 1]);

            result.push_back(spath);
        }

        // 回溯和递归是一一对应的，有一个递归，就要有一个回溯
        // 左
        if (node->left) {
            trival(node->left, path, result);
            // 回溯
            path.pop_back();
        }
        // 右
        if (node->right) {
            trival(node->right, path, result);
            path.pop_back();
        }

    }
    vector<string> binaryTreePaths(TreeNode* root) {
        vector<int> path;
        vector<string> result;
        trival(root, path, result);
        return result;
    }
};

这是大家第一次接触到回溯的过程， 我在视频里重点讲解了 本题为什么要有回溯，以及回溯的过程。
如果对回溯 似懂非懂，没关系， 可以先有个印象。
题目链接/文章讲解/视频讲解：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

404.左叶子之和 （优先掌握递归）

这题按照自己的思路，就是正常的递归遍历，然后加上查找的代码记录满足条件的val

class Solution {
public:
    // 需要后序遍历，将孩子节点的信息返回到上层
    void getSum(TreeNode* root, int& sum) {
        
        if (root == nullptr) return;

        getSum(root->left, sum);
        getSum(root->right, sum);
        if (root->left && !root->left->left && !root->left->right) {
            sum += root->left->val;
        }
    }
    int sumOfLeftLeaves(TreeNode* root) {
        int sum = 0;
        getSum(root, sum);
        return sum;
    }
};

其实本题有点文字游戏，搞清楚什么是左叶子，剩下的就是二叉树的基本操作。
题目链接/文章讲解/视频讲解：https://programmercarl.com/0404.%E5%B7%A6%E5%8F%B6%E5%AD%90%E4%B9%8B%E5%92%8C.html