算法题目---重建二叉树

输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。

假设输入的前序遍历和中序遍历的结果中都不含重复的数字。

using namespace std;

struct BinaryTreeNode
{
    int m_nValue;
    BinaryTreeNode* m_pLeft;
    BinaryTreeNode* m_pRight;
};

BinaryTreeNode* ConstructCore(int *startPreorder,int*endPreorder,
int *startInorder,int*endInorder)
{
    int rootValue = startPreorder[0];
    BinaryTreeNode* root = new BinaryTreeNode();
    root->m_nValue = rootValue;
    root->m_pLeft = root->m_pRight = NULL;

    if(startPreorder == endPreorder)
    {
        if(startInorder == endInorder && *startPreorder == *startInorder)
            return root;
        else
            printf("error\n");
    }
    
    int *rootInorder = startInorder;
    while(rootInorder <= endInorder && *rootInorder != rootValue)
        ++rootInorder;

    if(rootInorder == endInorder && *rootInorder != rootValue)
        printf("error\n");
    
    int leftLength = rootInorder - startInorder;
    int *leftPreorderEnd = startPreorder + leftLength;

    if(leftLength > 0)
    {
        root->m_pLeft = ConstructCore(startPreorder+1,leftPreorderEnd,
                                    startInorder,rootInorder-1);
    }
    if(leftLength < endPreorder - startPreorder)
    {
        root->m_pRight = ConstructCore(leftPreorderEnd+1,endPreorder,
                                            rootInorder+1,endInorder);
    }
    return root;
}

BinaryTreeNode* 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 PrintTreeNode(BinaryTreeNode *pNode)
{
     if(pNode != NULL)
    {
        printf("value of this node is: %d\n", pNode->m_nValue);

        if(pNode->m_pLeft != NULL)
            printf("value of its left child is: %d.\n", pNode->m_pLeft->m_nValue);
        else
            printf("left child is null.\n");

        if(pNode->m_pRight != NULL)
            printf("value of its right child is: %d.\n", pNode->m_pRight->m_nValue);
        else
            printf("right child is null.\n");
    }
    else
    {
        printf("this node is null.\n");
    }

    printf("\n");
}

void PrintTree(BinaryTreeNode* pRoot)
{
    PrintTreeNode(pRoot);
    if(pRoot != NULL)
    {
        if(pRoot->m_pLeft != NULL)
        {
            PrintTree(pRoot->m_pLeft);
        }
        if(pRoot->m_pRight != NULL)
        {
            PrintTree(pRoot->m_pRight);
        }
    }
}

void DestroyTree(BinaryTreeNode* pRoot)
{
    if(pRoot != NULL)
    {
        BinaryTreeNode* pLeft = pRoot->m_pLeft;
        BinaryTreeNode* pRight = pRoot->m_pRight;

        delete pRoot;
        pRoot = NULL;
        
        DestroyTree(pLeft);
        DestroyTree(pRight);
    }
}

void test()
{
        //const int length = 8;
      //int preorder[length] = {1, 2, 4, 7, 3, 5, 6, 8};
    //int inorder[length] = {4, 7, 2, 1, 5, 3, 8, 6};
    const int length = 7;
    int preorder[length] = {1, 2, 4, 5, 3, 6, 7};
    int inorder[length] = {4, 2, 5, 1, 6, 3, 7};
    BinaryTreeNode * root = Construct( preorder, inorder, length);
        PrintTree(root);
        DestroyTree(root);
}