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

#ifndef BINARYTREE_H
#define BINARYTREE_H
#include <cstdio>

struct BinaryTreeNode
{
    int             m_nValue;
    BinaryTreeNode* m_nLeft;
    BinaryTreeNode* m_nRight;
};

BinaryTreeNode* CreatBinaryTreeNode(int value);
void ConnectTreeNodes(BinaryTreeNode* pParent,BinaryTreeNode* pLeft,BinaryTreeNode* pRight);
void PrintTreeNode(const BinaryTreeNode* pRoot);
void PrintTree(const BinaryTreeNode* pRoot);
void DestroyTree(BinaryTreeNode* pRoot);


BinaryTreeNode* CreatBinaryTreeNode(int value)
{
    BinaryTreeNode* pNode = new BinaryTreeNode();
    pNode->m_nValue = value;
    pNode->m_nLeft = nullptr;
    pNode->m_nRight =nullptr;

    return pNode;
}
void ConnectTreeNodes(BinaryTreeNode* pParent,BinaryTreeNode* pLeft,BinaryTreeNode* pRight)
{
    if(pParent != nullptr)
    {
        pParent->m_nLeft = pLeft;
        pParent->m_nRight = pRight;
    }
}
void PrintTreeNode(const BinaryTreeNode* pNode)
{
    if(pNode != nullptr)
    {
        printf("value of this node is: %d\n",pNode->m_nValue);

        if(pNode->m_nLeft != nullptr)
        {
            printf("value of its left node is %d\n",pNode->m_nLeft->m_nValue);
        }
        else
        {
            printf("left child is nullptr\n");
        }

        if(pNode->m_nRight != nullptr)
        {
            printf("value of its right is: %d\n",pNode->m_nRight->m_nValue);
        }
        else
        {
            printf("right child is nullptr\n");
        }
    }

    printf("\n");
}
void PrintTree(const BinaryTreeNode* pRoot)
{
    PrintTreeNode(pRoot);
    if(pRoot != nullptr)
    {
        if(pRoot->m_nLeft != nullptr)
            PrintTree(pRoot->m_nLeft);

        if(pRoot->m_nRight != nullptr)
            PrintTree(pRoot->m_nRight);
    }
}
void DestroyTree(BinaryTreeNode* pRoot)
{
    if(pRoot != nullptr)
    {
        BinaryTreeNode* pLeft = pRoot->m_nLeft;
        BinaryTreeNode* pRight = pRoot->m_nRight;

        delete pRoot;
        pRoot = nullptr;

        DestroyTree(pLeft);
        DestroyTree(pRight);
    }
}
#endif // BINARYTREE_H







//BinaryTree.cpp
#include "BinaryTree.h"
#include <exception>
#include <cstdio>
#include <iostream>

BinaryTreeNode* ConstructCore
(
 int* startPreorder,int* endPreorder,
 int* startInorder,int* endInorder
 );

BinaryTreeNode* Construct(int* preorder,int* inorder,int length)
{
    if(preorder == nullptr||inorder == nullptr ||length<=0)
        return nullptr;
    return ConstructCore(preorder,preorder+length-1,inorder,inorder+length-1);
}

BinaryTreeNode* ConstructCore
(
 int* startPreorder,int* endPreorder,
 int* startInorder,int* endInorder
 )
 {

     //前序序列的第一个数字是根节点的值
     int rootValue = startPreorder[0];
     BinaryTreeNode* root = new BinaryTreeNode();
     root->m_nValue =rootValue;
     root->m_nLeft = nullptr;
     root->m_nRight = nullptr;

     if(startPreorder == endPreorder)
     {
         if(startInorder == endInorder
            && *startInorder ==*startPreorder )
                return root;
         else
           // throw std::exception("Invalid input.");
            std::cerr<<"Invalid input"<<std::endl;

     }

     //在中序遍历序列中找到根节点的值
     int *rootInorder = startInorder;
     while(rootInorder <= endInorder && *rootInorder !=rootValue)
        ++rootInorder;

     if(rootInorder == endInorder && *rootInorder!= rootValue)
        //throw std::exception("Invalid input.");
        std::cerr<<"Invalid input"<<std::endl;

     int leftlength = rootInorder - startInorder;
      int *leftPreorderEnd = startPreorder+leftlength;
     if(leftlength>0)
     {

     int *leftPreorderStart = startPreorder+1;
     int *leftInorderStart = startInorder;
     int *leftInorderEnd = rootInorder-1;
     root->m_nLeft=ConstructCore(leftPreorderStart,leftPreorderEnd,leftInorderStart,leftInorderEnd);

     }

     if(leftlength<endPreorder-startPreorder)
     {
     int *rightPreorderStart = leftPreorderEnd+1;
     int *rightPreorderEnd = endPreorder;
     int *rightInorderStart = rootInorder+1;
     int *rightInorderEnd = endInorder;
     root->m_nRight=ConstructCore(rightPreorderStart,rightPreorderEnd,rightInorderStart,rightInorderEnd);

     }
     return root;
 }

// ====================测试代码====================
void Test(char* testName, int* preorder, int* inorder, int length)
{
    if(testName != nullptr)
        printf("%s begins:\n", testName);

    printf("The preorder sequence is: ");
    for(int i = 0; i < length; ++ i)
        printf("%d ", preorder[i]);
    printf("\n");

    printf("The inorder sequence is: ");
    for(int i = 0; i < length; ++ i)
        printf("%d ", inorder[i]);
    printf("\n");

    try
    {
        BinaryTreeNode* root = Construct(preorder, inorder, length);
        PrintTree(root);

        DestroyTree(root);
    }
    catch(std::exception& exception)
    {
        printf("Invalid Input.\n");
    }
}

// 普通二叉树
//              1
//           /     \
//          2       3
//         /       / \
//        4       5   6
//         \         /
//          7       8
void Test1()
{
    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};

    Test("Test1", preorder, inorder, length);
}

// 所有结点都没有右子结点
//            1
//           /
//          2
//         /
//        3
//       /
//      4
//     /
//    5
void Test2()
{
    const int length = 5;
    int preorder[length] = {1, 2, 3, 4, 5};
    int inorder[length] = {5, 4, 3, 2, 1};

    Test("Test2", preorder, inorder, length);
}

// 所有结点都没有左子结点
//            1
//             \
//              2
//               \
//                3
//                 \
//                  4
//                   \
//                    5
void Test3()
{
    const int length = 5;
    int preorder[length] = {1, 2, 3, 4, 5};
    int inorder[length] = {1, 2, 3, 4, 5};

    Test("Test3", preorder, inorder, length);
}

// 树中只有一个结点
void Test4()
{
    const int length = 1;
    int preorder[length] = {1};
    int inorder[length] = {1};

    Test("Test4", preorder, inorder, length);
}

// 完全二叉树
//              1
//           /     \
//          2       3
//         / \     / \
//        4   5   6   7
void Test5()
{
    const int length = 7;
    int preorder[length] = {1, 2, 4, 5, 3, 6, 7};
    int inorder[length] = {4, 2, 5, 1, 6, 3, 7};

    Test("Test5", preorder, inorder, length);
}

// 输入空指针
void Test6()
{
    Test("Test6", nullptr, nullptr, 0);
}

// 输入的两个序列不匹配
void Test7()
{
    const int length = 7;
    int preorder[length] = {1, 2, 4, 5, 3, 6, 7};
    int inorder[length] = {4, 2, 8, 1, 6, 3, 7};

    Test("Test7: for unmatched input", preorder, inorder, length);
}

int main(int argc, char* argv[])
{
    Test1();
    Test2();
    Test3();
    Test4();
    Test5();
    Test6();
    Test7();

    return 0;
}