根据二叉树 前序和中序 重建原二叉树

#include <iostream>

#include <vector>

using namespace std;




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




//方法1 
class Solution {
public:
    TreeNode* reConstructBinaryTree(vector<int> pre,vector<int> vin) {

if(pre.size()<=0 && vin.size()<=0)
return NULL;

vector<int> left_pre,left_vin,right_pre,right_vin;

int rootvalue = pre[0];
TreeNode* root = new TreeNode(rootvalue);


if(pre[0] == vin[0] && pre.size() == 1)
{
return root;
}

for(int i=0;i<vin.size();i++)
{
if(vin[i] == rootvalue)
{
for(int j=0;j<i;j++)
left_vin.push_back(vin[j]);
 
for(int j=1;j<=i;j++)
left_pre.push_back(pre[j]);
   

for(int j=i+1;j<pre.size();j++)
right_pre.push_back(pre[j]);

for(int j=i+1;j<vin.size();j++)
right_vin.push_back(vin[j]);

break;
}
}



if(left_pre.size() > 0)
{
root->left = reConstructBinaryTree(left_pre,left_vin);
}

if(right_pre.size() > 0)
{
root->right = reConstructBinaryTree(right_pre,right_vin);
}


return root;




    }
};




class Solution_1{
    public: 
TreeNode* reConstructBinaryTree(vector<int> pre,vector<int> in) {
        return reConBTree(pre,0,pre.size()-1,in,0,in.size()-1);
    }
    
    TreeNode* reConBTree(vector<int> pre,int preleft,int preright,vector<int> in,int inleft,int inright)
{

        if(preleft > preright || inleft> inright)//当到达边界条件时候返回NULL
            return NULL;
            
            
        //新建一个TreeNode
        TreeNode* root = new TreeNode(pre[preleft]);
        
        
        //用中序数组进行输入边界的遍历
        for(int i = inleft; i<= inright; i++)
{

            if(pre[preleft] == in[i]){

                //重构左子树，注意边界条件
                root->left = reConBTree(pre,preleft+1,preleft+i-inleft,in,inleft,i-1);
                
                //重构右子树，注意边界条件
                root->right = reConBTree(pre,preleft+i+1-inleft,preright,in,i+1,inright);
                
            }
        }
        
        return root;     
    }
}










int main()
{
int n1[8] = {1,2,4,7,3,5,6,8};              //二叉树前序遍历序列
int n2[8] = {4,7,2,1,5,3,8,6};              //二叉树中序遍历序列

       //vector<int> pre(&n1[0],&n1[7]);
      //vector<int> vin(&n2[0],&n2[7]);
//注意上面这样只能初始化前7个元素，而不是所有的，需要指到后一位地址处 

vector<int> pre,vin;
pre.reserve(8);
vin.reserve(8);

pre.insert(pre.begin(),&n1[0],&n1[8]);
vin.insert(vin.begin(),&n2[0],&n2[8]);




Solution s;
TreeNode * root = new TreeNode(0);
root = s.reConstructBinaryTree(pre,vin);
cout << root->left->left->right->val<< endl;


}