代码随想录算法训练营第十八天 | LeetCode 513、112、113、106

---

前言

LeetCode题目：LeetCode 513、112、113、106
Takeaway：今天仍然是考察二叉树知识与递归+回溯的结合，回溯和递归的难度更高了。

---

一、513

递推轻松解决，没什么说的，比较轻松。

/**
 * 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;
        int res;
        int depth = 0;
        if(root == NULL){
            return 0;
        }
        que.push(root);
        while(!que.empty()){
            int size = que.size();
            TreeNode* cur;

            for(int i=0;i<size;i++){
                cur = que.front();
                if(i == 0){
                    res = cur->val;
                    //cout<<"res:"<<res<<" i:"<<i<<" size:"<<size<<endl;
                }
                if(cur->left!=NULL){
                    que.push(cur->left);
                }
                if(cur->right!=NULL){
                    que.push(cur->right);
                }
                que.pop();
            }
        }
        return res;
    }
};

---

二、112

递归题，难度不高。

/**
 * 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 hasPathSum(TreeNode* root, int targetSum) {
        if(root == NULL){
            return false;
        }

        if(root->left==NULL && root->right==NULL && targetSum-(root->val)==0){
            return true;
        }
        if(root->left==NULL && root->right==NULL && targetSum-(root->val)!=0){
            return false;
        }

        bool leftSide, rightSide;
        if(root->left!=NULL){
            leftSide = hasPathSum(root->left, targetSum-root->val);
        }
        if(root->right!=NULL){
            rightSide =  hasPathSum(root->right, targetSum-root->val);
        }
        return leftSide||rightSide;   
    }
};

---

三、113

和112思路类似，比112稍微复杂一点，回溯的处理更加明显了。

/**
 * 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:

    vector<vector<int>> ans;
    void path(TreeNode* root, int count, vector<int> curVec){
        if(root == NULL){
            return;
        }

        if(root->left==NULL && root->right==NULL && count-(root->val)==0){
            
            ans.push_back(curVec);
            
            return;
        }

        if(root->left==NULL && root->right==NULL && count-(root->val)!=0){
            return;
        }

        if(root->left!=NULL){
            curVec.push_back(root->left->val);
            path(root->left, count-(root->val), curVec);
            curVec.pop_back();
        }
        if(root->right!=NULL){
            curVec.push_back(root->right->val);
            path(root->right, count-(root->val), curVec);
            curVec.pop_back();
        }
    }

    vector<vector<int>> pathSum(TreeNode* root, int targetSum) {
        vector<int> curVec;
        curVec.clear();
        ans.clear();
        if(root == NULL){
            return ans;
        }
        curVec.push_back(root->val);
        path(root, targetSum, curVec);
        return ans;
    }
};

---

四、106

今天最难的一道题，需要明天再练，要先滤清如何用后序和中序遍历的数组构建树，然后再分步模拟实现。

/**
 * 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* TravelBuild(vector<int>& inorder, vector<int>& postorder){
        if(inorder.size() == 0){
            return NULL;
        }

        int target = postorder[postorder.size()-1];
        TreeNode* root = new TreeNode(target);

        if (postorder.size() == 1) 
            return root;

        int leftIndex;
        for(leftIndex=0; leftIndex<inorder.size(); leftIndex++){
            if(inorder[leftIndex] == target){
                break;
            }
        }

        vector<int> leftInorder(inorder.begin(), inorder.begin()+leftIndex);
        vector<int> rightInorder(inorder.begin()+leftIndex+1, inorder.end());

        postorder.resize(postorder.size()-1);

        vector<int> leftPostorder(postorder.begin(), postorder.begin()+leftInorder.size());
        vector<int> rightPostorder(postorder.begin()+leftInorder.size(), postorder.end());

        root->left = TravelBuild(leftInorder, leftPostorder);
        root->right = TravelBuild(rightInorder, rightPostorder);

        return root;
    }

    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        if(inorder.size()==0||postorder.size()==0){
            return NULL;
        }
        
        return TravelBuild(inorder, postorder);
    }   
};

---

总结

和昨天很类似，今天题主要是递归的每层逻辑变得复杂了，有点绕，其中还夹杂了回溯的思路。