day18 | 513.找树左下角的值、路径总和、从中序与后序遍历序列构造二叉树

最新推荐文章于 2024-06-15 09:23:13 发布

我想喝冰阔乐

最新推荐文章于 2024-06-15 09:23:13 发布

阅读量588

点赞数

分类专栏： LeetCode 刷题 C++ 文章标签： leetcode 算法 c++

本文链接：https://blog.csdn.net/weixin_45048521/article/details/131175060

版权

C++ 同时被 2 个专栏收录

82 篇文章 0 订阅

订阅专栏

LeetCode 刷题

81 篇文章 0 订阅

订阅专栏

链接

题目链接：

https://leetcode.cn/problems/find-bottom-left-tree-value/

解题及思路学习

513. 找树左下角的值

给定一个二叉树的 根节点 root，请找出该二叉树的 最底层最左边 节点的值。

假设二叉树中至少有一个节点。

示例 1:

!https://assets.leetcode.com/uploads/2020/12/14/tree1.jpg

输入:root = [2,1,3]
输出:1

思考：递归和迭代都可以。

递归：题目关键点，最底层，所以，还需要知道子树的深度。可以考虑返回一个数组信息，第一个传的是该分支最左边节点的值，第二个传深度信息，也就是该分支的高度。

根据随想录写的代码：

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

    int findBottomLeftValue(TreeNode* root) {
        reversal(root, 0);
        return result;
        
    }
};

迭代法：

一直用一个值保存每行的第一个，遍历结束后就放的是最底层的第一个。

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

递归的处理方法很妙，我原先想的是返回一个数组，分别记录高度和最左节点的值。随想录里面是在递归外层用变量记录最大的深度和对于的值。这种方法比我刚开始思考的方法传回的值更简洁。后面如果遇到这种需要记录的题目，也可以考虑用这种回溯的思路去做，在递归的外层用变量记录。

路径总和

112. 路径总和

给你二叉树的根节点 root 和一个表示目标和的整数 targetSum 。判断该树中是否存在 根节点到叶子节点 的路径，这条路径上所有节点值相加等于目标和 targetSum 。如果存在，返回 true ；否则，返回 false 。

叶子节点 是指没有子节点的节点。

示例 1：

!https://assets.leetcode.com/uploads/2021/01/18/pathsum1.jpg

输入：root = [5,4,8,11,null,13,4,7,2,null,null,null,1], targetSum = 22
输出：true
解释：等于目标和的根节点到叶节点路径如上图所示。

思考：这题可以用前序递归来试一下，用一个数组记录一下从根节点到当前叶子节点的路径和。

代码：

这里就很明显用到了回溯的思想，比较坑的是结束情况需要考虑的更清楚。起先没想到root为空，判断条件少了一个，卡了我将近二十分钟。

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

        if (root->left) {
            targetSum -= root->val;
            if(hasPathSum(root->left,targetSum)) return true;
            targetSum += root->val;
        }

        if (root->right) {
            targetSum -= root->val;
            if(hasPathSum(root->right, targetSum)) return true;
            targetSum += root->val;
        }
        return false;
    }
};

迭代也能行，试着写一下。没写出来，直接看随想录代码：

递归代码：

思路差不多一样的

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);
    }
};

//精简版代码
lass 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);
    }
};

迭代法

利用一个stack栈，用pair的形式存储当前节点的指针以及路径的累计数值。很秒。

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;
    }
};

113. 路径总和 II

这道题升级了一下难度，返回的不再是bool，而是所有等于目标和的路径。

递归方法：

自己写的方法，时间复杂度有点高，如果将vec换成指针，或许会快不少。

class Solution {
public:
    vector<vector<int>> result;
    vector<int> vec;
    void findPath(TreeNode* root, int targetSum, vector<int> vec) {
        if (root == NULL) return;
        if (!root->left && !root->right && targetSum == root->val) {
            vec.push_back(root->val);
            result.push_back(vec);
        }
        if (!root->left && !root->right && targetSum != root->val) return;

        if (root->left) {
            vec.push_back(root->val);
            targetSum -= root->val;
            findPath(root->left, targetSum, vec);
            vec.pop_back();
            targetSum += root->val;
        }
        if (root->right) {
            vec.push_back(root->val);
            targetSum -= root->val;
            findPath(root->right, targetSum, vec);
            vec.pop_back();
            targetSum += root->val;
        }
    }
    vector<vector<int>> pathSum(TreeNode* root, int targetSum) {
        findPath(root, targetSum, vec);
        return result;
    }
};

// 优化版本, 可以不用传入vec
class Solution {
public:
    vector<vector<int>> result;
    vector<int> vec;
    void findPath(TreeNode* root, int targetSum) {
        if (root == NULL) return;
        if (!root->left && !root->right && targetSum == root->val) {
            vec.push_back(root->val);
            result.push_back(vec);
            vec.pop_back();
        }
        if (!root->left && !root->right && targetSum != root->val) return;

        if (root->left) {
            vec.push_back(root->val);
            targetSum -= root->val;
            findPath(root->left, targetSum);
            targetSum += root->val;
            vec.pop_back();
        }
        if (root->right) {
            vec.push_back(root->val);
            targetSum -= root->val;
            findPath(root->right, targetSum);
            targetSum += root->val;
            vec.pop_back();
        }
        return;
    }
    vector<vector<int>> pathSum(TreeNode* root, int targetSum) {
        result.clear();
        vec.clear();
        findPath(root, targetSum);
        return result;
    }
};

随想录方法：

递归

class solution {
private:
    vector<vector<int>> result;
    vector<int> path;
    // 递归函数不需要返回值，因为我们要遍历整个树
    void traversal(TreeNode* cur, int count) {
        if (!cur->left && !cur->right && count == 0) { // 遇到了叶子节点且找到了和为sum的路径
            result.push_back(path);
            return;
        }

        if (!cur->left && !cur->right) return ; // 遇到叶子节点而没有找到合适的边，直接返回

        if (cur->left) { // 左 （空节点不遍历）
            path.push_back(cur->left->val);
            count -= cur->left->val;
            traversal(cur->left, count);    // 递归
            count += cur->left->val;        // 回溯
            path.pop_back();                // 回溯
        }
        if (cur->right) { // 右 （空节点不遍历）
            path.push_back(cur->right->val);
            count -= cur->right->val;
            traversal(cur->right, count);   // 递归
            count += cur->right->val;       // 回溯
            path.pop_back();                // 回溯
        }
        return ;
    }

public:
    vector<vector<int>> pathSum(TreeNode* root, int sum) {
        result.clear();
        path.clear();
        if (root == NULL) return result;
        path.push_back(root->val); // 把根节点放进路径
        traversal(root, sum - root->val);
        return result;
    }
};

递归过程中当需要记录一些值，这些值在遍历的过程中发生变化，就一定要注意回溯的写法。

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

给定两个整数数组 inorder 和 postorder ，其中 inorder 是二叉树的中序遍历， postorder 是同一棵树的后序遍历，请你构造并返回这颗 二叉树 。

示例 1:

!https://assets.leetcode.com/uploads/2021/02/19/tree.jpg

输入：inorder = [9,3,15,20,7], postorder = [9,15,7,20,3]
输出：[3,9,20,null,null,15,7]

思考：简单的说，就是给定中序遍历和后续遍历，去构造这颗二叉树。自己想的步骤→ 先从后续遍历取到末尾的值，再到中序遍历中找到该值，根据该值将其分为左右两个部分。然后根据中序的两个区间再将后续分成两个区间。然后重复该步骤。

随想录：思路差不多。以后序数组的最后一个元素为切割点，先切中序数组，根据中序数组，反过来再切后序数组。一层一层切下去，每次后序数组最后一个元素就是节点元素。

来看一下一共分几步：

第一步：如果数组大小为零的话，说明是空节点了。
第二步：如果不为空，那么取后序数组最后一个元素作为节点元素。
第三步：找到后序数组最后一个元素在中序数组的位置，作为切割点
第四步：切割中序数组，切成中序左数组和中序右数组（顺序别搞反了，一定是先切中序数组）
第五步：切割后序数组，切成后序左数组和后序右数组
第六步：递归处理左区间和右区间

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 delimiterIndex;
        for (delimiterIndex = 0; delimiterIndex < inorder.size(); delimiterIndex++) {
            if (inorder[delimiterIndex] == rootValue) break;
        }

        vector<int> leftInorder(inorder.begin(), inorder.begin() + delimiterIndex);
        vector<int> rightInorder(inorder.begin() + delimiterIndex + 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);

    }
};

看起来真的很复杂，做题的时候需要仔细判断边界条件，最好都用某一种边界条件。

困难及收获

困难

思路清晰，代码写出来一定是各种问题

今日收获

对于调代码，阔以用日志的方法来搞清楚细节

https://programmercarl.com/0106.从中序与后序遍历序列构造二叉树.html#思路

我想喝冰阔乐

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
day18 | 513.找树左下角的值、路径总和、从中序与后序遍历序列构造二叉树

递归的处理方法很妙，我原先想的是返回一个数组，分别记录高度和最左节点的值。后面如果遇到这种需要记录的题目，也可以考虑用这种回溯的思路去做，在递归的外层用变量记录。自己想的步骤→ 先从后续遍历取到末尾的值，再到中序遍历中找到该值，根据该值将其分为左右两个部分。以后序数组的最后一个元素为切割点，先切中序数组，根据中序数组，反过来再切后序数组。可以考虑返回一个数组信息，第一个传的是该分支最左边节点的值，第二个传深度信息，也就是该分支的高度。一直用一个值保存每行的第一个，遍历结束后就放的是最底层的第一个。
复制链接

扫一扫