【LeetCode学习计划】《数据结构入门-C++》第12天 树

LeetCode【学习计划】：【数据结构】

---

---

226. 翻转二叉树

LeetCode: 226. 翻转二叉树

$简单$

翻转一棵二叉树。

示例：
输入：

     4
   /   \
  2     7
 / \   / \
1   3 6   9

输出：

     4
   /   \
  7     2
 / \   / \
9   6 3   1

备注:
这个问题是受到 Max Howell 的 原问题 启发的 ：

谷歌：我们90％的工程师使用您编写的软件(Homebrew)，但是您却无法在面试时在白板上写出翻转二叉树这道题，这太糟糕了。

---

方法1：递归

我们可以递归地解决本题。假设处于某处根节点，首先需要调用递归函数翻转左右子树，然后翻转自身的左右孩子即可。

class Solution
{
public:
    TreeNode *invertTree(TreeNode *root)
    {
        if (!root)
            return nullptr;

        TreeNode *left = invertTree(root->left);
        TreeNode *right = invertTree(root->right);
        root->left = right;
        root->right = left;
        return root;
    }
};

复杂度分析

• 时间复杂度：$O(n)$

• 空间复杂度：$O(n)$。和递归深度有关。平均情况下，二叉树的高度和结点个数呈对数关系$O(\log n)$；最坏情况下，树呈链状，时间复杂度达到$O(n)$。

参考结果

Accepted
77/77 cases passed (0 ms)
Your runtime beats 100 % of cpp submissions
Your memory usage beats 44.51 % of cpp submissions (9.5 MB)

---

---

112. 路径总和

LeetCode: 112. 路径总和

$简单$

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

示例 1：

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

示例 2：

输入：root = [1,2,3], targetSum = 5
输出：false
解释：树中存在两条根节点到叶子节点的路径：
(1 --> 2): 和为 3
(1 --> 3): 和为 4
不存在 sum = 5 的根节点到叶子节点的路径。

示例 3：

输入：root = [], targetSum = 0
输出：false
解释：由于树是空的，所以不存在根节点到叶子节点的路径。

提示：

• 树中节点的数目在范围 [0, 5000] 内
• -1000 <= Node.val <= 1000
• -1000 <= targetSum <= 1000

---

方法1：递归

我们需要找到一条路径，这条路径上所有结点的和如果等于 targetSum，则返回真值。

反过来思考一下，从根节点开始，每下降一个结点，就将 targetSum 减去该结点的值。一直这样减下去，如果说是一条有效路径，那么最终叶子结点的值就等于减完路径上其它结点的 targetSum。

由此，我们可以从根节点开始，先减去根节点的值得到 targetSum-root->val，这个值就是以左右孩子为根结点时，对它们所要求的 targetSum。到了最后，叶子结点的左右孩子必然是空指针，这时再判断叶子结点的值是否等于那时的 targetSum 即可。

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

复杂度分析

• 时间复杂度：$O(n)$

• 空间复杂度：$O(n)$。空间复杂度和递归深度有关。

参考结果

Accepted
117/117 cases passed (8 ms)
Your runtime beats 86.68 % of cpp submissions
Your memory usage beats 19.34 % of cpp submissions (20.9 MB)