[自我记录]随想录刷题第十六天 | 513.找树左下角的值, 112. 路径总和, 113.路径总和ii, 106.从中序与后序遍历序列构造二叉树, 105.从前序与中序遍历序列构造二叉树

代码随想录算法打卡第十六天, 新手自我记录一下刷题历程, 仅为自我打卡使用.

---

513.找树左下角的值

class Solution {
public:
    int findBottomLeftValue(TreeNode* root) {
        queue<TreeNode*> que;
        int result = 0;
        if (root) que.push(root);

        while (!que.empty()) {
            int size = que.size();
            for (int i = 0; i < size; ++i) {
                TreeNode* 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;
    }
};

---

112. 路径总和

class Solution {
public:
    bool traversal(TreeNode* node, int count) {
        if (node->left == nullptr && node->right == nullptr && count == 0)
            return true;
        else if (node->left == nullptr && node->right == nullptr)
            return false;

        if (node->left) {
            count -= node->left->val;
            if (traversal(node->left, count)) 
                return true;
            count += node->left->val;
        }
        if (node->right) {
            count -= node->right->val;
            if (traversal(node->right, count)) 
                return true;
            count += node->right->val;
        }
        return false;
    }

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

---

113. 路径总和 II

class Solution {
public:
    vector<vector<int>> result;
    void traversal(TreeNode* node, vector<int> path, int count) {
        path.push_back(node->val);
        if (node->left == nullptr && node->right == nullptr && count == 0) {
            result.push_back(path);
            return;
        }
            
        else if (node->left == nullptr && node->right == nullptr)
            return;

        if (node->left) 
            traversal(node->left, path, count - node->left->val);
        if (node->right) 
            traversal(node->right, path, count - node->right->val);
    }

    vector<vector<int>> pathSum(TreeNode* root, int targetSum) {
        vector<int> path;
        result.clear();
        if (!root) return result;
        else
            traversal(root, path, targetSum - root->val);
        return result;
    }
};

---

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

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

        int index = 0;
        for (; index < inorder.size(); ++index) {
            if (inorder[index] == rootValue) 
                break;
        }
        vector<int> leftInorder = vector<int>(inorder.begin(), inorder.begin() + index);
        vector<int> rightInorder = vector<int>(inorder.begin() + index + 1, inorder.end());
        vector<int> leftPostorder = vector<int>(postorder.begin(), postorder.begin() + index);
        vector<int> rightPostorder = vector<int>(postorder.begin() + index, postorder.end() - 1);

        root->left = traversal(leftInorder, leftPostorder);
        root->right = traversal(rightInorder, rightPostorder);
        return root;
    }

    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        return traversal(inorder, postorder);
    }
};

---

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

class Solution {
public:
    TreeNode* traversal(vector<int>& preorder, vector<int>& inorder) {
        if (preorder.size() == 0) return nullptr;
        int rootValue = preorder[0];
        TreeNode* root = new TreeNode(rootValue);
        if (preorder.size() == 1)
            return root;

        int index = 0;
        for (; index < inorder.size(); ++index) {
            if (inorder[index] == rootValue) 
                break;
        }
        vector<int> leftInorder = vector<int>(inorder.begin(), inorder.begin() + index);
        vector<int> rightInorder = vector<int>(inorder.begin() + index + 1, inorder.end());
        vector<int> leftPreorder = vector<int>(preorder.begin() + 1, preorder.begin() + index + 1);
        vector<int> rightPreorder = vector<int>(preorder.begin() + index + 1, preorder.end());

        root->left = traversal(leftPreorder, leftInorder);
        root->right = traversal(rightPreorder, rightInorder);
        return root;
    }

    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        return traversal(preorder, inorder);
    }
};

---

希望明天还能加持一天