leetcode|给定两个遍历序列，构造二叉树

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

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;

        root->left = myBuildTree(preorder, inorder, preorder_left + 1, preorder_left + size_left_subtree, inorder_left, inorder_root - 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);
    }
};

从中序与后序遍历序列构造二叉树

class Solution {
    int post_idx;
    unordered_map<int, int> idx_map;
public:
    TreeNode* helper(int in_left, int in_right, vector<int>& inorder, vector<int>& postorder){
        // 如果这里没有节点构造二叉树了，就结束
        if (in_left > in_right) {
            return nullptr;
        }

        // 选择 post_idx 位置的元素作为当前子树根节点
        int root_val = postorder[post_idx];
        TreeNode* root = new TreeNode(root_val);

        // 根据 root 所在位置分成左右两棵子树
        int index = idx_map[root_val];

        // 下标减一
        post_idx--;
        // 构造右子树
        root->right = helper(index + 1, in_right, inorder, postorder);
        // 构造左子树
        root->left = helper(in_left, index - 1, inorder, postorder);
        return root;
    }
    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        // 从后序遍历的最后一个元素开始
        post_idx = (int)postorder.size() - 1;

        // 建立（元素，下标）键值对的哈希表
        int idx = 0;
        for (auto& val : inorder) {
            idx_map[val] = idx++;
        }
        return helper(0, (int)inorder.size() - 1, inorder, postorder);
    }
};

从前序与后序遍历序列构造二叉树

class Solution {
public:
    unordered_map<int,int> mapre;
    unordered_map<int,int> mappost;
    TreeNode* myBuildTree(vector<int>& pre,vector<int> post,int left,int right){
        //过程中只传递了前序遍历对应子树的节点值
        if(left>right){
            return NULL;
        }
        //新建树节点,前序遍历的第一个节点就是我们要找的根结点
        TreeNode* root = new TreeNode(pre[left]);
        if(right == left){//只剩下这最后一个节点
            return root;
        }
        
        //1.获得前序中的根结点在后序中的位置-1的值
        //2.获得上述值在前序遍历中的位置下标       

        //更新右子树----后序遍历中根节点的前一个节点就是右子树的根结点
        int left1 = mapre[ post[mappost [pre[left]] -1]];

        //更新左子树
        int right1 = mapre[ post[mappost[pre[left]] -1] ]-1;

        root->left = myBuildTree(pre, post, left + 1, right1);
        root->right = myBuildTree(pre, post, left1, right);
        return root;

    }
    TreeNode* constructFromPrePost(vector<int>& pre, vector<int>& post) {
        //根据前序和后序构造二叉树
        for(int i=0;i<pre.size();i++){//键为数组中的值，值为下标，方便快速查找
            mapre[pre[i]] = i;
            mappost[post[i]] = i;
        }   
        return myBuildTree(pre,post,0,pre.size()-1);
    }
};