代码随想录算法训练营第十七天|110. 平衡二叉树、257. 二叉树的所有路径、404. 左叶子之和

Leetcode 110. 平衡二叉树
思路：采用后序遍历，因为我们需要记录左右子树的高度，一旦发现左右子树高度差大于1，返回-1

/**
 * 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){
        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; 
        return abs(leftHeight - rightHeight) > 1 ? -1 : 1+max(leftHeight,rightHeight); //左右子树高度差大于1 不是平衡二叉树
    }
    bool isBalanced(TreeNode* root) {
        return getHeight(root)==-1 ? false : true;
    }
};

Leetcode 257. 二叉树的所有路径
思路：采用前序遍历，因为我们需要保存遍历的路径，还需要回溯。遍历逻辑有一点不一样，我们遇到叶子节点就将当前节点添加到路径中，然后停止遍历，注意每一次遍历都需要回溯，回溯到父节点然后继续遍历

/**
 * 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> &result){ //path存放遍历路径 result记录结果
    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]);
        result.push_back(sPath);
    }
    if(node->left){
        traversal(node->left, path, result); //左
        path.pop_back(); //回溯
    }
    if(node->right){
        traversal(node->right, path, result); //右
        path.pop_back(); //回溯
    }
    return ;
    }
    vector<string> binaryTreePaths(TreeNode* root) {
        vector<int> path;
        vector<string> result;
        traversal(root, path, result);
        return result;
    }
};

Leetcode 404. 左叶子之和
思路：采用后序遍历，因为要通过递归来累加左叶子的值。左叶子为叶子节点且为父节点的左孩子，遍历到叶子节点时，我们并不能知道是左叶子还是右叶子，只能通过父节点来判断。

/**
 * 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 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;
    }
};