本文已参与「新人创作礼」活动，一起开启掘金创作之路。

用递归将二叉树的前中后序遍历都写过一遍之后，就可以着手写构造二叉树了 构造二叉树没有想象中的那么难，第二题很快就写出来了，但是第一题卡了我一手，主要是舍弃根节点没搞好 从前序和中序遍历构造二叉树

class Solution {
public:
    TreeNode* traversal(vector<int>& preorder, vector<int>& inorder) {
        //特判
        if(preorder.size() == 0) return nullptr;

        //找根节点
        int rootValue = preorder[0];
        TreeNode* root = new TreeNode(rootValue);

        //如果只有一个节点，则返回根节点
        if(preorder.size() == 1) return root;

        //找中序遍历的切割点
        int delimiterIndex = 0;
        for(delimiterIndex = 0; delimiterIndex < inorder.size(); delimiterIndex++) {
            if(inorder[delimiterIndex] == rootValue) break;
        }

        //切割中序数组[0, delimiterIndex)
        vector<int> leftInorder(inorder.begin(), inorder.begin() + delimiterIndex);
        vector<int> rightInorder(inorder.begin() + delimiterIndex + 1, inorder.end());

        //前序遍历需要舍弃第一个元素
        vector<int> leftPreorder(preorder.begin() + 1, preorder.begin() + 1 + leftInorder.size());
        vector<int> rightPreOrder(preorder.begin() + 1 + leftInorder.size(), preorder.end());

        //切割前序遍历的数组
        root->left = traversal(leftPreorder, leftInorder);
        root->right = traversal(rightPreOrder, rightInorder);

        return root;
    }
    
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        if(inorder.size() == 0 || preorder.size() == 0) return nullptr;

        return traversal(preorder, inorder);
    }
};

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

class Solution {
public:
    TreeNode* travarsal (vector<int>& inorder, vector<int>& postorder) {
        //特殊判定
        if(postorder.size() == 0) {
            return nullptr;
        }

        //找根节点
        int rootValue = postorder[postorder.size()-1];
        TreeNode* root = new TreeNode(rootValue);

        //如果只有一个节点，则返回根节点
        if(postorder.size() == 1) return root;

        //找中序遍历的切割点
        int delimiterIndex;
        for(delimiterIndex = 0; delimiterIndex < inorder.size(); delimiterIndex++) {
            if(inorder[delimiterIndex] == rootValue) {
                break;
            }
        }

        //切割中序数组
        vector<int> leftInOrder(inorder.begin(), inorder.begin() + delimiterIndex);
        vector<int> rightInOrder(inorder.begin() + delimiterIndex + 1, inorder.end());

        //把后序遍历的末尾元素删掉
        postorder.resize(postorder.size() - 1);

        //切割后序数组
        vector<int> leftPostOrder(postorder.begin(), postorder.begin() + leftInOrder.size());
        //vector<int> rightPostOrder(postorder.begin() + leftInOrder.size() + 1, postorder.end());
        vector<int> rightPostOrder(postorder.begin() + leftInOrder.size(), postorder.end());

        //构造二叉树
        root->left = travarsal(leftInOrder, leftPostOrder);
        root->right = travarsal(rightInOrder, rightPostOrder);

        return root;
    }
    
    //
    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        if(inorder.size() == 0 || postorder.size() == 0) return nullptr;
        return travarsal(inorder, postorder);
    }
};