重建二叉树

/*
    重建二叉树
    pre  1,2,4,7,3,5,6,8
    in   4,7,2,1,5,3,8,6
*/

struct BinTree
{
    int m_nValue;
    BinTree* m_pLeft;
    BinTree* m_pRight;
    BinTree(int x) :
        m_nValue(x), m_pLeft(NULL), m_pRight(NULL)
    {}
    BinTree(int x,BinTree* l,BinTree* r) :
        m_nValue(x), m_pLeft(l), m_pRight(r)
    {}
};

BinTree* ConstructCore(int* startpre, int *endpre, int* startin, int* endin)
{
    int rootvalue = startpre[0];
    BinTree* root = new BinTree(rootvalue);

    if (startpre == endpre)
    {
        if (startin == endin && *startpre == *startin)
            return root;
        else
            throw std::exception("invalid input");
    }

    int *rootIn = startin;
    while (rootIn <= endin && *rootIn != rootvalue)
        ++rootIn;

    if (rootIn == endin && *rootIn != rootvalue)
        throw std::exception("invalid input");

    int LeftLength = rootIn - startin;
    int* LeftPreorderEnd = startpre + LeftLength;

    if (LeftLength > 0)
    {
        root->m_pLeft = ConstructCore(startpre + 1, LeftPreorderEnd, startin, rootIn - 1);
    }
    if (LeftLength < endpre - startpre)
    {
        root->m_pRight = ConstructCore(LeftPreorderEnd + 1, endpre, rootIn + 1, endin);
    }
    return root;
}

BinTree* Construct(int* pre, int* in, int length)
{
    if (pre == NULL || in == NULL || length <= 0)
        return NULL;

    return ConstructCore(pre, pre + length - 1, in, in + length - 1);
}

//void test()
//{
//  int pre[8] = { 1,2,4,7,3,5,6,8 };
//  int in[8] = { 4,7,2,1,5,3,8,6 };
//
//  BinTree* root = Construct(pre, in, 8);
//  getchar();
//}