Follow Carl To Grow|【LeetCode】513.找树左下角的值,112.路径总和,113.路径总和ii,106.从中序与后序遍历序列构造二叉树,105.从前序与中序遍历构造二叉树

【LeetCode】513.找树左下角的值

题意：给定一个二叉树的 根节点 root，请找出该二叉树的 最底层 最左边 节点的值。
假设二叉树中至少有一个节点。

思路：迭代层序遍历，每层第一个点更新值。

代码：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    int findBottomLeftValue(TreeNode* root) {
        queue<TreeNode*> q;
        q.push(root);
        int val = root->val;
        while (!q.empty())
        {
            int size = q.size();
            for (int i = 0; i < size; ++i)
            {
                TreeNode* node = q.front();
                q.pop();                
                if (0 == i)
                {
                    val = node->val;
                }
                if (node->left)
                {
                    q.push(node->left);
                }
                if (node->right)
                {
                    q.push(node->right);
                }
            }
        }
        return val;
    }
};

---

【LeetCode】112.路径总和

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

思路：前序遍历，递归时计算当前还需要多少，计算时传参需要回溯。又因为找到就停止，所以递归函数返回值为bool

代码：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    bool traverse(TreeNode* root, int target)
    {
        if (!root->left && !root->right)
        {
            return 0 == target;
        }
        if (root->left)
        {
            target -= root->left->val;
            if (traverse(root->left, target))
            {
                return true;
            }
            target += root->left->val;
        }
        if (root->right)
        {
            target -= root->right->val;
            if (traverse(root->right, target))
            {
                return true;
            }
            target += root->right->val;
        }
        return false;
    }

    bool hasPathSum(TreeNode* root, int targetSum) {
        if (!root)
        {
            return false;
        }
        return traverse(root, targetSum - root->val);
    }
};

---

【LeetCode】113.路径总和ii

题意：给你二叉树的根节点 root 和一个整数目标和 targetSum ，找出所有 从根节点到叶子节点 路径总和等于给定目标和的路径。
叶子节点 是指没有子节点的节点。

思路：前序遍历，递归时计算当前还需要多少，计算时传参需要回溯。要遍历所有路径，所以参数可以存储当前路径，然后用一个数据成员存储所有路径。

代码：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<vector<int> > m_result;

    void traverse(TreeNode* root, int target, vector<int> path)
    {
        if (!root->left && !root->right)
        {
            if (0 == target)
            {
                m_result.push_back(path);
            }
            return;
        }
        if (root->left)
        {
            target -= root->left->val;
            path.push_back(root->left->val);
            traverse(root->left, target, path);
            path.pop_back();
            target += root->left->val;
        }
        if (root->right)
        {
            target -= root->right->val;
            path.push_back(root->right->val);
            traverse(root->right, target, path);
            path.pop_back();
            target += root->right->val;
        }
    }

    vector<vector<int>> pathSum(TreeNode* root, int targetSum) {
        if (!root)
        {
            return m_result;
        }
        vector<int> path;
        path.push_back(root->val);
        traverse(root, targetSum - root->val, path);
        return m_result;
    }
};

---

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

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

思路：中序和后序可以唯一确定一棵二叉树，递归从后序找到根节点，然后从中序找到这个点来划分左右子树。

代码：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    // [lin, rin) [lpost, rpost)
    TreeNode* build(vector<int> &inorder, int lin, int rin, vector<int> &postorder, int lpost, int rpost)
    {
        if (rin <= lin || rpost <= lpost)
        {
            return NULL;
        }
        int val = postorder[rpost - 1];
        TreeNode* node = new TreeNode(val);
        int idx = 0;
        for (idx = lin; idx != rin; ++idx)
        {
            if (inorder[idx] == val)
            {
                break;
            }
        }
        node->left = build(inorder, lin, idx, postorder, lpost, lpost + idx - lin);
        node->right = build(inorder, idx + 1, rin, postorder, lpost + idx - lin, rpost - 1);
        return node;
    }

    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        if (inorder.empty() || postorder.empty() || inorder.size() != postorder.size())
        {
            return NULL;
        }
        return build(inorder, 0, inorder.size(), postorder, 0, postorder.size());
    }
};

---

【LeetCode】105.从前序与中序遍历构造二叉树

题意：给定两个整数数组 preorder 和 inorder ，其中 preorder 是二叉树的先序遍历， inorder 是同一棵树的中序遍历，请构造二叉树并返回其根节点。

思路：前序和中序可以唯一确定一棵二叉树，递归从前序找到根节点，然后从中序找到这个点来划分左右子树。

代码：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    // [lpre, rpre) [lin, rin)
    TreeNode* build(vector<int> &preorder, int lpre, int rpre, vector<int> &inorder, int lin, int rin)
    {
        if (rpre <= lpre || rin <= lin)
        {
            return NULL;
        }
        int val = preorder[lpre];
        TreeNode* node = new TreeNode(val);
        int idx = 0;
        for (idx = lin; idx != rin; ++idx)
        {
            if (inorder[idx] == val)
            {
                break;
            }
        }
        node->left = build(preorder, lpre + 1, lpre + 1 + idx - lin, inorder, lin, idx);
        node->right = build(preorder, lpre + 1 + idx - lin, rpre, inorder, idx + 1, rin);
        return node;
    }

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

---

心态：“第六章 二叉树 part05” 拿下！
参考资料