DAY17 平衡二叉树 二叉树的所有路径 左叶子之和

110.平衡二叉树

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

本题中，一棵高度平衡二叉树定义为：一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过1。

示例 1:

给定二叉树 [3,9,20,null,null,15,7]

返回 true 

 这题如果用递归的话，使用后序遍历，求出二叉树的高度才行，如果高度差大于1，返回-1即可，最后看返回的数是啥就行。

class Solution {
public:
    int blanced(TreeNode* root)
    {
        if(root==NULL)return 0;
        int left=blanced(root->left);
        if(left==-1)return -1;
        int right=blanced(root->right);
        if(right==-1)return -1;
        int res;
        if(abs(left-right)>1)res=-1;
        else
        res=1+max(left,right);
        return res;
    }
    bool isBalanced(TreeNode* root) {
        int res=blanced(root);
        if(res==-1)return 0;
        else 
        return 1;
    }
};

用迭代方法的话，看左右字数的高度差就行，深度用层序遍历，然后遍历每个结点就行：

class Solution {
public:
    int maxDepth(TreeNode* root) {
      queue<TreeNode*> qu;
            int size=0;
            int depth=0;
            if(root!=NULL)qu.push(root);
            while(!qu.empty())
            {
                size=qu.size();
               for(int i=0;i<size;i++)
                {   auto tempnode=qu.front();
                    qu.pop();
                    if(tempnode->left)qu.push(tempnode->left);
                    if(tempnode->right)qu.push(tempnode->right);
                }
                depth++;
            }
            return depth;
    }
    bool isBalanced(TreeNode* root) {
        stack<TreeNode*> st;
        if(root==NULL)return 1;
        st.push(root);
        while(!st.empty())
        {
               auto tempnode=st.top();
               st.pop();
               if(tempnode!=NULL)
               {
                   if(abs(maxDepth(tempnode->left)-maxDepth(tempnode->right))>1)return 0;
               }
               else
                   continue;
                    if(tempnode->left)st.push(tempnode->right);
                    if(tempnode->right)st.push(tempnode->left);
        }
        return 1;
    
    }
};

257. 二叉树的所有路径

给定一个二叉树，返回所有从根节点到叶子节点的路径。

说明: 叶子节点是指没有子节点的节点。

示例:

 这是我第一次遇到“回溯”，这题使用递归＋回溯的方法即可

class Solution {
public:
    void path(TreeNode* root,vector<int>& res,vector<string>& result)
    {    if(root==NULL)return;
        res.push_back(root->val);
        if(root->left==NULL&&root->right==NULL)
        {   string path1;
            for(int i=0;i<res.size();i++)
            {path1+=to_string(res[i]);
            if(i<res.size()-1)
             path1+="->";
            }
            result.push_back(path1);
            return;}
         if(root->left){path(root->left,res,result);res.pop_back();}
         if(root->right){path(root->right,res,result);res.pop_back();}
    }


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

 两个栈做法，一个栈负责遍历，另外一个栈在遍历的过程中保存路径就行：

class Solution {
public:
    vector<string> binaryTreePaths(TreeNode* root) {
          stack<TreeNode*> treest;
          stack<string> pathst;
          vector<string> res;
         if(root==NULL)return res;
           treest.push(root);
           pathst.push(to_string(root->val));
           while(!treest.empty())
           {
               auto node=treest.top(); treest.pop();
               string path=pathst.top();pathst.pop();
               if(node->left==NULL&&node->right==NULL)
               {
                   res.push_back(path);
               }
               if(node->left)
               {
                   treest.push(node->left);
                   pathst.push(path+"->"+to_string(node->left->val));
               }
                 if(node->right)
               {
                   treest.push(node->right);
                   pathst.push(path+"->"+to_string(node->right->val));
               }

           }
               return res;
    }
};

404.左叶子之和

计算给定二叉树的所有左叶子之和。

示例：

这个题最需要注意的地方是，左叶子的判定条件，有了这个条件，无论是递归还是遍历都可以做出这道题

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

class Solution {
public:
    int sumOfLeftLeaves(TreeNode* root) {
              queue<TreeNode* > qu;
              int size=0;
              int sum=0;
              if(root==NULL)return 0;
              qu.push(root);
              while(!qu.empty())
              {
                  size=qu.size();
                  while(size--)
                  {
                      auto node=qu.front();
                      qu.pop();
                      if(node->left&&node->left->left==NULL&&node->left->right==NULL)
                      sum+=node->left->val;
                      if(node->left)qu.push(node->left);
                      if(node->right)qu.push(node->right);
                  }
              }
       return sum;
    }
};

class Solution {
public:
    int sum(TreeNode* root)
    {   if(root==NULL)return 0;
        if(root->left==NULL&&root->right==NULL)return 0;
        int left=sum(root->left);
        if(root->left&&root->left->left==NULL&&root->left->right==NULL)
        left=root->left->val;
        int right=sum(root->right);
        int sum=right+left;
        return sum;
    }
    int sumOfLeftLeaves(TreeNode* root) {
              return sum(root);
    }
};

一入递归深似海，shift