LeetCode 算法：从前序与中序遍历序列构造二叉树 c++

原题链接🔗：从前序与中序遍历序列构造二叉树
难度：中等⭐️⭐️

题目

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

示例 1:

输入: preorder = [3,9,20,15,7], inorder = [9,3,15,20,7]
输出: [3,9,20,null,null,15,7]

示例 2:

输入: preorder = [-1], inorder = [-1]
输出: [-1]

提示:

• 1 <= preorder.length <= 3000
• inorder.length == preorder.length
• -3000 <= preorder[i], inorder[i] <= 3000
• preorder 和 inorder 均 无重复 元素
• inorder 均出现在 preorder
• preorder 保证 为二叉树的前序遍历序列
• inorder 保证 为二叉树的中序遍历序列

题解

二叉树前序遍历

二叉树前序遍历的顺序为：

• 先遍历根节点；

• 随后递归地遍历左子树；

• 最后递归地遍历右子树。

二叉树中序遍历

二叉树中序遍历的顺序为：

• 先递归地遍历左子树；

• 随后遍历根节点；

• 最后递归地遍历右子树。

递归法

1. 解题思路：

LeetCode上的这个问题，即根据前序遍历和中序遍历的序列重建二叉树，是一个经典的二叉树问题。这个问题的关键在于理解前序遍历和中序遍历的特点：

• 前序遍历：首先访问根节点，然后是左子树，最后是右子树。

• 中序遍历：首先访问左子树，然后是根节点，最后是右子树。
  解题思路如下：

• 理解问题：首先，你需要理解前序遍历和中序遍历的序列。前序遍历的第一个元素总是根节点。中序遍历中的根节点位置可以用来区分左子树和右子树。

• 递归构建：使用递归来构建二叉树。递归的基本思想是使用前序遍历的第一个元素作为当前子树的根节点。

• 确定根节点：在前序遍历中，第一个元素是根节点。

• 找到根节点在中序遍历中的位置：在中序遍历中找到前序遍历的第一个元素的位置，这个位置将中序遍历分为左子树和右子树的中序遍历。

• 计算子树的大小：根节点在中序遍历中的位置可以帮助你计算出左子树和右子树的大小。左子树的大小是根节点的位置，右子树的大小是中序遍历的长度减去根节点的位置减去1。

• 递归构建左右子树：使用相同的逻辑递归地构建左子树和右子树。对于左子树，使用前序遍历的接下来的左子树大小个元素和中序遍历的根节点之前的所有元素。对于右子树，使用前序遍历的剩余元素和中序遍历的根节点之后的所有元素。

• 返回根节点：每次递归调用完成后，返回构建的子树的根节点。

2. 复杂度：时间复杂度O(n)，空间复杂度O(n)。

3. c++ demo：

#include <iostream>
#include <vector>
#include <unordered_map>

using namespace std;

struct TreeNode {
    int val;
    TreeNode* left;
    TreeNode* right;
    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
};

class Solution {
private:
    unordered_map<int, int> index;

public:
    TreeNode* myBuildTree(const vector<int>& preorder, const vector<int>& inorder, int preorder_left, int preorder_right, int inorder_left, int inorder_right) {
        if (preorder_left > preorder_right) {
            return nullptr;
        }

        // 前序遍历中的第一个节点就是根节点
        int preorder_root = preorder_left;
        // 在中序遍历中定位根节点
        int inorder_root = index[preorder[preorder_root]];

        // 先把根节点建立出来
        TreeNode* root = new TreeNode(preorder[preorder_root]);
        // 得到左子树中的节点数目
        int size_left_subtree = inorder_root - inorder_left;
        // 递归地构造左子树，并连接到根节点
        // 先序遍历中「从 左边界+1 开始的 size_left_subtree」个元素就对应了中序遍历中「从 左边界 开始到 根节点定位-1」的元素
        root->left = myBuildTree(preorder, inorder, preorder_left + 1, preorder_left + size_left_subtree, inorder_left, inorder_root - 1);
        // 递归地构造右子树，并连接到根节点
        // 先序遍历中「从 左边界+1+左子树节点数目 开始到 右边界」的元素就对应了中序遍历中「从 根节点定位+1 到 右边界」的元素
        root->right = myBuildTree(preorder, inorder, preorder_left + size_left_subtree + 1, preorder_right, inorder_root + 1, inorder_right);
        return root;
    }

    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        int n = preorder.size();
        // 构造哈希映射，帮助我们快速定位根节点
        for (int i = 0; i < n; ++i) {
            index[inorder[i]] = i;
        }
        return myBuildTree(preorder, inorder, 0, n - 1, 0, n - 1);
    }
};
// 前序遍历打印二叉树
void printPreOrder(TreeNode* node) {
    if (node == nullptr) {
        return;
    }
    cout << node->val << " "; // 访问根节点
    printPreOrder(node->left);  // 递归地前序遍历左子树
    printPreOrder(node->right); // 递归地前序遍历右子树
}

int main() {
    Solution solution;
    vector<int> preorder = { 3, 9, 20, 15, 7 };
    vector<int> inorder = { 9, 3, 15, 20, 7 };

    TreeNode* root = solution.buildTree(preorder, inorder);

    // 这里可以添加代码来遍历或打印树，以验证构建的树是否正确
    // ...
    printPreOrder(root);

    return 0;
}

• 输出结果：

3 9 20 15 7

4. 代码仓库地址：myBuildTree