Construct a tree from Inorder and Level order traversals

Given inorder and level-order traversals of a Binary Tree, construct the Binary Tree. Following is an example to illustrate the problem.

BinaryTree

Input: Two arrays that represent Inorder and level order traversals of a Binary Tree
in[]    = {4, 8, 10, 12, 14, 20, 22};
level[] = {20, 8, 22, 4, 12, 10, 14};

Output: Construct the tree represented by the two arrays. For the above two arrays, the constructed tree is shown in the diagram.

geeksforgeeks的做法是，每次以in和level数组去构建以level[0]为根结点的树。生成下一次level结点的开销是O(n)，所以整个时间复杂度是O(n^2)。

我的做法是：

1. 先计算出所有点的层序号。基于这个规律，如果两个元素在同一层，那么后面的数在中序遍历的顺序中，必然也是处于后面；如果后面的数在中序遍历中处于前面，那么必然是处于下一层。O(n)可以做到，但是需要先对两个数组作索引。

2. 从最后一层开始，每一层的左结点，是在inorder序列中，在它左边的连续序列（该序列必须保证层数比它大）中第一个层数=它的层数+1的数。右结点同理。查找左右结点的开销需要O(n)。

所以最终可以做到$O(n^2)$。

 struct TreeNode {
     int val;
     TreeNode *left, *right;
     TreeNode(int v): val(v), left(NULL), right(NULL) {}
 };

 void print(TreeNode *root) {
     if (root == NULL) {
         cout << "NULL ";
     } else {
         cout << root->val << " ";
         print(root->left);
         print(root->right);
     }
 }

 struct Indices {
     int inOrderIndex;
     int levelOrderIndex;
     int level;
 };

 int main(int argc, char** argv) {
     vector<int> inOrder = {, , , , , , };
     vector<int> levelOrder = {, , , , , , };

     // build indices
     unordered_map<int, Indices> indices;
     for (int i = ; i < inOrder.size(); ++i) {
         if (indices.count(inOrder[i]) <= ) {
             indices[inOrder[i]] = {i, , };
         } else {
             indices[inOrder[i]].inOrderIndex = i;
         }
         if (indices.count(levelOrder[i]) <= ) {
             indices[levelOrder[i]] = {, i, };
         } else {
             indices[levelOrder[i]].levelOrderIndex = i;
         }
     }

     // get level no. for each number
     int level = ;
     for (int i = ; i < levelOrder.size(); ++i) {
         if (indices[levelOrder[i]].inOrderIndex < indices[levelOrder[i - ]].inOrderIndex) {
             ++level;
         }
         indices[levelOrder[i]].level = level;
     }

     unordered_map<int, TreeNode*> nodes;
     for (int i = levelOrder.size() - ; i >= ; --i) {
         nodes[levelOrder[i]] = new TreeNode(levelOrder[i]);
         int index = indices[levelOrder[i]].inOrderIndex;
         for (int j = index - ; j >=  && indices[inOrder[j]].level > indices[inOrder[index]].level; --j) {
             if (indices[inOrder[j]].level == indices[inOrder[index]].level + ) {
                 nodes[levelOrder[i]]->left = nodes[inOrder[j]];
                 break;
             }
         }
         for (int j = index + ; j < levelOrder.size() && indices[inOrder[j]].level > indices[inOrder[index]].level; ++j) {
             if (indices[inOrder[j]].level == indices[inOrder[index]].level + ) {
                 nodes[levelOrder[i]]->right = nodes[inOrder[j]];
                 break;
             }
         }
     }
     print(nodes[levelOrder[]]);
     cout << endl;
     return ;
 }