剑指offer--构造二叉树

题目：

书上给出的源码如下：

#include "stdafx.h"
#include "..\Utilities\BinaryTree.h"
#include <exception>

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

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);
}

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 std::exception("Invalid input.");
    }

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

    if(rootInorder == endInorder && *rootInorder != rootValue)
        throw std::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;
}

// ====================测试代码====================
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);

        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", 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;
}

 "..\Utilities\BinaryTree.h"头文件定义如下

#include "StdAfx.h"
#include "BinaryTree.h"


BinaryTreeNode* CreateBinaryTreeNode(int value)
{
    BinaryTreeNode* pNode = new BinaryTreeNode();
    pNode->m_nValue = value;
    pNode->m_pLeft = NULL;
    pNode->m_pRight = NULL;


    return pNode;
}


void ConnectTreeNodes(BinaryTreeNode* pParent, BinaryTreeNode* pLeft, BinaryTreeNode* pRight)
{
    if(pParent != NULL)
    {
        pParent->m_pLeft = pLeft;
        pParent->m_pRight = pRight;
    }
}


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);
    }
}

如果不喜欢用指针的童鞋可以使用C++中的vector

/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode* reConstructBinaryTree(vector<int> pre,vector<int> vin) {
        // 根据先序确定根，根据中序确定哪些在左子树＆哪些在右子树。
        /* 判断先序和中序节点数目是否相等且长度不是０ */
        if ( pre.size() != vin.size() || pre.size() == 0 ) {
            return NULL ;
        }
        // int size = pre.size() ;
        return Core ( pre.begin(), pre.end(), vin.begin(), vin.end() ) ;
    }
     
    // 核心处理函数（参数先序的头指针，先序的最后一个节点后面节点的指针，
                    //中序的头指针，中序的最后一个节点后面的指针）
    TreeNode *Core ( vector<int>::iterator startPre, vector<int>::iterator  endPre,
                     vector<int>::iterator  startVin, vector<int>::iterator  endVin ) {
        // 先序的第一个节点是根
        TreeNode * root = new TreeNode ( *startPre ) ;
         
        // 检验合法性以及是否该树只有一个根节点
        if ( startPre == endPre-1 ) {
            if ( startVin == endVin-1 && *startPre == *startVin ) {
                // 若只有一个根节点则先序中序都只有一个节点且她们的节点值相同
                return root ;
            } else {
                std::cout << "Invalid input." << std::endl ;
            }
        }
         
        /* 从中序中找到根节点的值 */
        // 首先使得rootVin指向中序的第一个节点
        vector<int>::iterator rootVin = startVin ;
        // 然后在中序中寻找根节点
        while ( rootVin != endVin && *rootVin != root->val ) {
            ++rootVin ;
        }
         
        // 如果跳出循环是因为在该中序没有找到value等于rootValue的，则异常
        if ( rootVin == endVin ) {
            std::cout << "Error." << std::endl ;
        }
         
        // 求出左子树有几个节点
        int leftLength = rootVin - startVin ;
        // 从先序中获取右子树的开始节点处即左子树的end
        vector<int>::iterator leftPre = startPre + leftLength + 1;
         
        if ( leftLength > 0 ) {
            // 构建左子树
            root->left = Core ( startPre + 1, leftPre, startVin, rootVin ) ;
        }
         
        if ( endPre - leftPre > 0 ) {
            // 构建右子树
            root->right = Core ( leftPre, endPre, rootVin+1, endVin ) ;
        }
        return root ;
    }
};