Leetcode: 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 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> &preorder, vector<int> &inorder) {
if (preorder.empty()) {
return NULL;
}

return buildTreeUtil(preorder, 0, preorder.size() - 1, inorder, 0, inorder.size() - 1);
}

TreeNode *buildTreeUtil(vector<int> &preorder, int prestart, int preend,
vector<int> &inorder, int instart, int inend) {
if (prestart == preend)                             {
return new TreeNode(preorder[prestart]);
}
else if (prestart > preend) {
return NULL;
}
else {
int mid = preorder[prestart];
int mid_index = findInVector(inorder, instart, inend, mid);
int left = mid_index - instart;
TreeNode *root = new TreeNode(mid);
root->left = buildTreeUtil(preorder, prestart + 1, prestart + left, inorder, instart, mid_index - 1);
root->right = buildTreeUtil(preorder, prestart + left + 1, preend, inorder, mid_index + 1, inend);
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> &preorder, vector<int> &inorder) {
assert(preorder.size() == inorder.size());
return constructTree(preorder, 0, preorder.size(), inorder, 0, inorder.size());
}

TreeNode *constructTree(vector<int> &preorder, int pres, int pree, vector<int> &inorder, int ins, int ine) {
if (pres >= pree) {
return NULL;
}

int rootIndex = ins;
for (; rootIndex < ine; ++rootIndex) {
if (inorder[rootIndex] == preorder[pres]) {
break;
}
}

int leftNodes = rootIndex - ins;
TreeNode *root = new TreeNode(preorder[pres]);
root->left = constructTree(preorder, pres + 1, pres + 1 + leftNodes, inorder, ins, ins + leftNodes);
root->right = constructTree(preorder, pres + 1 + leftNodes, pree, inorder, rootIndex + 1, ine);
}
};