代码随想录Day18 - 二叉树5 | 513. 找树左下角的值、112. 路径总和、106. 从中序与后序遍历序列构造二叉树-CSDN博客

本文链接：https://blog.csdn.net/Genelove1974/article/details/128692977

文章提供了力扣平台上几个关于二叉树的问题解决方案，包括找树左下角的最底层最左边节点值、路径总和以及从遍历序列构造二叉树的方法。使用了迭代策略，通过队列来处理节点，并对二叉树进行深度优先或广度优先搜索。

摘要由CSDN通过智能技术生成

513. 找树左下角的值：力扣

112. 路径总和：力扣

113. 路径总和：力扣

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

513. 找树左下角的值

力扣

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

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

解法：

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

112. 路径总和

力扣

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

迭代解法：

感觉回溯不好处理，因此队列没有只存TreeNode，加了pair存储当前的cur值

class Solution {
public:
    bool hasPathSum(TreeNode* root, int targetSum) {
        queue<pair<TreeNode*, int>> q;
        TreeNode* n;
        int cur = 0;
        if(root != nullptr) q.push(make_pair(root, 0));
        while(!q.empty()){
            auto i = q.front();
            q.pop();
            n = i.first;
            cur = i.second + n->val;
            if(n->left == nullptr && n->right == nullptr){
                if(cur == targetSum) return true;
            }
            if(n->left != nullptr) q.push(make_pair(n->left, cur));
            if(n->right != nullptr) q.push(make_pair(n->right, cur));
        }
        return false;
    }
};

113. 路径总和II

力扣

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

力扣

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

解法：

中序：左孩子 - 根节点 - 右孩子（根节点在中间访问）

后续：左孩子 - 右孩子 - 根节点（根节点在最后访问）

这样写有点繁琐，可以直接用迭代器作为参数

class Solution {
public:
    TreeNode* getTree(vector<int>& inorder, vector<int>& postorder, int l, int r, int l2, int r2){ // [l, r]
        if(r < l) return nullptr;
        TreeNode* root = new TreeNode(postorder[r2]);
        int root_pos = l;
        while(root_pos < r && inorder[root_pos] != postorder[r2]) root_pos++; // 1
        root->left = getTree(inorder, postorder, l, root_pos - 1, l2, l2 + root_pos - l - 1); // root_pos - l是左子树个数
        root->right = getTree(inorder, postorder, root_pos + 1, r, l2 + root_pos - l, r2 - 1);
        return root;
    }
    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        int size = postorder.size();
        TreeNode* root = getTree(inorder, postorder, 0, size - 1, 0, size - 1);
        return root;
    }
};