剑指offer 6- 重建二叉树

对于一颗二叉树，可以根据先序遍历（后序遍历）和中序遍历重新还原出二叉树。

根据先序遍历和中序遍历还原二叉树的主要思想：

1、先序遍历序列的第一个元素必定是根节点，可以由此获取二叉树的根节点。

2、根据根节点，在中序遍历序列中查找该节点，由中序遍历的性质可知，中序遍历中该根节点左边的序列必定在根节点的左子树中，而根节点右边的序列必定在右子树中。由此可以知道先序遍历中左子树以及右子树的起止位置。

3、分别对左子树和右子树重复上述的过程，直至所有的子树的起止位置相等时，说明已经到达叶子节点，遍历完毕。

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

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

BinaryTreeNode* Construct(  int* startPreorder, int* endPreorder,   int* startInorder, int* endInorder   )
 {
	 if(startPreorder == NULL || endPreorder==NULL  ||   startInorder==NULL   ||  endInorder==NULL)
		 return NULL;
	  
	 int rootValue = startPreorder[0];                              //前序遍历  根节点
	 BinaryTreeNode* root = new BinaryTreeNode[sizeof(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;
	  int leftLength = rootInorder - startInorder;     //从而得到左子树的位数
	  int* leftPreorderEnd = startPreorder+ leftLength ;

	  if(leftLength >0)     //根据前序遍历构建左子树
		  root->m_pLeft = Construct(  startPreorder +1, leftPreorderEnd,   startInorder, rootInorder -1   );
	  if(leftLength < endPreorder - startPreorder)    //根据前序遍历构建右子树
		   root->m_pRight = Construct(  leftPreorderEnd+1, endPreorder,  rootInorder+1,  endInorder   );

	  return root;


}

void  printTreeNode(  BinaryTreeNode* root )  //前序遍历打印
{
	if(root !=NULL)
	{
		cout<<root->m_nValue;
	    printTreeNode(root->m_pLeft);
		printTreeNode(root->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);
    }
}
// ====================测试代码====================
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,preorder+length-1, inorder, inorder+length-1);
        printTreeNode(root);

        DestroyTree(root);
    }
    catch(std::exception& exception)
    {
        printf("Invalid Input.\n");
    }
	 printf("\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 main(int argc, char* argv[])
{
    Test1();
    Test2();
    Test3();
    Test4();
    Test5();
    Test6();
    Test7();

    return 0;
}