1. 树与树的遍历

树是一种在实际编程中经常遇到的数据结构，它的逻辑结构很简单：除了根节点之外每个节点只有一个父节点，根节点没有父节点；除了叶节点之外所有节点都有一个或者多个子节点，叶节点没有子节点。父节点和子节点之间用指针链接。所谓的二叉树是树的一种特殊结构，在二叉树中每个节点最多只能有两个子节点。二叉树最重要的莫过于遍历，即按照某一顺序访问树中的搜有的节点。通常树有三种遍历方式。

前序遍历：根节点-左子节点-右子节点。上图的遍历顺序为：10-6-4-8-14-12-16；
中序遍历：左子节点-根节点-右子节点。上图的遍历顺序为：4-6-8-10-12-14-16
后序遍历：左子节点-右子节点-根节点。上图的遍历顺序为：4-8-6-12-16-14-10
宽度优先遍历：自上到下，自左到右。上图的遍历顺序为：10-6-14-4-8-12-16

二叉搜索树是二叉树中的一个特例。在二叉搜索树中，左子节点总是小于或者等于根节点，右子节点总是大于等于根节点。上图实际上就是一棵二叉搜索树。可以再平均O(logn)时间内根据数值在二叉搜索树中找到一个节点。

二叉树还有两个特例。分别是堆和红黑树。堆分为最大堆和最小堆。在最大堆中，根节点的值最大，在最小队中，根节点的值最小。很多需要快速查找到最大值最小值的问题都可以通过堆来实现。红黑树是把树中的结点定义为红、黑两种颜色，并通过确定规则使得从根节点到叶节点的最常路径的长度不差偶偶最短路径的二倍。在C++的STL中，set, multiset, map, multimap等数据结构都是结余红黑树实现的。

2.利用前序遍历和中序遍历重建二叉树

原理：

1.前序遍历的第一个值对应的就是节点；

2.利用该节点可以在中序遍历中划分左子树和左子树；

3.划分子树结束后，回到前序遍历中又可以判断节点，递归的过程；

#include "BinaryTree.h"
#include <exception>
#include <stdio.h>
#include <stdlib.h>
using namespace std;

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

	return 0;
}

树与搜索

1. 树与树的遍历

2.利用前序遍历和中序遍历重建二叉树

猜你喜欢