LeetCode 热题 100 | 二叉树(下)

目录

[1 114. 二叉树展开为链表](#1 114. 二叉树展开为链表)

[2 105. 从前序与中序遍历序列构造二叉树](#2 105. 从前序与中序遍历序列构造二叉树)

[3 437. 路径总和 III](#3 437. 路径总和 III)


菜鸟做题(即将返校版),语言是 C++

1 114. 二叉树展开为链表

题眼:展开后的单链表应该与二叉树 先序遍历 顺序相同。

而先序遍历就是指,先遍历左子树,再遍历右子树。题意所说的展开,无非就是让左子树插队到右子树的前面去。

解题思路:采用递归,对于每个节点,先将它的左子树链到右侧去,再让右子树链到左子树的后面。

思路说明图:

对于节点 "1",绿色部分为其左子树,黄色部分为其右子树。我们需要做的就是:先将左子树链到 "1" 的右侧去,再让右子树链到左子树的后面。对于节点 "2",同理。

cpp 复制代码
class Solution {
public:
    void flatten(TreeNode* root) {
        if (!root) return;

        TreeNode * p = root->left;
        if (p) {
            while (p->right) {
                p = p->right;
            }
            TreeNode * q = root->right;
            root->right = root->left;
            root->left = nullptr; // heap-use-after-free on address 0x503000000138
            p->right = q;
        }

        flatten(root->right);
    }
};

说明:为了能使右子树链到左子树的屁股后面,我们需要找到左子树的屁股,代码如下。

cpp 复制代码
while (p->right) {
    p = p->right;
}

坑点:题目中说 "左子指针始终为 null",即移走左子树后,要把左子指针置为空指针,代码如下。

cpp 复制代码
root->left = nullptr; // heap-use-after-free on address 0x503000000138

否则会出现注释中的报错。

2 105. 从前序与中序遍历序列构造二叉树

遍历特点:

  • 前序:根节点 << 左子树 << 右子树
  • 中序:左子树 << 根节点 << 右子树

因此,preorder 和 inorder 数组中的元素也呈现出上述排列规律。

思路说明图:

对于 preorder 数组,根据遍历特点,显然最左侧的 "3" 是根节点**(root)**。但是,我们无法根据 preorder 数组得知 "3" 的左子树和右子树分别是哪两坨。这时,inorder 数组就派上用场了。我们在 inorder 数组中定位 "3",根据遍历特点,"3" 的左侧部分就是左子树("9"),右侧部分就是右子树("20" "15" "7")。

现在,我们知道 "3" 的左子树和右子树分别是什么了,以及它们各自的长度。由此,我们可以在 preorder 数组中得到 "3" 的左子树和右子树所处的区间,即上图中的 绿色 部分和 蓝色 部分。又根据遍历特点,我们知道 绿色 部分的最左侧是左子树的根节点**(root->left)蓝色 部分的最左侧是右子树的根节点(root->right)**。

以此类推,构造整个二叉树。

综上,preorder 数组的作用是定位各个根节点,inorder 数组的作用是定位左子树和右子树。

参数说明:

  • pre_left、pre_right:当前子树在 preorder 数组所处的区间
  • in_left、in_right:当前子树在 inorder 数组所处的区间
  • sub_ltree:左子树长度,帮助定位左子树区间
cpp 复制代码
class Solution {
public:
    vector<int> preorder, inorder;
    unordered_map<int, int> hash;

    TreeNode * helper(int pre_left, int pre_right, int in_left, int in_right) {
        if (pre_left > pre_right) return nullptr;

        int pre_root = pre_left;
        int in_root = hash[preorder[pre_root]];
        int sub_ltree = in_root - in_left;

        TreeNode * node = new TreeNode(preorder[pre_root]);
        node->left = helper(pre_left + 1, pre_left + sub_ltree,
                            in_left, in_root - 1);
        node->right = helper(pre_left + sub_ltree + 1, pre_right,
                            in_root + 1, in_right);
        return node;
    }

    TreeNode* buildTree(vector<int>& arr1, vector<int>& arr2) {
        int n = arr1.size();
        preorder = arr1;
        inorder = arr2;
        
        for (int i = 0; i < n; ++i) {
            hash[inorder[i]] = i;
        }

        return helper(0, n - 1, 0, n - 1);
    }
};

3 437. 路径总和 III

关键字:深度搜索(先序遍历)+ 前缀和

我百度了一下,说它俩是一个意思。我觉得采用先序遍历是因为,它每次都是沿着一条直线去遍历的,而不是像中序遍历那样跳着遍历的。因此,先序遍历更符合题意。

思路说明图:路径 "5, 3" 的和可以看作是路径 "10, 5, 3" 的和减去路径 "10" 的和,也就是可以转换为字符串那一节的前缀和问题。

这里说的前缀是指以根节点为开始的路径,而前缀和就是各个前缀的路径和。

具体解法:

① 定义变量

  • hash 用于存放各个前缀的路径和
  • total 用于记录当前加总出的路径和
  • count 用于记录符合条件的路径和的个数

② 查询符合条件的路径和

cpp 复制代码
if (hash.count(total - targetSum)) {
    count = hash[total - targetSum];
}

就是在 hash 表中寻找,是否有前缀的路径和与当前路径和的差为 targetSum 值。

③ 先序遍历

cpp 复制代码
hash[total]++;
count += helper(root->left, total, targetSum);
count += helper(root->right, total, targetSum);
hash[total]--;

在走向下一个节点之前,先把当前路径和存入 hash 表中,因为它是前缀和。同时,当基于这条路径的所有路径都被遍历完毕后,要把这条路径的路径和移出 hash 表,即 hash[total]-- 。

比如,我们遍历完了节点 "3" 及其左右子树,接下来就该遍历 "5" 的右子树了。而 "5" 的右子树不会经过路径 "10, 5, 3" 。因此,在节点 "3" 发现自己的左右子树被遍历完时,"3" 就应该回收以自己为终点的路径 "10, 5, 3" 了。

cpp 复制代码
class Solution {
public:
    unordered_map<long, int> hash;

    int helper(TreeNode * root, long total, int targetSum) {
        if (!root) return 0;

        int count = 0;
        total += root->val;
        if (hash.count(total - targetSum)) {
            count = hash[total - targetSum];
        }

        hash[total]++;
        count += helper(root->left, total, targetSum);
        count += helper(root->right, total, targetSum);
        hash[total]--;

        return count;
    }

    int pathSum(TreeNode* root, int targetSum) {
        hash[0] = 1;
        return helper(root, 0, targetSum);
    }
};

说明:下述代码是为了处理前缀本身的路径和等于 targetSum 的情况,也就是它(被减数)不需要和另一个前缀(减数)做减法。这里用路径和为 0 来表示减数,否则这种情况会被忽略。

cpp 复制代码
hash[0] = 1;

题外话:虽然 count 变量在每一次递归中都是重新定义的,但是因为它是返回值,所以还是能起到计数器的作用。而 total 变量是作为参数一层一层传下去的,所以它也能起到计数器的作用。

相关推荐
记得早睡~7 分钟前
leetcode73-矩阵置零
数据结构·leetcode·矩阵
爱coding的橙子29 分钟前
每日算法刷题Day27 6.9:leetcode二分答案2道题,用时1h20min
算法·leetcode·职场和发展
GalaxyPokemon40 分钟前
LeetCode - 3. 无重复字符的最长子串
算法·哈希算法·散列表
a.3021 小时前
C++ 时间处理指南:深入剖析<ctime>库
数据结构·c++·算法
亮亮爱刷题1 小时前
算法刷题-回溯
算法
Neil今天也要学习1 小时前
永磁同步电机无速度算法--自适应龙贝格观测器
算法
算AI3 小时前
AI辅助编程:常用的7种Prompt模式
人工智能·算法
TY-20253 小时前
机器学习算法_决策树
算法·决策树·机器学习
子豪-中国机器人4 小时前
C++ 信息学奥赛总复习题
java·jvm·算法
全干engineer5 小时前
web3-基于贝尔曼福特算法(Bellman-Ford )与 SMT 的 Web3 DeFi 套利策略研究
算法·金融·web3·去中心化·区块链·智能合约