实现二叉树类及若干应用算法（附具体代码）

一、二叉树的存储结构

1. 顺序存储结构
由于每个数据元素的存储位置彼此之间有着一定的关系，因此可以根据结点的编号直接计算出他的父结点、左右孩子结点的位置。类似的，其他操作也可以通过计算得出。
但是此存储结构只对于满、完全二叉树来说效率极高，而对于一般的二叉树而言使用顺序存储会造成空间极大的浪费。

2. 链式存储结构
链式存储中，每个结点结构应该包含两个指针域，分别指向左、右孩子结点，以及一个结点数据。

struct BiNode
{
	T data;					//结点数据
	BiNode<T>* lchild;		//左孩子
	BiNode<T>* rchild;		//右孩子
};

使用链式存储虽然还是有许多空指针域，但是后面会进一步改进该程序使得空指针域得以利用，所以我们选择链式存储。

二、二叉树的遍历算法

1.先序遍历
先输出本身的值，再依次输出左、右孩子的值。

void BiTree<T>::PreOrder(BiNode<T>* p)
{
	if (p == NULL)
		return;
	cout << p->data;
	PreOrder(p->lchild);
	PreOrder(p->rchild);
}

2.中序遍历
先输出左孩子的值，再输出本身的值，最后输出右孩子的值。

void BiTree<T>::InOrder(BiNode<T>* p)
{
	if (p == NULL)
		return;
	InOrder(p->lchild);
	cout << p->data;
	InOrder(p->rchild);
}

3.后序遍历
先输出左、右孩子的值，最后输出本身的值。

void BiTree<T>::PostOrder(BiNode<T>* p)
{
	if (p == NULL)
		return;
	PostOrder(p->lchild);
	PostOrder(p->rchild);
	cout << p->data;
}

4.层次遍历
自上而下，从左向右一层层遍历，因为具有先进先出的特点，所以使用队列来实现相关操作。

void BiTree<T>::LevelOrder()
{
	if (root == NULL)
		return;
	queue<BiNode<T>*> Q;
	Q.push(root);
	while (!Q.empty())
	{
		BiNode<T>* p = Q.front();
		cout << p->data;
		Q.pop();
		if (p->lchild != NULL)
			Q.push(p->lchild);
		if (p->rchild != NULL)
			Q.push(p->rchild);
	}
	
}

因为前面三种遍历都是递归算法，所以要注意不能直接调用根结点，需要通过对外开放的函数作为媒介调用根结点。

例如：

void BiTree<T>::PreOrder()
{
	return PreOrder(root);
}

注意：进行递归运算时只需要考虑前几种情况，不要想的太深，会混淆

三、二叉树的构造

1. 单个遍历序列构造二叉树
通过带空指针标记的先序序列来构造一个确定的二叉树

通过将空指针标记为*来唯一确定一个二叉树

BiNode<T>* BiTree<T>::CreateByPre(vector<T>& pre, int& i)
{
	T e = pre[i];
	i++;
	if (e == '*')
		return NULL;
	BiNode<T>* p = new BiNode<T>;
	p->data = e;
	p->lchild = CreateByPre(pre, i);
	p->rchild = CreateByPre(pre, i);
	return p;
}

2.通过两个不同序列来构造一个确定的二叉树
两个不同序列可以是先序序列和中序序列，也可以是后序序列和中序序列，但是不能是先序序列和后序序列。
下面以先序序列和中序序列为例：
已知某二叉树的先序序列为ABHFDECKG，中序序列为HBDFAEKCG，确定二叉树的过程如图所示。

后序序列和中序序列确定二叉树的方法与上图类似。

BiNode<T>* BiTree<T>::CreateByPreMid(vector<T>& pre, vector<T>& mid, int ipre, int imid, int n)
{
	if (n == 0)
		return NULL;
	BiNode <T>* p = new BiNode<T>;
	p->data = pre[ipre];
	int i;
	for (i = 0; n > i; i++)
		if (pre[ipre] == mid[imid + i])
			break;
	p->lchild = CreateByPreMid(pre, mid, ipre + 1, imid, i);
	p->rchild = CreateByPreMid(pre, mid, ipre + i + 1, mid + i + 1, n - i - 1);
	return p;
}

四、二叉树的析构

析构要从底层向根结点依次析构，这里要用到递归的算法。

void BiTree<T>::Free(BiNode<T>* p)
{	if (p == NULL)		
        return;
    Free(p->lchild);
	Free(p->rchild);
	delete p;
}

五、其他应用算法

1.计算二叉树的结点数
利用后序遍历程序的框架，将计数目标分解为对左子树和右子树的计数，通过逐层递归调用完成。

int BiTree<T>::Count(BiNode<T>* p)
{
	if (p == NULL)
		return 0;
	int left = Count(p->lchild);
	int right = Count(p->rchild);
	return 1 + left + right;
}

2.计算二叉树的高度
若二叉树为空则高度为0，否则二叉树的高度为左、右子树高度的最大值加1，同样是利用了递归调用。

int BiTree<T>::Height(BiNode<T>* p)
{
	if (p == NULL)
		return 0;
	int left = Height(p->lchild);
	int right = Height(p->rchild);
	if (left > right)
		return left + 1;
	else
		return right + 1;
}

3.根据关键值查找结点
查找过程可以分解为3各部分：
①结点比较
②左子树查找
③右子树查找
若查找成功则停止查找并返回该结点的指针，若所有结点都不满足条件返回NULL。

BiNode<T>* BiTree<T>::Search(BiNode<T>* p, T e)
{
	if (p == NULL)
		return NULL;
	if (p->data == e)
		return p;
	BiNode<T>* q = Search(p->lchild, e);
	if (q != NULL)
		return q;
	return Search(p->rchild, e);
}

4.查找结点的父结点
和上面的算法类似，也是分为三部分：根结点的比较和左、右子树的查找。
若查找成功返回对应的结点，否则返回NULL。

BiNode<T>* BiTree<T>::SearchParent(BiNode<T>* p, BiNode<T>* child)
{
	if (p == NULL || child == NULL)
		return NULL;
	if (p->lchild == child || p->rchild == child)
		return p;
	BiNode<T>* q = SearchParent(p->lchild, child);
	if (q != NULL)
		return q;
	return SearchParent(p->rchild, child);
}

六、总结

二叉树类的实现运用了大量的递归运算，在层次遍历中还使用了队列的算法。递归运算时一定要注意将大问题化为小问题，并且不要随着递归而不停的向下去思考，只需要考虑最上面一层的递归，其他的交给计算机来实现即可。同时这里的二叉树存储结构选择的为链式存储，仍然有大量的空间浪费，后面将介绍线索二叉树将这些浪费的空间全部都利用上。

具体代码：二叉树类及其相关应用