二叉树零散

110.平衡二叉树
平衡二叉树的概念：左右子树的高度差不超过1，左右子树分别满足这个条件
使用递归三部曲
1.明确递归函数的参数和返回值，这里是节点，返回值是深度；
2.确定终止条件，当节点为空时，返回0（深度为0）；
3.确定运行逻辑，左子树、右子树若不满足平衡二叉树的条件，那么返回-1标记值，若左子树右子树的高度大小差值超过1，那么也返回-1标记不是平衡二叉树；
根据模板可得出：

class Solution {
public:
    int IsBalanced(TreeNode* root){
        if(root==nullptr) return 0;

        int left=IsBalanced(root->left);
        int right=IsBalanced(root->right);

        if(left==-1||right==-1) return -1;
        if(abs(left-right)>1) return -1;

        return max(left,right)+1;
    }
    bool isBalanced(TreeNode* root) {
        if(IsBalanced(root)==-1) return false;
        else return true;
    }
};

这题用迭代法做有很多重复计算；个人觉得应该不会考察这么细；

257.二叉树的所有路径
做递归方法的时候，有点搞蒙了，主要是怎么集成一个string，没想好怎么加”->“ 这个符号，注意我开始做的时候，确定终止条件是节点为空的时候，但是这个时候返回的值是双份的，意思是叶子节点处保留了两份记录，同时如果左子树为空或者右子树为空的时候都会造成一份记录，这个时候怎么办，只能改成是遇到叶子节点的时候，终止，加节点到string上；
1.确定参数与返回值，我使用引用传递，在函数中不断加入string，不用返回值，因此参数需要节点，保存结果的vector -string，以及保留路径的string temp；

class Solution {
public:
    void preOrder(TreeNode* root,vector<string>& res,string temp) {
        if(root->left==nullptr&&root->right==nullptr) {
            temp=temp+"->";
            char c=root->val+'0';
            temp=temp+c;
            res.emplace_back(temp);
            return ;
        }
        if(root->left){
            string s=temp;
            s=s+"->";
            char m=(root->val+'0');
            s=s+m;
            preOrder(root->left,res,s);
        }
        if(root->right){
            string s=temp;
            s=s+"->";
            char m=(root->val+'0');
            s=s+m;
            preOrder(root->right,res,s);
        }
    }
    vector<string> binaryTreePaths(TreeNode* root) {
        vector<string> res;
        preOrder(root->left,res,"");
        preOrder(root->right,res,"");
        for(auto &e:res) {
            char a=root->val+'0';
            e=a+e;
        }
        return res;
    }
};

404.左叶子之和
判断底层在于左叶子，但是迭代过程是不知道自己是不是左叶子的，所以需要在左叶子的父节点来判断，按照这个理解，我认为怎么遍历都可以的，统一格式遍历的后序遍历：

class Solution {
public:
    int sumOfLeftLeaves(TreeNode* root) {
        if(root==nullptr) return 0;
        stack<TreeNode*> q;
        q.push(root);
        int sum=0;
        while(!q.empty()) {
            TreeNode* node=q.top();
            if(node!=nullptr) {
                q.push(nullptr);
                if(node->right) {
                    q.push(node->right);
                }
                if(node->left) {
                    q.push(node->left);
                }
            }else{  
                q.pop();
                TreeNode* w=q.top();
                if(w->left!=nullptr&&w->left->left==nullptr&&w->left->right==nullptr) {
                    sum+=w->left->val;
                }
                q.pop();
            }
        }
        return sum; 
    }

按照递归的话：
第一步，判断递归函数的参数和返回值，只要节点，返回值为返回的int值
第二步，判断终止条件，当节点为空的时候，肯定返回0；
第三步，确定单层逻辑，求的是左子树下左叶子的总和，加上右子树下右叶子的；

class Solution {
public:
    int sumOfLeftLeaves(TreeNode* root) {
        if(root==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);
        return leftValue+rightValue;
    }
};