代码随想录算法训练营Day16 | 513.找树左下角的值、112. 路径总和、106.从中序与后序遍历序列构造二叉树-优快云博客

文章目录

513.找树左下角的值
- 思路与重点
112. 路径总和
- 思路与重点
106.从中序与后序遍历序列构造二叉树
- 思路与重点

513.找树左下角的值

题目链接：513. 找树左下角的值 - 力扣（LeetCode）
讲解链接：代码随想录
状态：一遍AC。

思路与重点

我的解法：直接层序遍历，最后一层的第一个节点值即为所求。

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

也可以使用回溯法解决：当遇到叶子节点的时候，就需要统计一下最大的深度了，所以需要遇到叶子节点来更新最大深度。

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

112. 路径总和

题目链接：
- 112. 路径总和 - 力扣（LeetCode）
- 113. 路径总和 II - 力扣（LeetCode）
讲解链接：代码随想录
状态：一遍AC。

思路与重点

我的思路：递归遍历遇到叶子节点时进行比较，存在的问题是没有及时退出函数。

class Solution {
public:
    void traversal(TreeNode* cur, int pathSum, int targetSum, bool& flag){
        if(!cur->left && !cur->right && pathSum + cur->val == targetSum){
            flag = true;
            return;
        }
        if(cur->left) traversal(cur->left, pathSum + cur->val, targetSum, flag);
        if(cur->right) traversal(cur->right, pathSum + cur->val, targetSum, flag);
    }
    bool hasPathSum(TreeNode* root, int targetSum) {
        bool ans = false;
        int pathSum = 0;
        if(!root) return ans;
        traversal(root, pathSum, targetSum, ans);
        return ans;
    }
};

**递归函数什么时候需要返回值？什么时候不需要返回值？**这里总结如下三点：
- 如果需要搜索整棵二叉树且不用处理递归返回值，递归函数就不要返回值。（这种情况就是本文下半部分介绍的113.路径总和ii)
- 如果需要搜索整棵二叉树且需要处理递归返回值，递归函数就需要返回值。（这种情况我们在236. 二叉树的最近公共祖先 (opens new window)中介绍）
- 如果要搜索其中一条符合条件的路径，那么递归一定需要返回值，因为遇到符合条件的路径了就要及时返回。（本题的情况）
代码随想录中的写法：

class Solution {
private:
    bool traversal(TreeNode* cur, int count) {
        if (!cur->left && !cur->right && count == 0) return true; // 遇到叶子节点，并且计数为0
        if (!cur->left && !cur->right) return false; // 遇到叶子节点直接返回

        if (cur->left) { // 左
            count -= cur->left->val; // 递归，处理节点;
            if (traversal(cur->left, count)) return true;
            count += cur->left->val; // 回溯，撤销处理结果
        }
        if (cur->right) { // 右
            count -= cur->right->val; // 递归，处理节点;
            if (traversal(cur->right, count)) return true;
            count += cur->right->val; // 回溯，撤销处理结果
        }
        return false;
    }

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

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

使用栈模拟的前序遍历：

class solution {

public:
    bool haspathsum(TreeNode* root, int sum) {
        if (root == null) return false;
        // 此时栈里要放的是pair<节点指针，路径数值>
        stack<pair<TreeNode*, int>> st;
        st.push(pair<TreeNode*, int>(root, root->val));
        while (!st.empty()) {
            pair<TreeNode*, int> node = st.top();
            st.pop();
            // 如果该节点是叶子节点了，同时该节点的路径数值等于sum，那么就返回true
            if (!node.first->left && !node.first->right && sum == node.second) return true;

            // 右节点，压进去一个节点的时候，将该节点的路径数值也记录下来
            if (node.first->right) {
                st.push(pair<TreeNode*, int>(node.first->right, node.second + node.first->right->val));
            }

            // 左节点，压进去一个节点的时候，将该节点的路径数值也记录下来
            if (node.first->left) {
                st.push(pair<TreeNode*, int>(node.first->left, node.second + node.first->left->val));
            }
        }
        return false;
    }
};

路径总和ii我的解法：

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

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

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

题目链接：106. 从中序与后序遍历序列构造二叉树 - 力扣（LeetCode）
讲解链接：代码随想录
状态：直接看题解了。

思路与重点

中序序列可以与先序序列、后序序列、层序序列中的任意一个来构建唯一的二叉树，而后三者两两搭配或是三个一起上都无法构建唯一的二叉树。原因是先序、后序、层序的作用均是提供根节点，都必须由中序序列来区分出左右子树。
全部使用闭区间的写法，参见《算法笔记》：

class Solution {
public:
    TreeNode* traversal(vector<int>& inorder, vector<int>& postorder, int inL, int inR, int postL, int postR){
        if(postL > postR) return NULL;
        TreeNode* root = new TreeNode(postorder[postR]);
        int delimiterIndex;
        for(delimiterIndex = inL; delimiterIndex <= inR; delimiterIndex++){
            if(inorder[delimiterIndex] == postorder[postR]) break;
        }
        int numLeft = delimiterIndex - inL;
        root->left = traversal(inorder, postorder, inL, delimiterIndex - 1, postL, postL + numLeft - 1);
        root->right = traversal(inorder, postorder, delimiterIndex + 1, inR, postL + numLeft, postR - 1);
        return root;
    }
    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        return traversal(inorder, postorder, 0, inorder.size() - 1, 0, postorder.size() - 1);
    }
};

采用左闭右开的写法，参见代码随想录。

class Solution {
private:
    // 中序区间：[inorderBegin, inorderEnd)，后序区间[postorderBegin, postorderEnd)
    TreeNode* traversal (vector<int>& inorder, int inorderBegin, int inorderEnd, vector<int>& postorder, int postorderBegin, int postorderEnd) {
        if (postorderBegin == postorderEnd) return NULL;

        int rootValue = postorder[postorderEnd - 1];
        TreeNode* root = new TreeNode(rootValue);

        if (postorderEnd - postorderBegin == 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;

        // 切割后序数组
        // 左后序区间，左闭右开[leftPostorderBegin, leftPostorderEnd)
        int leftPostorderBegin =  postorderBegin;
        int leftPostorderEnd = postorderBegin + delimiterIndex - inorderBegin; // 终止位置是 需要加上 中序区间的大小size
        // 右后序区间，左闭右开[rightPostorderBegin, rightPostorderEnd)
        int rightPostorderBegin = postorderBegin + (delimiterIndex - inorderBegin);
        int rightPostorderEnd = postorderEnd - 1; // 排除最后一个元素，已经作为节点了

        root->left = traversal(inorder, leftInorderBegin, leftInorderEnd,  postorder, leftPostorderBegin, leftPostorderEnd);
        root->right = traversal(inorder, rightInorderBegin, rightInorderEnd, postorder, rightPostorderBegin, rightPostorderEnd);

        return root;
    }
public:
    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        if (inorder.size() == 0 || postorder.size() == 0) return NULL;
        // 左闭右开的原则
        return traversal(inorder, 0, inorder.size(), postorder, 0, postorder.size());
    }
};