day13 二叉树(递归+回溯)

以下题目均采用递归方法。
确定递归函数以及参数
确定递归终止条件
确定单层递归得逻辑
1.平衡二叉树
平衡二叉树是指一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 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 == nullptr) return 0;
        int left = getHeight(node->left);  //左
        if(left==-1) return -1;
        int right = getHeight(node->right); //右
        if(right==-1) return -1;
        int result = abs(left - right)>1?-1:1+max(left,right); //中
        return result;

    }
    bool isBalanced(TreeNode* root) {
        int result = getHeight(root);
        return result==-1?false:true;
    }
};

2.二叉树的所有路径
思路：递归加回溯。每次遍历到叶子节点收集完一条路径我们需要往回跑去遍历其它的路径。
前序遍历

/**
 * 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*cur,vector<int>& path,vector<string>& result)
    {
        //中
        path.push_back(cur->val);
        //到了叶子节点，收集前面所有路径
        if(cur->left==nullptr&&cur->right==nullptr)
        {
            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(cur->left) 
            {
                traversal(cur->left,path,result);
                path.pop_back();//回溯
            }
             if(cur->right) 
            {
                traversal(cur->right,path,result);
                path.pop_back();//回溯
            }

    }
    vector<string> binaryTreePaths(TreeNode* root) {
        vector<string> result;
        vector<int> path;
        if(root==nullptr) return result;
        traversal(root,path,result);
        return result;

    }
};

3.所有左叶子节点之和
思路：先统计左子树的左叶子节点之和再统计右子树，最后相加。
如何判断是否是左叶子节点？根据叶子节点的父节点判断。

/**
 * 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==nullptr) return 0;
        if(root->left==nullptr&&root->right==nullptr) //叶子节点
        {
            return 0;
        } 
        int leftValue = sumOfLeftLeaves(root->left);//所有左子树得左叶子节点
        if(root->left!=nullptr&&root->left->left==nullptr&&root->left->right==nullptr)
        {
            leftValue = root->left->val;
        }
        int rightValue = sumOfLeftLeaves(root->right);

        int sum = leftValue + rightValue;
        return sum;
    }
};