重建二叉树

重建二叉树

描述

输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。

示例1

输入：

[1,2,3,4,5,6,7],[3,2,4,1,6,5,7]

返回值：

{1,2,5,3,4,6,7}

题目难度：二星
考察知识：树，递归

---

题解

本题解是初学算法的对象，一步步从不会到会的详细讲解。

方法：递归算法

前置知识：

二叉树的前序遍历：根左右
二叉树的中序遍历：左根右
二叉树的的后序遍历：左右根

建树的相关步骤：

// 树结点
struct TreeNode {
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int x) : val(x), left(nullptr), right(nullptr) { }
};
// 建树的伪代码
TreeNode* build(1...) {
    if (2...) return nullptr;
    TreeNode *root = new TreeNode(3...);
    root->left = build(4...); // 递归建立左子树
    root->right = build(5...); // 递归建立右子树
    return root;
}

如果大家知道了上述建树的伪代码后，那么括号应该填什么呢？
假设 1.是一个数组vector，是需要建树的元素
那么 2.数组为空，然后 return nullptr.
\3. 根结点的值
\4. 左子树的数组元素
\5. 右子树的数组元素

如果把1.从数组再简化到数组的下标，如下：

// 假设元素在数组v中，并且头结点的下标为 root_index, first < root_index < last,
// 这里只是会的容易讲解
TreeNode* build(int first, int last) {
    if (first > last) return nullptr;
    TreeNode *root = new TreeNode(v[root_index]);
    root->left = build(first, root_index - 1);
    root->right = build(root_index + 1, last);
    return root;
} 

那么大家现在会有疑问，root_index 从哪来的？
如果有了上面的知识做铺垫，那么本题就很容易了。
从前序遍历可知，前序遍历数组pre的首元素就是二叉树的根结点，然后根据根结点的值在中序遍历中找到根结点的位置，那么根结点左边就为左子树的序列，
根结点右边就是右子树的序列。

以本题例子为例：
前序遍历序列： {1,2,4,7,3,5,6,8}
中序遍历序列： {4,7,2,1,5,3,8,6}
第一步：根结点为1
第二步：根结点在中序遍历序列中下标为3的位置，那么[0…2]就为左子树，[4…7]就为右子树
只不过现在build()参数中为2个数组，道理一样，维护2个数组的下标就行了。
那么现在这道题就可以解决了。

TreeNode* rebuild(vector<int>& pre, int pre_left, int pre_right, vector<int>& vin, int vin_left, int vin_right) {
        if (pre_left > pre_right) return nullptr;
        TreeNode* root = new TreeNode(pre[pre_left]); // 根结点
        int root_index = vin_left;
        while (root_index <= vin_right && vin[root_index++] != pre[pre_left]);
        --root_index; // 中序遍历中头结点的下标
        root->left = rebuild(pre, pre_left+1, pre_left+root_index-vin_left, vin, vin_left, root_index-1);
        root->right = rebuild(pre, pre_left+root_index-vin_left+1, pre_right, vin, root_index+1, vin_right);
        return root;
    }
    TreeNode* reConstructBinaryTree(vector<int> pre, vector<int> vin) {
        return rebuild(pre, 0, pre.size()-1, vin, 0, vin.size()-1);
    }
};

其中递归左子树中，前序遍历的结尾为：pre_left + root_index - vin_left 的解释。

root_index - vin_left为根结点左边有几个元素
pre_left + root_index - vin_left 为从pre_left开始往后推这么多元素

---

更优美的写法

class Solution {
public:
TreeNode* rebuild(vector& pre, int pre_left, int pre_right, vector& vin, int vin_left, int vin_right) {
if (pre_left > pre_right) return nullptr;

    TreeNode* root = new TreeNode(pre_left);
    for (int i=vin_left; i<=vin_right; ++i) {
        if (vin[i] == root_val) {
            root->left = rebuild(pre, pre_left+1, pre_left+i-vin_left, vin, vin_left, i-1);
            root->right = rebuild(pre, pre_left+i-vin_left+1, pre_right, vin, i+1, vin_right);
            break;
        }
    }
    return root;
}
TreeNode* reConstructBinaryTree(vector<int> pre，vector<int> vin) {
    return rebuild(pre, 0, pre.size()-1, vin, 0, vin.size()-1);
}

};

附：二叉树的先序中序后序遍历

二叉树的先序中序后序遍历