《剑指offer》第七题：重建二叉树

// 面试题7：重建二叉树
// 题目：输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输
// 入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,
// 2, 4, 7, 3, 5, 6, 8}和中序遍历序列{4, 7, 2, 1, 5, 3, 8, 6}，则重建出
// 图2.6所示的二叉树并输出它的头结点。

#include "BinaryTree.h"
#include <exception>
#include <cstdio>

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

BinaryTreeNode* Construct(int* preorder, int* inorder, int length)
{
    //鲁棒性测试 1.空数组 2.长度小于等于0
    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_pLeft = root->m_pRight = nullptr;

    //如无子节点
    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) //左子节点长度不为0
    {
        //构建左子树
        root->m_pLeft = ConstructCore(startPreorder + 1, leftPreorderEnd,
            startInorder, rootInorder - 1);
    }
    if (leftLength < endPreorder - startPreorder) //右子节点长度不为0
    {
        //构建右子树
        root->m_pRight = ConstructCore(leftPreorderEnd + 1, endPreorder,
            rootInorder + 1, endInorder);
    }
    return root;
}

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

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

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

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

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

// 普通二叉树
//              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;
}

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

__declspec( dllexport ) BinaryTreeNode* CreateBinaryTreeNode(int value);
__declspec( dllexport ) void ConnectTreeNodes(BinaryTreeNode* pParent, BinaryTreeNode* pLeft, BinaryTreeNode* pRight);
__declspec( dllexport ) void PrintTreeNode(const BinaryTreeNode* pNode);
__declspec( dllexport ) void PrintTree(const BinaryTreeNode* pRoot);
__declspec( dllexport ) void DestroyTree(BinaryTreeNode* pRoot);

#include <cstdio>
#include "BinaryTree.h"

//新建一个父节点
BinaryTreeNode* CreateBinaryTreeNode(int value)
{
    BinaryTreeNode* pNode = new BinaryTreeNode();
    pNode->m_nValue = value;
    pNode->m_pLeft = nullptr;
    pNode->m_pRight = nullptr;

    return pNode;
}

//父节点连接左右子节点
void ConnectTreeNodes(BinaryTreeNode* pParent, BinaryTreeNode* pLeft, BinaryTreeNode* pRight)
{
    if(pParent != nullptr)
    {
        pParent->m_pLeft = pLeft;
        pParent->m_pRight = pRight;
    }
}

//打印当前父节点以及左右子节点
void PrintTreeNode(const BinaryTreeNode* pNode)
{
    if(pNode != nullptr)
    {
        printf("value of this node is: %d
", pNode->m_nValue);

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

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

    printf("
");
}

//递归调用打印整个二叉树
void PrintTree(const BinaryTreeNode* pRoot)
{
    PrintTreeNode(pRoot);

    if(pRoot != nullptr)
    {
        if(pRoot->m_pLeft != nullptr)
            PrintTree(pRoot->m_pLeft);

        if(pRoot->m_pRight != nullptr)
            PrintTree(pRoot->m_pRight);
    }
}

//递归调用删除整个树
void DestroyTree(BinaryTreeNode* pRoot)
{
    if(pRoot != nullptr)
    {
        BinaryTreeNode* pLeft = pRoot->m_pLeft;
        BinaryTreeNode* pRight = pRoot->m_pRight;

        delete pRoot;
        pRoot = nullptr;

        DestroyTree(pLeft);
        DestroyTree(pRight);
    }
}

分析：递归思想。

 牛客网又给了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> preorder,vector<int> inorder) {
        
        int length = int(preorder.size());
        if (preorder.empty() || inorder.empty())
            return nullptr;
        
        return ConstructCore (preorder, inorder, 0, length - 1, 0, length - 1);
    }
    
    TreeNode* ConstructCore (vector<int> preorder, vector<int> inorder,
                             int startPreorder, int endPreorder, int startInorder, int endInorder)
    {
        //根节点
        TreeNode* root = new TreeNode(preorder[startPreorder]);
        
        //无子节点
        if (startPreorder == endPreorder)
        {
            if (startInorder == endInorder && preorder[startPreorder] == inorder[startInorder])
                return root;
            else
                printf("Invaild input.");
                //throw std::exception("Invaild input.");
        }
        
        //有子节点，先寻找中序遍历中根节点位置
        int rootInorder = startInorder;
        while(startInorder <= endInorder && inorder[rootInorder] != root->val)
            ++rootInorder;
        //如果没找到
        if (startInorder == endInorder && inorder[rootInorder] != root->val)
            printf("Invaild input.");
            //throw std::exception("Invaild input.");
        
        int leftLength = rootInorder - startInorder;
        int rightLength = endInorder - rootInorder;
        int leftPreorderEnd = startPreorder + leftLength;
        if (leftLength > 0) //左子节点
        {
            root->left = ConstructCore(preorder, inorder, 
                                      startPreorder + 1, leftPreorderEnd, startInorder, rootInorder - 1);
        }
        if (rightLength > 0) //右子节点
        {
            root->right = ConstructCore(preorder, inorder,
                                       leftPreorderEnd + 1,  endPreorder, rootInorder + 1, endInorder);
        }
        return root;
    }
    
};