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

513.找树左下角的值

题目链接：. - 力扣（LeetCode）

文档讲解：代码随想录

视频讲解：怎么找二叉树的左下角？ 递归中又带回溯了，怎么办？| LeetCode：513.找二叉树左下角的值_哔哩哔哩_bilibili

状态：未通过

初步解题思路：使用层序遍历的方法遍历整棵树，取层序遍历中最后一层的最左边节点的值就得到题目要求的结果了。 

代码实现：

class Solution {
public:
    int findBottomLeftValue(TreeNode* root) {
        queue<TreeNode*> que;
        if(root != NULL) que.push(root);
        int result;
        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;
    }
};

看完代码随想录后解题思路：使用递归法，先求出最大深度的叶子节点，取最大深度的叶子节点中最左边节点的值作为结果返回。

代码实现：

class Solution {
public:
    int maxDepth = INT_MIN;
    int result;
    void traversal(TreeNode* node, int depth){
        if(node->left == NULL && node->right == NULL){
            if(depth > maxDepth){
                maxDepth = depth;
                result = node->val;
            }
        }
        if(node->left){
            depth++;
            traversal(node->left, depth);
            depth--;
        }
        if(node->right){
            depth++;
            traversal(node->right, depth);
            depth--;
        }
    }
    int findBottomLeftValue(TreeNode* root) {
        traversal(root, 0);
        return result;
    }
};

112. 路径总和

题目链接：. - 力扣（LeetCode）

文档讲解：代码随想录

视频讲解：拿不准的遍历顺序，搞不清的回溯过程，我太难了！ | LeetCode：112. 路径总和_哔哩哔哩_bilibili

状态：未通过

代码实现：

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

        if(node->left){
            if(traversal(node->left, sum - node->left->val)) return true;
        }
        if(node->right){
            if(traversal(node->right, sum - node->right->val)) return true;
        }

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

 

113.路径总和ii

题目链接：. - 力扣（LeetCode）

文档讲解：代码随想录

状态：通过

代码实现： 

class Solution {
private:
    vector<vector<int>> result;
    void traversal(TreeNode* node, vector<int> vec, int sum){
        if(node->left == NULL && node->right == NULL && sum == 0){
            result.push_back(vec);
            return;
        } 
        if(node->left == NULL && node->right == NULL) return;

        if(node->left){
            vec.push_back(node->left->val);
            traversal(node->left, vec, sum - node->left->val);
            vec.pop_back();
        }
        if(node->right){
            vec.push_back(node->right->val);
            traversal(node->right, vec, sum - node->right->val);
            vec.pop_back();
        }
    };
public:
    vector<vector<int>> pathSum(TreeNode* root, int targetSum) {
        if(root == NULL) return {};
        vector<int> vec;
        vec.push_back(root->val);
        traversal(root, vec, targetSum - root->val);
        return result;
    }
};

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

题目链接：. - 力扣（LeetCode）

文档讲解：代码随想录

视频讲解：坑很多！来看看你掉过几次坑 | LeetCode：106.从中序与后序遍历序列构造二叉树_哔哩哔哩_bilibili

状态：未通过

代码实现：

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

        int i;
        for(i = 0; i < inorder.size(); i++){
            if(inorder[i] == rootValue) break;
        }

        vector<int> leftInorder(inorder.begin(), inorder.begin() + i);
        vector<int> rightInorder(inorder.begin() + i + 1, inorder.end());

        postorder.resize(postorder.size() - 1);
        vector<int> leftPostorder(postorder.begin(), postorder.begin() + leftInorder.size());
        vector<int> rightPostorder(postorder.begin() + leftInorder.size(), postorder.end());

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

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

 

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

题目链接：. - 力扣（LeetCode）

文档讲解：代码随想录

状态：通过

代码实现：

class Solution {
private:
    TreeNode* traversal(vector<int>& preorder, vector<int>& inorder){
        if(preorder.size() == 0) return NULL;

        int rootValue = preorder[0];
        TreeNode* root = new TreeNode(rootValue);
        if(preorder.size() == 1) return root;

        int i;
        for(i = 0; i < inorder.size(); i++){
            if(inorder[i] == rootValue) break;
        }

        vector<int> leftInorder(inorder.begin(), inorder.begin() + i);
        vector<int> rightInorder(inorder.begin() + i + 1, inorder.end());

        vector<int> leftPreorder(preorder.begin() + 1, preorder.begin() + leftInorder.size() + 1);
        vector<int> rightPreorder(preorder.begin() + leftInorder.size() + 1, preorder.end());

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

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