代码随想录算法训练营第十八天| 513.找树左下角的值、112. 路径总和 、113.路径总和ii、106.从中序与后序遍历序列构造二叉树、105.从前序与中序遍历序列构造二叉树

513.找树左下角的值

题目链接
文章讲解

递归法

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    void traversal(TreeNode* node, int depth, int& maxDepth, int& rec) {
        if (!node) return;
        if (depth > maxDepth) {
            rec = node-> val;
            maxDepth = depth;
        }
        traversal(node->left, depth + 1, maxDepth, rec);
        traversal(node->right, depth + 1, maxDepth, rec);
    }

    int findBottomLeftValue(TreeNode* root) {
        int maxDepth = 0, ans;
        traversal(root, 1, maxDepth, ans);
        return ans;
    }
};

迭代法

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    int findBottomLeftValue(TreeNode* root) {
        queue<TreeNode*> order;
        TreeNode* node;
        int ans;
        order.push(root);
        while (!order.empty()) {
            int n = order.size();
            for (int i = 0; i < n; i++) { 
                node = order.front(); order.pop();
                if (i == 0) ans = node->val;
                if (node->left) order.push(node->left);
                if (node->right) order.push(node->right);
            }
        }
        return ans;
    }
};

路径总和

文章讲解

112. 路径总和

题目链接

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    bool hasPathSum(TreeNode* root, int targetSum) {
        if (!root) return false;
        targetSum -= root->val;
        if (!root->left && !root->right) return targetSum == 0;
        return hasPathSum(root->left, targetSum) || hasPathSum(root->right, targetSum);
    }
};

113.路径总和ii

题目链接

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    void traversal(TreeNode* node, vector<int> path, vector<vector<int>>& paths, const int& targetSum) {
        path.push_back(node->val);
        if (!node->left && !node->right) {
            int sum = 0;
            for (int i = 0; i < path.size(); i++) sum += path[i];
            if (sum == targetSum) paths.push_back(path);
        }
        if (node->left) traversal(node->left, path, paths, targetSum);
        if (node->right) traversal(node->right, path, paths, targetSum);
    }

    vector<vector<int>> pathSum(TreeNode* root, int targetSum) {
        if (!root) return {};
        vector<vector<int>> ans;
        traversal(root, {}, ans, targetSum);
        return ans;
    }
};

从中序与后序（前序）遍历序列构造二叉树

文章讲解

关键在于切割点

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

题目链接

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    TreeNode* traversal(const vector<int>& inorder, int inBegin, int inEnd, const vector<int>& postorder, int postBegin, int postEnd) {
        if (postBegin == postEnd) return nullptr;
        int rootValue = postorder[postEnd - 1];
        int delimiterIndex = inBegin;
        while (delimiterIndex < inEnd) {
            if (inorder[delimiterIndex] == rootValue)
                break;
            delimiterIndex++;
        }
        TreeNode* root = new TreeNode(rootValue);
        int inLeftBegin = inBegin, inLeftEnd = delimiterIndex;
        int inRightBegin = delimiterIndex + 1, inRightEnd = inEnd;
        int postLeftBegin = postBegin, postLeftEnd = postBegin + inLeftEnd - inLeftBegin;
        int postRightBegin = postLeftEnd, postRightEnd = postEnd - 1;
        root->left = traversal(inorder, inLeftBegin, inLeftEnd, postorder, postLeftBegin, postLeftEnd);
        root->right = traversal(inorder, inRightBegin, inRightEnd, postorder, postRightBegin, postRightEnd);
        return root;
    }

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

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

题目链接

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    TreeNode* traversal(const vector<int>& preorder, int preBegin, int preEnd, const vector<int>& inorder, int inBegin, int inEnd) {
        if (preBegin == preEnd) return nullptr;
        int rootValue = preorder[preBegin];
        int delimiterIndex = inBegin;
        while (delimiterIndex < inEnd) {
            if (inorder[delimiterIndex] == rootValue)
                break;
            delimiterIndex++;
        }
        int leftInBegin = inBegin; int leftInEnd = delimiterIndex;
        int rightInBegin = delimiterIndex + 1; int rightInEnd = inEnd;
        int leftPreBegin = preBegin + 1; int leftPreEnd = preBegin + 1 + leftInEnd - leftInBegin;
        int rightPreBegin = preBegin + 1 + leftInEnd - leftInBegin; int rightPreEnd = preEnd;
        TreeNode* root = new TreeNode(rootValue);
        root->left = traversal(preorder, leftPreBegin, leftPreEnd, inorder, leftInBegin, leftInEnd);
        root->right = traversal(preorder, rightPreBegin, rightPreEnd, inorder, rightInBegin, rightInEnd);
        return root;
    }

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