从前序和中序遍历构造二叉树

从前序和中序遍历构造二叉树

描述

根据一棵树的前序遍历与中序遍历构造二叉树。

注意:
你可以假设树中没有重复的元素。

例如，给出

前序遍历 preorder = [3,9,20,15,7]
中序遍历 inorder = [9,3,15,20,7]
返回如下的二叉树：

3

/
9 20
/
15 7

思路和代码

没有思路，学过数据结构的好像都会，仔细斟酌一下代码即可。
树最常见的思路就是处理根节点，然后递归处理左子树，递归处理右子树。
用两个指针，p_start，p_end表示先序序列的首尾结点，i_start, i_end表示中序序列的首尾结点。

/**
 * 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 {
public:
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        return build(preorder, 0, preorder.size(), inorder, 0, inorder.size());
    }

    TreeNode* build(vector<int>& preorder, int p_start, int p_end, vector<int>& inorder, int i_start, int i_end){
        if(p_start == p_end)
            return NULL;
        int root_val = preorder[p_start];
        TreeNode* root = new TreeNode(root_val);

        //遍历中序数组，找到root_val所在位置，位置之前的都属于左子树，之后的都属于右子树
        int idx = 0;
        for(int i=i_start; i<i_end; i++){
            if(root_val == inorder[i]){
                idx = i;
                break;
            }
        }

        //左子树为i_start到idx
        int left_num = idx - i_start;

        //递归遍历左子树
        root->left = build(preorder, p_start+1, p_start+left_num+1, inorder, i_start, idx);
        root->right = build(preorder, p_start+left_num+1, p_end, inorder, idx+1, i_end);
        return root;
    }
};

改进

对上面代码可以看到，每次都需要遍历中序数组，所以可以用哈希表存储中序数组值和索引。

/**
 * 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 {
public:
    map<int, int> hash;
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        for(int i=0; i<inorder.size(); i++){
            hash[inorder[i]] = i;
        }
        return build(preorder, 0, preorder.size(), inorder, 0, inorder.size());
    }

    TreeNode* build(vector<int>& preorder, int p_start, int p_end, vector<int>& inorder, int i_start, int i_end){
        if(p_start == p_end)
            return NULL;
        int root_val = preorder[p_start];
        TreeNode* root = new TreeNode(root_val);

        //遍历中序数组，找到root_val所在位置，位置之前的都属于左子树，之后的都属于右子树
        int idx = hash[root_val];

        //左子树为i_start到idx
        int left_num = idx - i_start;

        //递归遍历左子树
        root->left = build(preorder, p_start+1, p_start+left_num+1, inorder, i_start, idx);
        root->right = build(preorder, p_start+left_num+1, p_end, inorder, idx+1, i_end);
        return root;
    }
};

从中序和后序遍历构造二叉树

思路同上

/**
 * 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 {
public:
    map<int, int> hash;
    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        for(int i=0; i<inorder.size(); i++){
            hash[inorder[i]] = i;
        }
        return build(inorder, 0, inorder.size(), postorder, 0, postorder.size());
    }

    TreeNode* build(vector<int>& inorder, int i_start, int i_end, vector<int>& postorder, int p_start, int p_end)
    {
        if(p_start == p_end)
            return NULL;
        
        //定义根节点
        int root_val = postorder[p_end - 1];
        TreeNode* root = new TreeNode(root_val);

        //找到中序根所在的位置
        int idx = hash[root_val];
        int left_num = idx - i_start;

        root->left = build(inorder, i_start, idx, postorder, p_start, p_start+left_num);
        root->right = build(inorder, idx+1, i_end, postorder, p_start+left_num, p_end-1);
        return root;
    }
};