代码随想录训练营day18|513.找树左下角的值● 112. 路径总和 113.路径总和ii● 106.从中序与后序遍历序列构造二叉树 105.从前序与中序遍历序列构造二叉树

513. 找树左下角的值 - 力扣（LeetCode）

513. 找树左下角的值 - 力扣（LeetCode）

/**
 * 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 findBottomLeftValue(TreeNode* root) {
     queue<TreeNode*> que;
     if(root!=NULL)
     que.push(root);
     int result;
     while(!que.empty())
     {
         int size=que.size();
         TreeNode* node;
         for(int i=0;i<size;i++)
         {
             node=que.front();
             que.pop();
             if(i==0)
             result=node->val;
             if(node->left)
             que.push(node->left);
             if(node->right)
             que.push(node->right);
         }
     }
     return result;
    }
};

/**
 * 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 maxDepth=INT_MIN;
    int result;
    void traversal(TreeNode* node,int depth)
    {
        if(node->left==NULL&&node->right==NULL)
        {
            if(depth>maxDepth)
            {
                maxDepth=depth;
                result=node->val;
            }
            return;
        }
        if(node->left)
        {
            depth++;
            traversal(node->left,depth);
            depth--;
        }
        if(node->right)
        {
            depth++;
            traversal(node->right,depth);
            depth--;
        }
        return;
    }
    int findBottomLeftValue(TreeNode* root) {
        traversal(root,0);
        return result;
    }
};

112. 路径总和 - 力扣（LeetCode）

拿不准的遍历顺序，搞不清的回溯过程，我太难了！ | LeetCode：112. 路径总和_哔哩哔哩_bilibili

/**
 * 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:
    bool teaversal(TreeNode* node,int count)
    {
        if(node->left==NULL&&node->right==NULL&&count==0)
        return true;
        if(node->left==NULL&&node->right==NULL&&count!=0)
        return false;
        if(node->left)
        {
            if(teaversal(node->left,count-node->left->val))
            return true;
        }
        if(node->right)
        {
            if(teaversal(node->right,count-node->right->val))
            return true;
        }
        return false;
        
    }
    bool hasPathSum(TreeNode* root, int targetSum) {
       if(root==NULL)
       return false;
       return teaversal(root,targetSum-root->val);
    }
};

106. 从中序与后序遍历序列构造二叉树 - 力扣（LeetCode）

坑很多！来看看你掉过几次坑 | LeetCode：106.从中序与后序遍历序列构造二叉树_哔哩哔哩_bilibili

/**
 * 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:
   TreeNode* traversal(vector<int>& inorder, vector<int>& postorder)
   {
       if(postorder.size()==0)
       return NULL;
       int rootvalue=postorder[postorder.size()-1];
       TreeNode* root=new TreeNode(rootvalue);
       int index=0;
       if(postorder.size()==1)
       return root;
       for(index=0;index<inorder.size();index++)
       {
           if(inorder[index]==rootvalue)
           break;
       }
       vector<int> leftinorder(inorder.begin(),inorder.begin()+index);
       vector<int> rightinorder(inorder.begin()+index+1,inorder.end());
       postorder.resize(postorder.size()-1);

       vector<int> ledtpostorder(postorder.begin(),postorder.begin()+leftinorder.size());//左闭右开原则       vector<int> rightpostorder(postorder.begin()+leftinorder.size(),postorder.end());
       root->left=traversal(leftinorder,ledtpostorder);
       root->right=traversal(rightinorder,rightpostorder);
       return root;
   }
    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        if(inorder.size()==0||postorder.size()==0)
        return NULL;
        return traversal(inorder,postorder);
    }
};