输入某二叉树的前序遍历和中序遍历的结果，重建该二叉树

题目：输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。

 


思路：

 


       先序遍历的第一个元素为根节点，在中序遍历中找到这个根节点，从而可以将中序遍历分为左右两个部分，左边部分为左子树的中序遍历，右边部分为右子树的中序遍历，进而也可以将先序遍历除第一个元素以外的剩余部分分为两个部分，第一个部分为左子树的先序遍历，第二个部分为右子树的先序遍历。

 

       由上述分析结果，可以递归调用构建函数，根据左子树、右子树的先序、中序遍历重建左、右子树。

 

完整代码及其测试用例实现：

#include<iostream>
#include <exception>//异常处理类
using namespace std;

//二叉树节点定义
struct BinaryTreeNode
{
int m_nValue;
BinaryTreeNode* m_pLeft;
BinaryTreeNode* m_pRight;
};

//打印树节点
void PrintTreeNode(BinaryTreeNode* pNode)
{
if (pNode != NULL)
{
cout << "value of this root node is: " << pNode->m_nValue << endl;

if (pNode->m_pLeft != NULL)
{
cout << "value of its left child is: " << pNode->m_pLeft->m_nValue << endl;
}
else
{
cout << "left child is null. " << endl;
}

if (pNode->m_pRight != NULL)
{
cout << "value of its right child is: " << pNode->m_pRight->m_nValue << endl;
}
else
{
cout << "right child is null. " << endl;
}
}
else
{
cout << "this root node is null. " << endl;
}

cout << endl;
}

//遍历树
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);
}
}

//重建二叉树
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 = NULL;
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;
}

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 Test(char* testName, int* preorder, int* inorder, int length)
{
if (testName != NULL)
{
cout << testName << " begins:" << endl;
}

cout << "The preorder sequence is:" ;
for (int i = 0; i < length; ++i)
{
cout << preorder[i] << " ";
}
cout <<endl;

cout << "The inorder sequence is:";
for (int i = 0; i < length; ++i)
{
cout << inorder[i] << " ";
}
cout << endl;

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

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

void Test1()
{
// 普通二叉树
// 1
// / \
// 2 3
// / / \
// 4 5 6
// \ /
// 7 8

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

void Test2()
{
// 所有结点都没有右子结点
// 1
// /
// 2
// /
// 3
// /
// 4
// /
// 5

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

void Test3()
{
// 所有结点都没有左子结点
// 1
// \
// 2
// \
// 3
// \
// 4
// \
// 5
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);
}

void Test5()
{
// 完全二叉树
// 1
// / \
// 2 3
// / \ / \
// 4 5 6 7

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()
{
Test1();
Test2();
Test3();
Test4();
Test5();
Test6();
Test7();

system("pause");
return 0;
}

运行结果：

Test1 begins:

The preorder sequence is:1  2  4  7  3  5  6  8

The inorder sequence is:4  7  2  1  5  3  8  6

value of this root node is: 1

value of its left child is: 2

value of its right child is: 3

 

value of this root node is: 2

value of its left child is: 4

right child is null.

 

value of this root node is: 4

left child is null.

value of its right child is: 7

 

value of this root node is: 7

left child is null.

right child is null.

 

value of this root node is: 3

value of its left child is: 5

value of its right child is: 6

 

value of this root node is: 5

left child is null.

right child is null.

 

value of this root node is: 6

value of its left child is: 8

right child is null.

 

value of this root node is: 8

left child is null.

right child is null.

 

Test2 begins:

The preorder sequence is:1  2  3  4  5

The inorder sequence is:5  4  3  2  1

value of this root node is: 1

value of its left child is: 2

right child is null.

 

value of this root node is: 2

value of its left child is: 3

right child is null.

 

value of this root node is: 3

value of its left child is: 4

right child is null.

 

value of this root node is: 4

value of its left child is: 5

right child is null.

 

value of this root node is: 5

left child is null.

right child is null.

 

Test3 begins:

The preorder sequence is:1  2  3  4  5

The inorder sequence is:1  2  3  4  5

value of this root node is: 1

left child is null.

value of its right child is: 2

 

value of this root node is: 2

left child is null.

value of its right child is: 3

 

value of this root node is: 3

left child is null.

value of its right child is: 4

 

value of this root node is: 4

left child is null.

value of its right child is: 5

 

value of this root node is: 5

left child is null.

right child is null.

 

Test4 begins:

The preorder sequence is:1

The inorder sequence is:1

value of this root node is: 1

left child is null.

right child is null.

 

Test5 begins:

The preorder sequence is:1  2  4  5  3  6  7

The inorder sequence is:4  2  5  1  6  3  7

value of this root node is: 1

value of its left child is: 2

value of its right child is: 3

 

value of this root node is: 2

value of its left child is: 4

value of its right child is: 5

 

value of this root node is: 4

left child is null.

right child is null.

 

value of this root node is: 5

left child is null.

right child is null.

 

value of this root node is: 3

value of its left child is: 6

value of its right child is: 7

 

value of this root node is: 6

left child is null.

right child is null.

 

value of this root node is: 7

left child is null.

right child is null.

 

Test6 begins:

The preorder sequence is:

The inorder sequence is:

this root node is null.

 

Test7: for unmatched input begins:

The preorder sequence is:1  2  4  5  3  6  7

The inorder sequence is:4  2  8  1  6  3  7

 Invalid Input.

请按任意键继续. . .