海涛老师的面试题-作业6-重建二叉树

// 重建二叉树.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <iostream>
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
        {
            throw exception("Invalid Input!");
        }
    }
    int* RootInorder=StartInorder;
    while(RootInorder<=EndInorder&&*RootInorder!=RootValue)
        ++RootInorder;
    if(RootInorder==EndInorder&&*RootInorder!=RootValue)
        throw exception("Invalid Input!");
    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 PrintTree(BinaryTreeNode* Head)
{
    if(Head)
    {
    if(Head->m_pLeft)
        PrintTree(Head->m_pLeft);
    if(Head->m_pRight)
        PrintTree(Head->m_pRight);
        cout<<Head->m_nValue<<"  ";
    }
    else
        return;
}

void DestroyTree(BinaryTreeNode* Head)
{
    if(Head)
    {
    if(Head->m_pLeft)
        DestroyTree(Head->m_pLeft);
    else if(Head->m_pRight)
        DestroyTree(Head->m_pRight);
    delete Head;
    }
    else
        return;
}


void Test(char* testName, int* preorder, int* inorder, int length)
{
    if(testName != NULL)
        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);
        cout<<endl;
        DestroyTree(root);
    }
    catch(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", NULL, NULL, 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 _tmain(int argc, _TCHAR* argv[])
{
    Test1();
    Test2();
    Test3();
    Test4();
    Test5();
    Test6();
    Test7();
    return 0;
}