剑指offer——面试题7：重建二叉树

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

 #include <iostream>
 #include <exception>
 #include <cstdio>
 #include<stdexcept>
 using namespace std;

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

 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\n", pNode->m_nValue);

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

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

     printf("\n");
 }

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

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

 BinaryTreeNode* Construct(int* preorder, int* inorder, int length)
 {
     if(preorder == nullptr || inorder == nullptr || length <= )
         return nullptr;

     return ConstructCore(preorder, preorder + length - ,
         inorder, inorder + length - );
 }

 BinaryTreeNode* ConstructCore
 (
     int* startPreorder, int* endPreorder,
     int* startInorder, int* endInorder
 )
 {
     // 前序遍历序列的第一个数字是根结点的值
     int rootValue = startPreorder[];
     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
         {
             std::logic_error ex("Invalid input.");
             throw std::exception(ex);
         }
        //     throw exception("Invalid input.");
     }

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

     if(rootInorder == endInorder && *rootInorder != rootValue)
     {
          std::logic_error ex("Invalid input.");
          throw std::exception(ex);
     }
      //   throw std::exception("Invalid input.");

     int leftLength = rootInorder - startInorder;
     int* leftPreorderEnd = startPreorder + leftLength;
     if(leftLength > )
     {
         // 构建左子树
         root->m_pLeft = ConstructCore(startPreorder + , leftPreorderEnd,
             startInorder, rootInorder - );
     }
     if(leftLength < endPreorder - startPreorder)
     {
         // 构建右子树
         root->m_pRight = ConstructCore(leftPreorderEnd + , endPreorder,
             rootInorder + , endInorder);
     }

     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 = ; i < length; ++ i)
         printf("%d ", preorder[i]);
     printf("\n");

     printf("The inorder sequence is: ");
     for(int i = ; 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 = ;
     int preorder[length] = {, , , , , , , };
     int inorder[length] = {, , , , , , , };

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

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

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

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

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

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

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

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

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

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

 // 输入的两个序列不匹配
 void Test7()
 {
     const int length = ;
     int preorder[length] = {, , , , , , };
     int inorder[length] = {, , , , , , };

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

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

     return ;
 }