1.递归，时间和空间复杂度爆炸
1 int pre_id = 0;
2 unordered_map<int, int> map;
3 TreeNode* recur(int left, int right,vector<int> preorder,vector<int> inorder)
4 {
5 if (left == right)
6 {
7 return nullptr;
8 }
9 int val = preorder[pre_id];
10 TreeNode* root = new TreeNode(val);
11 int index = map[val];
12 pre_id++;
13 root->left = recur(left, index,preorder,inorder);
14 root->right = recur(index + 1, right,preorder,inorder);
15 return root;
16 }
17 TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
18 int left = 0;
19 int right = inorder.size();
20 int id = 0;
21 for (auto e : inorder)
22 {
23 map[e] = id++;
24 }
25 TreeNode* root = recur(left, right,preorder,inorder);
26 return root;
27 }
2.非递归
就是个屁算法，反正我是不懂它为什么能算出来。。
1 class Solution {
2 public:
3 TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
4 int pre = 0, in = 0;
5 stack<TreeNode*> use;
6 if (!preorder.size())
7 return nullptr;
8 TreeNode* root = new TreeNode(preorder[0]);
9 TreeNode* cur = root;
10 use.push(root);
11 pre++;
12 while (pre != preorder.size())
13 {
14 if(cur->val == inorder[in])
15 {
16 while (!use.empty() && inorder[in] == use.top()->val)
17 {
18 cur = use.top();
19 use.pop();
20 in++;
21 }
22 cur->right = new TreeNode(preorder[pre]);
23 cur = cur->right;
24 use.push(cur);
25 pre++;
26 }
27 else
28 {
29 TreeNode* temp = new TreeNode(preorder[pre]);
30 cur->left = temp;
31 cur = cur->left;
32 use.push(cur);
33 pre++;
34 }
35 }
36 return root;
37 }
38 };