《剑指Offer》面试题6：重建二叉树
《剑指Offer》面试题6：重建二叉树
知识点
1.对二叉树前序遍历、中序遍历的理解程度
2.递归分解复杂问题
题目描述
输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。
解题思路
测试用例
代码（原书）
/* 《剑指Offer——名企面试官精讲典型编程题》代码
著作权所有者：何海涛*/
#include
#include
using namespace std;
struct BinaryTreeNode
{
int m_nValue;
BinaryTreeNode *m_pLeft;
BinaryTreeNode *m_pRight;
};
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 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);
}
}
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 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 node is : 1
value of its left child is : 2.
value of its right child is : 3.
value of this node is : 2
value of its left child is : 4.
right child is null.
value of this node is : 4
left child is null.
value of its right child is : 7.
value of this node is : 7
left child is null.
right child is null.
value of this node is : 3
value of its left child is : 5.
value of its right child is : 6.
value of this node is : 5
left child is null.
right child is null.
value of this node is : 6
value of its left child is : 8.
right child is null.
value of this 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 node is : 1
value of its left child is : 2.
right child is null.
value of this node is : 2
value of its left child is : 3.
right child is null.
value of this node is : 3
value of its left child is : 4.
right child is null.
value of this node is : 4
value of its left child is : 5.
right child is null.
value of this 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 node is : 1
left child is null.
value of its right child is : 2.
value of this node is : 2
left child is null.
value of its right child is : 3.
value of this node is : 3
left child is null.
value of its right child is : 4.
value of this node is : 4
left child is null.
value of its right child is : 5.
value of this 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 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 node is : 1
value of its left child is : 2.
value of its right child is : 3.
value of this node is : 2
value of its left child is : 4.
value of its right child is : 5.
value of this node is : 4
left child is null.
right child is null.
value of this node is : 5
left child is null.
right child is null.
value of this node is : 3
value of its left child is : 6.
value of its right child is : 7.
value of this node is : 6
left child is null.
right child is null.
value of this node is : 7
left child is null.
right child is null.
Test6 begins :
The preorder sequence is :
The inorder sequence is :
this 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.
请按任意键继续. . .
代码（牛客网）
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 pre,vector vin)
{
if(pre.empty() || vin.empty()) //若前序或中序序列为空，返回NULL
return NULL;
if(pre.size() != vin.size()) //若输入的前序和中序序列长度不一致，返回NULL
return NULL;
TreeNode *root = new TreeNode(pre.front()); //前序序列的第一个数字为二叉树的根结点值，由此创建根结点
vector::iterator rootInIndex;
rootInIndex=find(vin.begin(),vin.end(),pre.front()); //在中序序列中找到根结点所在位置
if(rootInIndex==vin.end()) //若在中序序列中没有找到根结点，返回NULL
return NULL;
int leftLength = rootInIndex - vin.begin(); //计算左子树结点个数
vector::iterator leftPreEndIndex = pre.begin()+leftLength; //前序序列中左子树最后一个结点所在位置
vector::iterator temp1, temp2;
if(leftLength>0) //左子树存在，构建左子树
{
vector preOfLeft; //左子树前序序列
vector vinOfLeft; //左子树中序序列
temp1 = pre.begin()+1; //左子树前序序列起始位置
temp2 = vin.begin(); //左子树中序序列起始位置
while(temp2 != rootInIndex)
{
preOfLeft.push_back(*temp1++);
vinOfLeft.push_back(*temp2++);
}
root->left = reConstructBinaryTree(preOfLeft, vinOfLeft); //递归实现
}
if(leftLength preOfRight;
vector vinOfRight;
temp1 = leftPreEndIndex+1;
temp2 = rootInIndex+1;
while(temp2 != vin.end())
{
preOfRight.push_back(*temp1++);
vinOfRight.push_back(*temp2++);
}
root->right = reConstructBinaryTree(preOfRight, vinOfRight);
}
return root;
}
};