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

注意：1、仅根据前序和后序无法构建唯一的二叉树；2、二叉树前序遍历，第一个数字总是树的根节点的值；3、中序遍历中，根节点的值在序列的中间，左子树的值子在根节点的值的左边，右字树的值在根节点的值的右边；4、思路：递归

#include <iostream>
#include <stdlib.h>
using namespace std;
struct Node{
    int value;
    Node* left;
    Node* right;
};

Node* ConstructCore(int *startPreorder,int *endPreorder,int *startInorder,int *endInorder){
    Node* root=new Node();
    root->value=startPreorder[0];
    root->left=root->right=NULL;

    //如果仅有一个节点
    if(startPreorder == endPreorder){
        if(startInorder == endInorder && *startPreorder == *startInorder){
            return root;
        }
        else{
            cout<<"Invalid input"<<endl;
            exit(1);
        }
    }

    //在中序遍历中找到根节点的值
    int *rootInorder=startInorder;
    while( rootInorder<=endInorder && *rootInorder!=root->value){
        rootInorder++;
    }

    if(rootInorder == endInorder && *rootInorder != root->value){
        cout<<"Invalid input"<<endl;
        exit(1);
    }

    int leftLength=rootInorder-startInorder;
    int *leftPreorderEnd=startPreorder+leftLength;

    //递归调用，构建
    if(leftLength>0){
        root->left=ConstructCore(startPreorder+1,leftPreorderEnd,startInorder,rootInorder-1);
    }

    if(leftLength < endPreorder - startPreorder){
        root->right=ConstructCore(leftPreorderEnd+1,endPreorder,rootInorder+1,endInorder);
    }

    return root;
}
//构建函数
Node* Construct(int *preorder,int * inorder,int length){
    if( preorder == NULL || inorder == NULL || length<=0){
        return NULL;
    }
    return ConstructCore(preorder,preorder+length-1,inorder,inorder+length-1);
}
void pre_order(Node* root){
    if(root != NULL){
        cout<<root->value<<" ";
        pre_order(root->left);
        pre_order(root->right);
    }
}

void in_order(Node* root){
    if(root != NULL){
        in_order(root->left);
        cout<<root->value<<" ";
        in_order(root->right);
    }
}

void post_order(Node* root){
    if(root != NULL){
        post_order(root->left);
        post_order(root->right);
        cout<<root->value<<" ";
    }
}

int main(){
    int length=8;
    int preorder[]={1,2,4,7,3,5,6,8};
    int inorder[]={4,7,2,1,5,3,8,6};
    Node* treeRoot=Construct(preorder,inorder,length);
    cout<<"Test pre_order"<<endl;
    pre_order(treeRoot);
    cout<<endl<<"Test in_order"<<endl;
    in_order(treeRoot);
    cout<<endl<<"Test post_order"<<endl;
    post_order(treeRoot);
}
/*
Test pre_order
1 2 4 7 3 5 6 8
Test in_order
4 7 2 1 5 3 8 6
Test post_order
7 4 2 5 8 6 3 1
Process returned 0 (0x0)   execution time : 0.259 s
Press any key to continue.
*/