输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5

#include<vector>
#include<iostream>
using namespace std;

//参数是vector<int>  实现
// Definition for binary tree
struct TreeNode {
int val;
struct TreeNode *left;
struct TreeNode *right;
TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};

TreeNode* reConstructBinaryTree(vector<int> pre,vector<int> vin)
{
if(pre.size() == 0 || vin.size() == 0)
return NULL;
int rootValue = pre[0];
TreeNode* root = new TreeNode(rootValue);
if(pre.size() == 1&& vin.size() == 1 && vin[0] == pre[0])
return root;
vector<int> leftSubPre;
vector<int> rightSubPre;
vector<int> leftSubIn;
vector<int> rightSubIn;
vector<int>::iterator it = vin.begin();

int leftSubTreeLength = 0;
while(it != vin.end()&& rootValue != *it)
{
leftSubIn.push_back(*it);
++it;
++leftSubTreeLength;
}
++it;
int rightSubTreeLength = 0;
while(it != vin.end())
{
rightSubIn.push_back(*it);
++it;
++rightSubTreeLength;
}
it = pre.begin();
++it;
int i =1;
for(;i<leftSubTreeLength+1;++i)
{
leftSubPre.push_back(pre[i]);
}
for(;i<pre.size();++i)
{
rightSubPre.push_back(pre[i]);
}
if(leftSubTreeLength > 0)
root->left = reConstructBinaryTree(leftSubPre,leftSubIn);
if(rightSubTreeLength > 0)
root->right = reConstructBinaryTree(rightSubPre,rightSubIn);
return root;
}
void showInOrder(TreeNode *root)
{
if( root == NULL)
return;
showInOrder(root->left);
cout<<root->val<<" 	";
showInOrder(root->right);
}

int main()
{
vector<int>	Pre;
Pre.push_back(1);
Pre.push_back(2);
Pre.push_back(4);
Pre.push_back(7);
Pre.push_back(3);
Pre.push_back(5);
Pre.push_back(6);
Pre.push_back(8);
vector<int> In;
In.push_back(4);
In.push_back(7);
In.push_back(2);
In.push_back(1);
In.push_back(5);
In.push_back(3);
In.push_back(8);
In.push_back(6);
TreeNode* root = reConstructBinaryTree(Pre,In);
showInOrder(root);
return 0;
}

//参数是一般的数组的实现
/*
struct BinaryTreeNode
{
int  m_nValue;
struct BinaryTreeNode* m_pLeft;
struct BinaryTreeNode* m_pRight;
BinaryTreeNode(int val):m_nValue(val),m_pLeft(NULL),m_pRight(NULL)
{}
};
BinaryTreeNode* ConstructCore(int *startPreorder,int *endPreorder,int *startInorder,int *endInorder);
BinaryTreeNode* Construct(int *preorder,int *inoder,int  length)
{
if(preorder == NULL ||inoder == NULL||length<=0)
return NULL;
return ConstructCore(preorder,preorder + length -1,inoder,inoder+length-1);
}
BinaryTreeNode* ConstructCore(int *startPreorder,int *endPreorder,int *startInorder,int *endInorder)
{
int rootValue = startPreorder[0];
BinaryTreeNode* root = new BinaryTreeNode(rootValue);
if(startPreorder == endPreorder && startInorder == endInorder && startInorder[0] == startPreorder[0])
{
return root;
}
int *rootInInoder = startInorder;
while(rootInInoder != endInorder && rootValue != *rootInInoder)
{
++rootInInoder;
}

int leftSubTreeLength = rootInInoder - startInorder;
int rightSubTreeLength = endInorder - rootInInoder;
if(leftSubTreeLength >0)
{
root->m_pLeft = ConstructCore(startPreorder+1,startPreorder+leftSubTreeLength,startInorder,rootInInoder-1);
}
if(rightSubTreeLength > 0)
{
root->m_pRight = ConstructCore(startPreorder+leftSubTreeLength+1,endPreorder,rootInInoder + 1,endInorder);
}
return root;

}
void showInOrder(BinaryTreeNode *root)
{
if( root == NULL)
return;
showInOrder(root->m_pLeft);
cout<<root->m_nValue<<" 	";
showInOrder(root->m_pRight);
}
int main()
{
int pre[] = {1,2,4,7,3,5,6,8};
int in[] = {4,7,2,1,5,3,8,6};
BinaryTreeNode* root = Construct(pre,in,8);
showInOrder(root);
cout<<endl;
return 0;
}
*/
/*

*/