根据两种遍历方式构造二叉树

规律：

• 前序遍历的头节点为根节点，后面是左子树或右子树的联合；
• 中序遍历的头节点左面是左子树，右面是右子树，只需要找到根节点即可；
• 后序遍历尾节点为根节点，前面是左子树或右子树的联合；
• 前序遍历和后序遍历不能确定唯一二叉树，因为在只有一个子树的时候无法确定左右。

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

思路：找到根节点在中序遍历中的位置，递归求解

/**
 * 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 * travel(const vector<int>& preorder, const vector<int>& inorder, int l1, int r1, int l2, int r2, const unordered_map<int, int> &in_pos) {
        if (l1 > r1 || l2 > r2) {
            return nullptr;
        }
        // int i = 0;
        // for (i = l2; i <= r2; ++i) {
        //     if (inorder[i] == preorder[l1]) {
        //         break;
        //     }
        // }
        // save position to avoid enumeration because inorder are no repetitions
        int i = in_pos.at(preorder[l1]);
        int len = i - l2;
        TreeNode *root = new TreeNode(preorder[l1]);
        root->left = travel(preorder, inorder, l1 + 1, l1 + len , l2, i-1, in_pos);
        root->right = travel(preorder, inorder, l1+len+1, r1, i+1, r2, in_pos);
        return root;
    }
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        unordered_map<int, int> in_pos;
        for (int i = 0; i < inorder.size(); ++i) {
            in_pos[inorder[i]] = i;
        }
        return travel(preorder, inorder, 0, preorder.size() - 1, 0, inorder.size() - 1, in_pos);
    }
};

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

思路同上

/**
 * 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 * travel(const vector<int>& postorder, const vector<int>& inorder, int l1, int r1, int l2, int r2, const unordered_map<int, int> &in_pos) {
        if (l1 > r1 || l2 > r2) {
            return nullptr;
        }
        int i = in_pos.at(postorder[r1]);
        int len = i - l2;
        TreeNode *root = new TreeNode(postorder[r1]);
        root->left = travel(postorder, inorder, l1, l1 + len - 1 , l2, i-1, in_pos);
        root->right = travel(postorder, inorder, l1+len, r1 - 1, i+1, r2, in_pos);
        return root;
    }
    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        unordered_map<int, int> in_pos;
        for (int i = 0; i < inorder.size(); ++i) {
            in_pos[inorder[i]] = i;
        }
        return travel(postorder, inorder, 0, postorder.size() - 1, 0, inorder.size() - 1, in_pos); 
    }
};

根据前序和后序遍历构造二叉树

思路：从前序遍历得到左子树的根节点（头节点），从而找到该左子树在后序遍历中的末尾，递归求解

/**
 * 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 *travel(const vector<int>& pre, const vector<int>& post, int l1, int r1, int l2, int r2, const unordered_map<int, int> &post_pos) {
        if (l1 > r1 || l2 > r2) {
            return nullptr;
        }

        TreeNode *root = new TreeNode(pre[l1]);
        if (l1 == r1 || l2 == r2) {
            return root;
        }
        int i = post_pos.at(pre[l1 + 1]);
        int len = i - l2 + 1;
        root->left = travel(pre, post, l1 + 1, l1 + len, l2, i, post_pos);
        root->right = travel(pre, post, l1 + len + 1, r1, i+1, r2 - 1, post_pos);
        return root;
    }
    TreeNode* constructFromPrePost(vector<int>& pre, vector<int>& post) {
        unordered_map<int, int> post_pos;
        for (int i = 0; i < post.size(); ++i) {
            post_pos[post[i]] = i;
        }
        return travel(pre, post, 0, pre.size() - 1, 0, post.size() - 1, post_pos);
    }
};