leetcode—6/4

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

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

TreeNode* build(vector<int>& preorder, vector<int>& inorder, int s1, int e1, int s2, int e2)
    {
        if(s1 > e1 || s2 > e2)
        {
            return nullptr;
        }
        int index;
        for(int i = s2; i <= e2; i++)
        {
            if(inorder[i] == preorder[s1])
            {
                index = i;
                break;
            }
        }
        int left_num = index - s2;
        int right_num = e2 - index; 
        TreeNode* root = new TreeNode(preorder[s1]);
        root -> left = build(preorder, inorder, s1 + 1, s1 + left_num, s2, index - 1);
        root -> right = build(preorder, inorder, e1 + 1 - right_num, e1, index + 1, e2);
        return root;
    }
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        return build(preorder, inorder, 0, preorder.size() - 1, 0, inorder.size() - 1);
    }

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

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

TreeNode* build(vector<int>& inorder, vector<int>& postorder, int s1, int e1, int s2, int e2)
    {
        if(s1 > e1 || s2 > e2)
        {
            return nullptr;
        }
        int index;
        for(int i = s1; i <= e1; i++)
        {
            if(inorder[i] == postorder[e2])
            {
                index = i;
                break;
            }
        }
        int left_num = index - s1;
        int right_num = e1 - index; 
        TreeNode* root = new TreeNode(postorder[e2]);
        root -> left = build(inorder, postorder, s1, index - 1, s2, left_num + s2 - 1);
        root -> right = build(inorder, postorder, index + 1, e1, e2 - right_num, e2 - 1);
        return root;
    }

    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        return build(inorder, postorder, 0, inorder.size() - 1, 0, postorder.size() - 1);
    }