Leetcode: Construct Binary Tree from Inorder and Postorder Traversal

Given inorder and postorder traversal of a tree, construct the binary tree.

Note:
You may assume that duplicates do not exist in the tree.

跟前题一样，递归。

/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode *buildTree(vector<int> &inorder, vector<int> &postorder) {
        if (inorder.empty()) {
            return NULL;
        }
        
        return buildTreeUtil(inorder, 0, inorder.size() - 1, postorder, 0, postorder.size() - 1);
    }
    
    TreeNode *buildTreeUtil(vector<int> &inorder, int instart, int inend, 
                            vector<int> &postorder, int poststart, int postend) {
        if (instart == inend)                             {
            return new TreeNode(inorder[instart]);
        }
        else if (instart > inend) {
            return NULL;
        }
        else {
            int mid = postorder[postend];
            int mid_index = findInVector(inorder, instart, inend, mid);
            int left = mid_index - instart;
            TreeNode *root = new TreeNode(mid);
            root->left = buildTreeUtil(inorder, instart, mid_index - 1, postorder, poststart, poststart + left - 1);
            root->right = buildTreeUtil(inorder, mid_index + 1, inend, postorder, poststart + left, postend - 1);
            return root;
        }
    }
    
    int findInVector(vector<int> &order, int start, int end, int target) {
        for (int i = start; i <= end; ++i) {
            if (order[i] == target) {
                return i;
            }
        }
        
        return -1;
    }
};

=======================第二次=======================

/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode *buildTree(vector<int> &inorder, vector<int> &postorder) {
        assert(inorder.size() == postorder.size());
        return constructTree(inorder, 0, inorder.size(), postorder, 0, postorder.size());
    }
    
    TreeNode *constructTree(vector<int> &inorder, int is, int ie, vector<int> &postorder, int ps, int pe) {
        if (is >= ie) {
            return NULL;
        }
        
        int rootIndex = is;
        for (; rootIndex < ie; ++rootIndex) {
            if (inorder[rootIndex] == postorder[pe-1]) {
                break;
            }
        }
        
        int leftNodes = rootIndex - is;
        TreeNode *root = new TreeNode(postorder[pe-1]);
        root->left = constructTree(inorder, is, rootIndex, postorder, ps, ps + leftNodes);
        root->right = constructTree(inorder, rootIndex + 1, ie, postorder, ps + leftNodes, pe - 1);
    }
};