数据结构-二叉树（链式储存）的c++实现（包括前中后序，层序遍历）

#pragma once
#ifndef My_Head_H
	#define My_Head_H
	#include "G://code/c++/myhead.h"
#endif // !My_Head_H
#include "SqQueue.h"
template <typename ElemType>
class BiTree 
{
public:
	class BiTree_Node
	{
		public:
			ElemType data;
			BiTree_Node* lchild,* rchild;
			BiTree_Node() //初始化函数，将左右孩子结点指针置空
			{
				lchild = NULL;
				rchild = NULL;
			}
	};
	typedef BiTree_Node* Node_Pointer;

	//清空二叉树
	void clear();

	//求二叉树节点数
	int Count_Node();

	//求二叉树深度
	int Depth();

	//前序遍历二叉树
	void Pre_Order_Traverse();

	//中序遍历二叉树
	void In_Order_Traverse();

	//后序遍历二叉树
	void Post_Order_Traverse();

	//层序遍历二叉树
	void Layer_Order_Traverse();

	//随机生成二叉数
	void Random_Fill_BiTree(int i);

	BiTree ();
	~BiTree ();

private:
	int Count_Node_Aux(Node_Pointer p);
	int Depth_Aux(Node_Pointer p);
	void Delete_Node_Aux(Node_Pointer p);
	void Pre_Order_Traverse_Aux(Node_Pointer p);
	void In_Order_Traverse_Aux(Node_Pointer p);
	void Post_Order_Traverse_Aux(Node_Pointer p);
	void Layer_Order_Traverse_Aux();
	void Creat_Random_Aux(int i, Node_Pointer p);
protected:
	Node_Pointer root;//根节点指针
};

template <typename ElemType>
void BiTree<ElemType>::clear()
{
	Delete_Node_Aux(root);
	root = NULL;
}

//清空二叉树的辅助函数
template<typename ElemType>
void BiTree<ElemType>::Delete_Node_Aux(Node_Pointer p)
{
	if (p)
	{
		Delete_Node_Aux(p->lchild);
		Delete_Node_Aux(p->rchild);
		delete p;
	}
}

template <typename ElemType>
int BiTree<ElemType>::Count_Node()
{
	return Count_Node_Aux(root);
}

//用于求结点个数的辅助函数
template<typename ElemType>
int BiTree<ElemType>::Count_Node_Aux(Node_Pointer p)
{
	int num;//存放最终结点个数
	static int count = 0;//存放累计结点数
	if (p) count++;
	Count_Node_Aux(p->lchild);
	Count_Node_Aux(p->rchild);
	if (p = root)
	{
		num = count;
		count = 0;
	}
	return num;
}

template <typename ElemType>
int BiTree<ElemType>::Depth()
{
	return Depth_Aux(root);
}

//用于求深度的辅助函数
template<typename ElemType>
int BiTree<ElemType>::Depth_Aux(Node_Pointer p)
{
	int ldepth, rdepth;
	if (!p) return 0;
	ldepth = Depth_Aux(p->lchild);
	rdepth = Depth_Aux(p->rchild);
	return (ldepth > rdepth ? ldepth : rdepth) + 1;//返回左右子树较深的深度值+1
}

template<typename ElemType>
void BiTree<ElemType>::Pre_Order_Traverse()
{
	cout << "Here is the Pre Order Travaerse of the BiTree:" << endl;
	Pre_Order_Traverse_Aux(root);
	cout << endl;
}
//用于前序遍历的辅助函数
template<typename ElemType>
void BiTree<ElemType>::Pre_Order_Traverse_Aux(Node_Pointer p)
{
	if (!p) return;
	cout << "->" << p->data;
	Pre_Order_Traverse_Aux(p->lchild);
	Pre_Order_Traverse_Aux(p->rchild);
}

template<typename ElemType>
void BiTree<ElemType>::In_Order_Traverse()
{
	cout << "Here is the In Order Travaerse of the BiTree:" << endl;
	In_Order_Traverse_Aux(root);
	cout << endl;
}
//用于中序遍历的辅助函数
template<typename ElemType>
void BiTree<ElemType>::In_Order_Traverse_Aux(Node_Pointer p)
{
	if (!p) return;
	In_Order_Traverse_Aux(p->lchild);
	cout << "->" << p->data;
	In_Order_Traverse_Aux(p->rchild);
}

template<typename ElemType>
void BiTree<ElemType>::Post_Order_Traverse()
{
	cout << "Here is the Post Order Travaerse of the BiTree:" << endl;
	Post_Order_Traverse_Aux(root);
	cout << endl;
}
//用于后序遍历的辅助函数
template<typename ElemType>
void BiTree<ElemType>::Post_Order_Traverse_Aux(Node_Pointer p)
{
	if (!p) return;
	Post_Order_Traverse_Aux(p->lchild);
	Post_Order_Traverse_Aux(p->rchild);
	cout << "->" << p->data;
}

template<typename ElemType>
void BiTree<ElemType>::Layer_Order_Traverse()
{
	cout << "Here is the Layer Order Travaerse of the BiTree:" << endl;
	Layer_Order_Traverse_Aux();
	cout << endl;
}
//用于层序遍历的辅助函数
template<typename ElemType>
void BiTree<ElemType>::Layer_Order_Traverse_Aux()
{
	//这里需要队列的支持。先写完队列再来补充
	SqQueue<Node_Pointer> Q;
	Node_Pointer p;
	if (root != NULL) Q.enQueue(root); //根结点不为空则进队列；
	while (!Q.Is_Empty())
	{
		Q.deQueue(p);//出队列到指针p；
		cout << "->" << p->data;
		if (p->lchild) Q.enQueue(p->lchild);
		if (p->rchild) Q.enQueue(p->rchild);
	}
}

template<typename ElemType>
void BiTree<ElemType>::Random_Fill_BiTree(int i)
{
	Creat_Random_Aux(i,root);
}

template<typename ElemType>
void BiTree<ElemType>::Creat_Random_Aux(int i, Node_Pointer p)
{
	int lnum, rnum;
	if (p == root)
	{
		p = new BiTree_Node;
		p->data = random(100);
		root = p;
	}
	else
	{
		p->data = random(100);
	}
	if (i == 1) return;
	lnum = random(i - 1);
	if (lnum > 0)
	{
		p->lchild = new BiTree_Node;
		Creat_Random_Aux(lnum, p->lchild);
	}
	rnum = i - lnum - 1;
	if (rnum > 0)
	{
		p->rchild = new BiTree_Node;
		Creat_Random_Aux(rnum, p->rchild);
	}
	return;
}


template <typename ElemType>
BiTree<ElemType>::BiTree ()
{
	root = NULL;
}

template <typename ElemType>
BiTree<ElemType>::~BiTree()
{
	clear();
}