代码随想录算法训练营第十八天|LeetCode513、LeetCode112、LeetCode 113、LeetCode106

LeetCode 513

题目：

解法：(层序遍历）

class Solution {
public:
    int findBottomLeftValue(TreeNode* root) {
        queue<TreeNode*> que;
        vector<int> vec;
        if(root != NULL) que.push(root);
        long vi = 0;
        while(!que.empty())
        {
            int size = que.size();
            for(int i = 0; i < size ;i ++){
                TreeNode* node = que.front();
                que.pop();
                if(i == 0) vi = node ->val;
                if(node -> left) que.push(node -> left);
                if(node -> right) que.push(node -> right);
            }
        }
        return vi;
    }
};

解法：（递归）

class Solution {
public:
    int maxDepth = INT_MIN;
    int result;
    void traversal(TreeNode* root, int depth) {
        if (root->left == NULL && root->right == NULL) {
            if (depth > maxDepth) {
                maxDepth = depth;
                result = root->val;
            }
            return;
        }
        if (root->left) {
            traversal(root->left, depth + 1); // 隐藏着回溯
        }
        if (root->right) {
            traversal(root->right, depth + 1); // 隐藏着回溯
        }
        return;
    }
    int findBottomLeftValue(TreeNode* root) {
        traversal(root, 0);
        return result;
    }
};

LeetCode 112

题目：

 解法1：(自己递归）

class Solution {
public:
    void find_target(TreeNode* node,int targetSum,int &is,int sum)
    {
        if(node == NULL) return;
        sum += node -> val;
        if(node -> left == NULL && node ->right == NULL){
            if(sum == targetSum){
                is = 1;
            }
        }
        if(node -> left) find_target(node->left, targetSum, is, sum);
        if(node -> right) find_target(node->right, targetSum, is, sum);
    }
    bool hasPathSum(TreeNode* root, int targetSum) {
        int is = 0;
        int sum = 0;
        find_target(root,targetSum,is,sum);
        if(is == 1) return true;
        else return false;
    }
};

解法2：（官方递归）

class Solution {
public:
    bool find_target(TreeNode* node,int count)
    {
        if(!node -> left && !node -> right && count == 0) return true;
        if(!node -> left && !node -> right) return false;
        if(node -> left){
            if (find_target(node -> left, count - node -> left -> val)){
                return true;
            }
        }  
        if(node -> right) {
            if(find_target(node -> right, count - node -> right -> val))
            return true;
        }
        return false;
    }
    
    bool hasPathSum(TreeNode* root, int targetSum) {
        if(root == NULL) return false;
        return find_target(root,targetSum - root -> val);
    }
};

LeetCode113

题目：

 解法：

class Solution {
public:
    void find_path(TreeNode* node,int sum,vector<int> vec,vector<vector<int>>& result){
            vec.push_back(node -> val);
            if(node -> left == NULL && node ->right == NULL && sum -node -> val == 0 ){
                result.push_back(vec);
                vec.pop_back();
                return;
            }
            if(node -> left == NULL && node ->right == NULL) {
                vec.pop_back();
                return;
            }
            if(node -> left) find_path(node -> left,sum - node -> val,vec,result);
            if(node -> right) find_path(node -> right,sum - node  -> val,vec,result);

    }

    vector<vector<int>> pathSum(TreeNode* root, int targetSum) {
        vector<int> vec;
        vector<vector<int>> result;
        if(root == NULL) {
            return result;
        }
        find_path(root, targetSum, vec, result);
        return result;
    }
};

LeetCode106

 题目：

解法：

class Solution {
public:
    TreeNode* find(vector<int>& inorder, vector<int>& postorder){
        if(postorder.size() == 0) return NULL;
            int headnodevalue = postorder[postorder.size() - 1];
            TreeNode* root = new TreeNode(headnodevalue);
            if(postorder.size() == 1)  return root;
            int determinvalue;
            for(determinvalue = 0 ;determinvalue < inorder.size();determinvalue++){
                if(inorder[determinvalue] == headnodevalue)
                break;
            }
            vector<int> lefthalf(inorder.begin(),inorder.begin() + determinvalue);
            vector<int> righthalf(inorder.begin() + determinvalue + 1,inorder.end());
            postorder.resize(postorder.size() - 1);
            vector<int> lefthalf1(postorder.begin(),postorder.begin() + lefthalf.size());
            vector<int> righthalf1(postorder.begin() + lefthalf.size(),postorder.end());
            root -> left = find(lefthalf,lefthalf1);
            root -> right = find(righthalf,righthalf1);
            return root;
    }
    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
            if(inorder.size() == 0 || postorder.size() == 0)
            return NULL;
            return find(inorder,postorder);
    }
};

LeetCode105

题目：

解法：

class Solution {
public:
    TreeNode* makeTree(vector<int>& preorder, vector<int>& inorder){
        if(preorder.size() == 0) return NULL;
        int value = preorder[0];
        TreeNode* root = new TreeNode(value);
        int determin;
        for(determin = 0; determin < inorder.size();determin++){
            if(inorder[determin] == value) break;
        }
        vector<int> leftin(inorder.begin(),inorder.begin() + determin);
        vector<int> rightin(inorder.begin() + determin + 1,inorder.end());
        preorder.erase(preorder.begin());
        vector<int> leftpre(preorder.begin(),preorder.begin() + leftin.size());
        vector<int> rightpre(preorder.begin() + leftin.size(),preorder.end());
        root -> left = makeTree(leftpre, leftin);
        root -> right = makeTree(rightpre, rightin);
        return root;
    }

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