算法记录Day 18 | 二叉树 part05

算法记录Day 18 | 二叉树 part05

LeetCode 513.找树左下角的值

题目链接：leetcode.cn/problems/de…

题解

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

LeetCode 112. 路径总和

题目链接：leetcode.cn/problems/pa…

题解

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

LeetCode 113. 路径总和ii

题目链接：113. 路径总和 II

题解

class Solution {
   public:
    vector<vector<int>> res;
    vector<vector<int>> pathSum(TreeNode* root, int targetSum) {
        vector<int> path;
        dfs(root, path, targetSum);
        return res;
    }
    void dfs(TreeNode* root, vector<int>& path, int sum) {
        if (root == nullptr) return;
        sum -= root->val;
        path.push_back(root->val);
        if (!root->left && !root->right && sum == 0) {
            res.push_back(path);
        }
        dfs(root->left, path, sum);
        dfs(root->right, path, sum);
        path.pop_back();
        return;
    }
};

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

题目链接：106. 从中序与后序遍历序列构造二叉树

题解

class Solution {
   public:
    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        TreeNode* root = build(inorder, 0, inorder.size() - 1, postorder, 0,
                               postorder.size() - 1);
        return root;
    }
    TreeNode* build(vector<int>& inorder, int inStart, int inEnd,
                    vector<int>& postorder, int postStart, int postEnd) {
        if (inStart > inEnd) {
            return nullptr;
        }
        int rootVal = postorder[postEnd];
        int index = 0;
        for (int i = inStart; i <= inEnd; i++) {
            if (inorder[i] == rootVal) {
                index = i;
                break;
            }
        }

        int leftSize = index - inStart;
        TreeNode* root = new TreeNode(rootVal);
        root->left = build(inorder, inStart, index - 1, postorder, postStart,
                           postStart + leftSize - 1);
        root->right = build(inorder, index + 1, inEnd, postorder,
                            postStart + leftSize, postEnd - 1);
        return root;
    }
};

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

题目链接：105. 从前序与中序遍历序列构造二叉树

题解

class Solution {
   public:
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        TreeNode* root = build(preorder, 0, preorder.size() - 1, inorder, 0,
                               inorder.size() - 1);
        return root;
    }

    TreeNode* build(vector<int>& preorder, int preStart, int preEnd,
                    vector<int>& inorder, int inStart, int inEnd) {
        if (preStart > preEnd) {
            return nullptr;
        }
        int rootVal = preorder[preStart];
        int index = 0;
        for (int i = inStart; i <= inEnd; i++) {
            if (inorder[i] == rootVal) {
                index = i;
                break;
            }
        }
        int leftSize = index - inStart;
        TreeNode* root = new TreeNode(rootVal);
        root->left = build(preorder, preStart + 1, preStart + leftSize, inorder,
                           inStart, index - 1);
        root->right = build(preorder, preStart + leftSize + 1, preEnd, inorder,
                            index + 1, inEnd);
        return root;
    }
};