Leetcode 105. Construct Binary Tree from Preorder and Inorder Traversal

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

Note:

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

/**
* 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:
using CIt = vector<int>::const_iterator;
TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
return rebuild(preorder.begin(), preorder.end(), inorder.begin(), inorder.end());
}

private:

// b1 and e1 are for preorder
TreeNode* rebuild(CIt b1, CIt e1, CIt b2, CIt e2) {
if (e1 == b1) return nullptr;
int val = *b1;
TreeNode* ret = new TreeNode(val);
CIt it = find(b2, e2, val);

ret->left = rebuild(b1 + 1, b1 + 1 + (it - b2), b2, it);
ret->right  = rebuild(b1 + 1 + (it - b2),e1, it + 1, e2);
return ret;
}
};

/**
* 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* buildTree(vector<int>& preorder, vector<int>& inorder) {
if (preorder.size() == 0) return nullptr;
stack<TreeNode*> s;
unordered_map<int, int> m;
for (size_t i = 0; i != inorder.size(); ++i) {
m[inorder[i]] = i;
}
TreeNode* root = new TreeNode(preorder[0]);
s.push(root);
TreeNode* p = root;

size_t id = 1;

while (id != preorder.size()) {

if (m[preorder[id]] < m[p->val]) {
p->left = new TreeNode(preorder[id]);
s.push(p->left);
p = p->left;
++id;
} else {
// 当前 root
s.pop();

// bijiao上一个 root
if (s.empty() || m[preorder[id]] < m[s.top()->val]){
p->right = new TreeNode(preorder[id]);
s.push(p->right);
p = p->right;
++id;
} else {
p = s.top();
}
}
}
return root;

}
};