【剑指offer】二叉树构建以及利用前序遍历和中序遍历结果构建出二叉树

#include <iostream>
#include <exception>//抛出异常
using namespace std;
//二叉树
typedef struct BinaryTreeNode
{
	int m_nValue;
	BinaryTreeNode* m_pLeft;
	BinaryTreeNode* m_pRight;
	BinaryTreeNode(int value = 0) :m_nValue(value), m_pLeft(nullptr), m_pRight(nullptr) {}
}*BiTreeNode, *BiTree;//代码简介

BiTreeNode CreateBiTreeNode(int value);
void ConnectTreeNoides(BiTreeNode pParent, BiTreeNode pLeft, BiTreeNode pRight);
void PrintTreeNode(const BiTreeNode pNode);
void PrintTree(const BiTree pRoot);
void DestroyTree(BiTree pRoot);

BiTreeNode CreateBiTreeNode(int value)
{
	BiTreeNode node = new BinaryTreeNode();
	node->m_nValue = value;
	return node;
}

void ConnectTreeNoides(BiTreeNode pParent, BiTreeNode pLeft, BiTreeNode pRight)
{
	if (pParent != nullptr)
	{
		pParent->m_pLeft = pLeft;
		pParent->m_pRight = pRight;
	}
}

void PrintTreeNode(const BiTreeNode pNode)
{
	if (pNode != nullptr)
	{
		cout << "value of this node is:" << " " << pNode->m_nValue << endl;
		if (pNode->m_pLeft != nullptr)
			cout << "value of its left child is :" << " " << pNode->m_pLeft->m_nValue << endl;
		else
			cout << "left child is nullptr" << endl;

		if (pNode->m_pRight != nullptr)
			cout << "value of its right child is :" << " " << pNode->m_pRight->m_nValue << endl;
		else
			cout << "right child is nullptr" << endl;
	}
	cout << endl;
}

void PrintTree(const BiTree 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(BiTree pRoot)
{
	if (pRoot != nullptr)
	{
		BiTree leftTree = pRoot->m_pLeft;
		BiTree rightTree = pRoot->m_pRight;

		delete pRoot;
		pRoot = nullptr;

		DestroyTree(leftTree);//递归删除左子树
		DestroyTree(rightTree);//递归删除右子树
	}
}



// 面试题7：重建二叉树
// 题目：输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输
// 入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,
// 2, 4, 7, 3, 5, 6, 8}和中序遍历序列{4, 7, 2, 1, 5, 3, 8, 6}，则重建出
// 图2.6所示的二叉树并输出它的头结点。
/*
1
/		\
2				3
/              /   \
4				5		6
\                   /
7				8
*/
BiTree Construct(int* preOrder, int* midOrder, int length);
BiTree ConsrtructCore(int* startPreOrder, int* endPreOrder, int* startMidOrder, int* endMidOrder);

BiTree Construct(int * preOrder, int * midOrder, int length)
{
	if (preOrder == nullptr || midOrder == nullptr || length <= 0)
		return nullptr;
	return ConsrtructCore(preOrder, preOrder + length - 1, midOrder, midOrder + length - 1);
}

BiTree ConsrtructCore(int * startPreOrder, int * endPreOrder, int * startMidOrder, int * endMidOrder)
{
	//前序遍历的第一个数字是根节点的值
	int rootValue = startPreOrder[0];
	BiTreeNode root = new BinaryTreeNode();
	root->m_nValue = rootValue;
	root->m_pLeft = root->m_pRight = nullptr;
	if (startPreOrder == endPreOrder)//递归结束条件
	{
		if (startMidOrder == endMidOrder && *startPreOrder == *endMidOrder)
			return root;
		else
			throw std::exception("Invalid input.");
	}
	//在中序遍历中找到根节点的值
	int* rootMidOrder = startMidOrder;
	while (rootMidOrder <= endMidOrder && *rootMidOrder != rootValue)
		rootMidOrder++;
	if (rootMidOrder == endMidOrder && *rootMidOrder != rootValue)
		throw exception("Invalid input.");

	//利用中序遍历结果确定根节点的左子树长度（同时也确定了中序遍历中的左子树）
	int leftLength = rootMidOrder - startMidOrder;
	//根据长度，在前序遍历中确定了左子树
	int* leftPreOrderEnd = startPreOrder + leftLength;

	//递归构建左子树
	if (leftLength > 0)
	{
		root->m_pLeft = ConsrtructCore(startPreOrder + 1, leftPreOrderEnd, startMidOrder, rootMidOrder - 1);
	}
	//递归构建右子树
	if (leftLength < endPreOrder - startPreOrder)
	{
		root->m_pRight = ConsrtructCore(leftPreOrderEnd + 1, endPreOrder, rootMidOrder + 1, endMidOrder);
	}

	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 = 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", 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;
}