算法训练营day18

513.找树左下角的值

层序遍历，不断迭代ans;

class Solution {
public:
    int findBottomLeftValue(TreeNode* root) {
        int ans;
        queue<TreeNode*> q;
        if(root!=NULL) q.push(root);
        while(q.size()){
            int size=q.size();
            for(int i=0;i<size;i++){
                auto t=q.front();
                q.pop();
                if(i==0){
                    ans=t->val;
                }
                if(t->left) q.push(t->left);
                if(t->right) q.push(t->right);
            }
        }
        return ans;
    }
};

112. 路径总和

中左右递归遍历；

只要下面re回来true，就一路re上去；re回来false，就恢复现场；

public:

    bool dfs(TreeNode *t,int sum,int targetSum){
        if(t->left==NULL&&t->right==NULL){
            if(sum==targetSum) return true;
            else return false;
        }
        
        if(t->left){
            sum+=t->left->val;
            if(dfs(t->left,sum,targetSum)) return true;
            sum-=t->left->val;
        }
         if(t->right){
            sum+=t->right->val;
            if(dfs(t->right,sum,targetSum)) return true;
            sum-=t->right->val;
        }  
        return false;     
    }

    bool hasPathSum(TreeNode* root, int targetSum) {
        if(root==nullptr) return false;
        return dfs(root,root->val,targetSum);
    }
};

113.路径总和ii

path纪录路径，ans记录答案；

递归与回溯的时候加上对点的处理；

class Solution {
private:
    vector<vector<int>> ans;
    vector<int> path;
public:

    void dfs(TreeNode *t,int cnt){
        if(t->left==NULL&&t->right==NULL){
            if(cnt==0) ans.push_back(path);
            return;
        }
        
        if(t->left){
            cnt-=t->left->val;
            path.push_back(t->left->val);
            dfs(t->left,cnt);
            cnt+=t->left->val;
            path.pop_back();
        }
        if(t->right){
            cnt-=t->right->val;
            path.push_back(t->right->val);
            dfs(t->right,cnt);
            cnt+=t->right->val;
            path.pop_back();
        }
        return;
    }
    vector<vector<int>> pathSum(TreeNode* root, int targetSum) {
        ans.clear();
        path.clear();
        if(root==NULL) return ans;
        path.push_back(root->val);
        dfs(root,targetSum-root->val);
        return ans;
    }
};

106.从中序与后序遍历序列构造二叉树

后序最后一个是中间节点；在中序中找到这个节点，左边是左子树，右边是右子树；

class Solution {
public:
    TreeNode* travelsal(vector<int>& inorder, vector<int>& postorder) {
        if(postorder.size()==0) return NULL;

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

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

        vector<int> l_inorder(inorder.begin(),inorder.begin()+inorder_root);
        vector<int> r_inorder(inorder.begin()+inorder_root+1,inorder.end());
        postorder.resize(postorder.size() - 1);
        vector<int> l_postorder(postorder.begin(),postorder.begin()+l_inorder.size());
        vector<int> r_postorder(postorder.begin()+l_inorder.size(),postorder.end());

        root->left=travelsal(l_inorder,l_postorder);
        root->right=travelsal(r_inorder,r_postorder);

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

105.从前序与中序遍历序列构造二叉树

跟上题思路一样，这里注意，参数加上索引；

class Solution {
private:
        TreeNode* traversal (vector<int>& inorder, int inorderBegin, int inorderEnd, vector<int>& preorder, int preorderBegin, int preorderEnd) {
        if (preorderBegin == preorderEnd) return NULL;

        int rootValue = preorder[preorderBegin]; // 注意用preorderBegin 不要用0
        TreeNode* root = new TreeNode(rootValue);

        if (preorderEnd - preorderBegin == 1) return root;

        int delimiterIndex;
        for (delimiterIndex = inorderBegin; delimiterIndex < inorderEnd; delimiterIndex++) {
            if (inorder[delimiterIndex] == rootValue) break;
        }
        // 切割中序数组
        // 中序左区间，左闭右开[leftInorderBegin, leftInorderEnd)
        int leftInorderBegin = inorderBegin;
        int leftInorderEnd = delimiterIndex;
        // 中序右区间，左闭右开[rightInorderBegin, rightInorderEnd)
        int rightInorderBegin = delimiterIndex + 1;
        int rightInorderEnd = inorderEnd;

        // 切割前序数组
        // 前序左区间，左闭右开[leftPreorderBegin, leftPreorderEnd)
        int leftPreorderBegin =  preorderBegin + 1;
        int leftPreorderEnd = preorderBegin + 1 + delimiterIndex - inorderBegin; // 终止位置是起始位置加上中序左区间的大小size
        // 前序右区间, 左闭右开[rightPreorderBegin, rightPreorderEnd)
        int rightPreorderBegin = preorderBegin + 1 + (delimiterIndex - inorderBegin);
        int rightPreorderEnd = preorderEnd;

        root->left = traversal(inorder, leftInorderBegin, leftInorderEnd,  preorder, leftPreorderBegin, leftPreorderEnd);
        root->right = traversal(inorder, rightInorderBegin, rightInorderEnd, preorder, rightPreorderBegin, rightPreorderEnd);

        return root;
    }

public:
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        if (inorder.size() == 0 || preorder.size() == 0) return NULL;

        // 参数坚持左闭右开的原则
        return traversal(inorder, 0, inorder.size(), preorder, 0, preorder.size());
    }
};