LeetCode之重建二叉树

题目链接：https://leetcode-cn.com/problems/zhong-jian-er-cha-shu-lcof/

解题步骤：

• 二叉树的前序遍历顺序：根节点、左子树、右子树，并且对左右子树也采用前序遍历
• 二叉树的中序遍历顺序：左子树、根节点、右子树，并且对左右子树也采用中序遍历
• 所以，在二叉树的前序遍历序列中，根节点值为序列的第一个元素值
• 在二叉树的中序遍历序列中，根节点位于序列的中间，且左子树的节点值位于根节点的值的左边，右子树的节点值位于根节点的值的右边
• 通过前序遍历序列和中序遍历序列，我们可以得到左子树和右子树的前序遍历序列和中序遍历序列，将问题转换为子问题求解
• 递归的基本思路如下：
• 确定前序遍历序列、中序遍历序列的边界：preorder_left、preorder_right、inorder_left、inorder_right
• 确定终止条件：preorder_left > preorder_right
• 确定根节点的值：preorder[ preorder_left ]
• 确定根节点的在中序遍历序列的位置：inorder_root = index[ preorder[ preorder_left ] ]，使用哈希表 index，存放中序遍历的值和索引的映射关系
• root->value = preorder[ preorder_left ]
• 左子树的节点数：size_left_subtree = inorder_root - inorder_left
• root->left = recursive(preorder_left + 1, preorder_left + size_left_subtree, inorder_left, inorder_root - 1)
• root->right = recursive(preorder_left + size_left_subtree + 1, preorder_right, inorder_root + 1, inorder_right)

C++实现：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
    unordered_map<int, int> index;

public:
    TreeNode* recursive(vector<int>& preorder, 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;

        root->left = recursive(preorder, inorder, preorder_left + 1, preorder_left + size_left_subtree, inorder_left, inorder_root - 1);

        root->right = recursive(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 size = preorder.size();
        if (size == 0)
            return nullptr;
        for (int i = 0; i < size; i++)
            index[inorder[i]] = i;
        return recursive(preorder, inorder, 0, size - 1, 0, size - 1);
    }
};

其实通过前序遍历序列中根节点的下标也可以完成遍历

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {

    unordered_map<int, int> index;

public:
    TreeNode* recursive(vector<int>& preorder, int preorder_root, int inorder_left, int inorder_right) {
        if (inorder_left > inorder_right)
            return nullptr;
        
        TreeNode* root = new TreeNode(preorder[preorder_root]);
        int inorder_root = index[preorder[preorder_root]];

        root->left = recursive(preorder, preorder_root + 1, inorder_left, inorder_root - 1);
        root->right = recursive(preorder, preorder_root + (inorder_root - inorder_left) + 1, inorder_root + 1, inorder_right);

        return root;
    }

    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        int size = preorder.size();
        if (size == 0)
            return nullptr;
        for (int i = 0; i < size; i++)
            index[inorder[i]] = i;
        return recursive(preorder, 0, 0, size-1);
    }
};