代码随想录算法训练营第十八天|二叉树

513. 找树左下角的值

class Solution {
public:
    int maxLen = INT_MIN;
    int result;
    void backtracking(TreeNode* root, int len) {
        if (root->left == nullptr && root->right == nullptr) {
            if (len > maxLen) {
                maxLen = len;
                result = root->val;
            }
        }
        if (root->left) {
            len++;
            backtracking(root->left, len);
            len--;
        }
        if (root->right) {
            len++;
            backtracking(root->right, len);
            len--;
        }
    }
    int findBottomLeftValue(TreeNode* root) {
        if (root == nullptr) return 0;
        int len = 0;
        backtracking(root, len);
        return result;
    }
};

112. 路径总和

class Solution {
public:
    bool result = false;
    void backtracking(TreeNode* root, int cursum, int targetSum) {
        if (root->left == nullptr && root->right == nullptr) {
            if (cursum == targetSum) {
                result = true;
            }
            return;
        }
        if (root->left) {
            cursum += root->left->val;
            backtracking(root->left, cursum, targetSum);
            cursum -= root->left->val;
        }
        if (root->right) {
            cursum += root->right->val;
            backtracking(root->right, cursum, targetSum);
            cursum -= root->right->val;
        }
    }
    bool hasPathSum(TreeNode* root, int targetSum) {
        if (root == nullptr) return false;
        int cursum = root->val;
        backtracking(root, cursum, targetSum);
        return result;
    }
};

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

class Solution {
public:
    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        if (inorder.empty()) return nullptr;
        int len = postorder.size();
        int rootVal = postorder[len - 1];
        TreeNode* root = new TreeNode(rootVal);

        if (len == 1) return root;
        int newLeftlen, newRightlen = 1;
        for (int i = 0; i < inorder.size(); ++i) {
            if (inorder[i] != rootVal) {
                newLeftlen++;
            }
            else {
                break;
            }
        }
        newRightlen = inorder.size() - newLeftlen - 1;
        vector<int> newLeftInorder(inorder.begin(), inorder.begin() + newLeftlen);
        vector<int> newRightInorder(inorder.begin() + newLeftlen + 1, inorder.end());
        vector<int> newLeftPostorder(postorder.begin(), postorder.begin() + newLeftlen);
        vector<int> newRightPostorder(postorder.begin() + newLeftlen, postorder.end() - 1);
        root->left = buildTree(newLeftInorder, newLeftPostorder);
        root->right = buildTree(newRightInorder, newRightPostorder);
        return root;
    }
};class Solution {
public:
    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        if (inorder.empty()) return nullptr;
        int len = postorder.size();
        int rootVal = postorder[len - 1];
        TreeNode* root = new TreeNode(rootVal);

        if (len == 1) return root;
        int newLeftlen, newRightlen = 1;
        for (int i = 0; i < inorder.size(); ++i) {
            if (inorder[i] != rootVal) {
                newLeftlen++;
            }
            else {
                break;
            }
        }
        newRightlen = inorder.size() - newLeftlen - 1;
        vector<int> newLeftInorder(inorder.begin(), inorder.begin() + newLeftlen);
        vector<int> newRightInorder(inorder.begin() + newLeftlen + 1, inorder.end());
        vector<int> newLeftPostorder(postorder.begin(), postorder.begin() + newLeftlen);
        vector<int> newRightPostorder(postorder.begin() + newLeftlen, postorder.end() - 1);
        root->left = buildTree(newLeftInorder, newLeftPostorder);
        root->right = buildTree(newRightInorder, newRightPostorder);
        return root;
    }
};

今天的内容包含了一些语法知识