代码随想录算法训练营第十八天 | 513. 找树左下角的值、112. 路径总和、113. 路径总和 II

513. 找树左下角的值

迭代法，层序遍历，记录每层第一个值

class Solution {
public:
    int findBottomLeftValue(TreeNode* root) {
        deque<TreeNode*> que;
        if (root) que.emplace_back(root);
        int ans = 0;
        while (!que.empty()) {
            int size = que.size();
            for (int i = 0; i < size; i++) {
                TreeNode* cur = que.front();
                que.pop_front();
                if (i == 0) ans = cur->val;
                if (cur->left) que.emplace_back(cur->left);
                if (cur->right) que.emplace_back(cur->right);
            }
        }
        return ans;
    }
};

递归，维护两个全局变量，前序遍历，如果当前深度大于最大深度，则改变ans

class Solution:
    def findBottomLeftValue(self, root: Optional[TreeNode]) -> int:
        max_depth = 0
        ans = 0
        def dfs(node, depth):
            if not (node.left or node.right):
                nonlocal max_depth, ans
                if (depth > max_depth):
                    max_depth = depth
                    ans = node.val
                return 
            if node.left:
                dfs(node.left, depth + 1)
            if node.right:
                dfs(node.right, depth + 1)
            return
        dfs(root, 1)
        return ans

112. 路径总和

class Solution:
    def hasPathSum(self, root: Optional[TreeNode], targetSum: int) -> bool:
        if not root:
            return False
        def dfs(node, path_sum):
            path_sum += node.val
            if not node.left and not node.right:
                if path_sum == targetSum:
                    return True
                else:
                    return False
            left_tree, right_tree = False, False
            if node.left:
                left_tree = dfs(node.left, path_sum)
            if node.right:
                right_tree = dfs(node.right, path_sum)
            return left_tree or right_tree
        return dfs(root, 0)

113. 路径总和 II

递归

class Solution:
    def pathSum(self, root: Optional[TreeNode], targetSum: int) -> List[List[int]]:
        ans = []
        if not root:
            return ans
        def dfs(node, path, path_sum):
            nonlocal ans
            path_sum += node.val
            path.append(node.val)
            if not node.left and not node.right and path_sum == targetSum:
                ans.append(path[:])
                return

            if node.left:
                dfs(node.left, path, path_sum)
                path.pop()
            if node.right:
                dfs(node.right, path, path_sum)
                path.pop()
            return
        dfs(root, [], 0)
        return ans

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

递归

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

        int index = find(inorder.begin(), inorder.end(), postorder[n - 1]) - inorder.begin();
        vector<int> left_inorder(inorder.begin(), inorder.begin() + index);
        vector<int> right_inorder(inorder.begin() + index + 1, inorder.end());
        vector<int> left_postorder(postorder.begin(), postorder.begin() + index);
        vector<int> right_postorder(postorder.begin() + index, postorder.end() - 1);
        root->left = buildTree(left_inorder, left_postorder);
        root->right = buildTree(right_inorder, right_postorder);
        return root;
    }
};

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

class Solution {
public:
     TreeNode* traversal (vector<int>& inorder, int inorderBegin, int inorderEnd, vector<int>& preorder, int preorderBegin, int preorderEnd) {
         if (preorderBegin == preorderEnd) return NULL;
         
         int rootValue = preorder[preorderBegin]; // 注意用preorderBegin 不要用0
         TreeNode* root = new TreeNode(rootValue);
         if (preorderEnd - preorderBegin == 1) return root;

         int delimiterIndex;
         for (delimiterIndex = inorderBegin; delimiterIndex < inorderEnd; delimiterIndex++) {
            if (inorder[delimiterIndex] == rootValue) break;
        }
        // 切割中序数组
        // 中序左区间，左闭右开[leftInorderBegin, leftInorderEnd)
        int leftInorderBegin = inorderBegin;
        int leftInorderEnd = delimiterIndex;
        // 中序右区间，左闭右开[rightInorderBegin, rightInorderEnd)
        int rightInorderBegin = delimiterIndex + 1;
        int rightInorderEnd = inorderEnd;

        // 切割前序数组
        // 前序左区间，左闭右开[leftPreorderBegin, leftPreorderEnd)
        int leftPreorderBegin =  preorderBegin + 1;
        int leftPreorderEnd = preorderBegin + 1 + delimiterIndex - inorderBegin;
        // 前序右区间, 左闭右开[rightPreorderBegin, rightPreorderEnd)
        int rightPreorderBegin = preorderBegin + 1 + (delimiterIndex - inorderBegin);
        int rightPreorderEnd = preorderEnd;

        root->left = traversal(inorder, leftInorderBegin, leftInorderEnd,  preorder, leftPreorderBegin, leftPreorderEnd);
        root->right = traversal(inorder, rightInorderBegin, rightInorderEnd, preorder, rightPreorderBegin, rightPreorderEnd);

        return root;
    }

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