[C++]数据结构：链表二叉树的创建与四种遍历方式

//链表描述二叉树的创建与遍历
#include <iostream>
using namespace std;
/**********************************/
/*以下内容是一个队列数据结构的定义*/
/*队列引入是为实现二叉树的逐层遍历*/
/**********************************/
template <class T>
class Node{
public:
T data;
Node<T> *link;
};

//FIIFO对象
template <class T>
class LinkedQueue{
public:
LinkedQueue(){front=rear=0;}
~LinkedQueue();
bool IsEmpty()const{return ((front)?false:true);}
bool IsFull()const;
T First()const;     //返回队首元素
T Last()const;      //返回队尾元素
LinkedQueue<T>& Add(const T& x);
LinkedQueue<T>& Delete(T& x);
void Output();
Node<T> *front;               //指向第一个节点
Node<T> *rear;                //最后一个节点

};

template <class T>
LinkedQueue<T>::~LinkedQueue(){
Node<T> *next;
while (front){
next = front->link;
delete front;
front = next;
}
}

class OutOfBounds{
public:
OutOfBounds(){
//cout<<"Out Of Bounds!"<<endl;
}
};

//内存不足的异常类
class NoMem{
public:
NoMem(){
cout<<"No Memory!"<<endl;
}
};

//该队列的输出方法
template<class T>
void LinkedQueue<T>::Output(){
Node<T> *temp = front;
while(temp){
cout<<temp->data<<" ";
temp=temp->link;
}
cout<<""<<endl;
}

//判断当前队列是否已满
template <class T>
bool LinkedQueue<T>::IsFull()const{
Node<T>*p;
try{
p = new Node<T>;
delete p;
return false;
}
catch (NoMem)
{
return true;
}
}

//返回队列的第一个元素
template <class T>
T LinkedQueue<T>::First()const{
if(IsEmpty())
throw OutOfBounds();
return front->data
}

//返回队列的最后一个元素
template <class T>
T LinkedQueue<T>::Last()const{
if(IsEmpty())
throw OutOfBounds();
return rear->data
}

//将x添加到队列的尾部
template<class T>
LinkedQueue<T>& LinkedQueue<T>::Add(const T&x){
Node<T>*p = new Node<T>;
p->data=x;
p->link=0;
//在队列尾部添加新节点
if (front){
rear->link = p;
}
else{
front=p;
}
rear=p;
return *this;
}

//删除第一个元素并将其放到X中去
template<class T>
LinkedQueue<T>& LinkedQueue<T>::Delete(T&x){
if (IsEmpty()){
throw OutOfBounds();
}
x = front->data;
Node<T>*p = front;
front = front->link;
delete p;
return *this;
}

/**********************************/
/*以下内容是一个二叉树数据结构定义*/
/**********************************/
template<class T>
class BinaryTreeNode
{
public:
BinaryTreeNode(){LeftChild=RightChild=0;}
BinaryTreeNode(const T&e){data=e;LeftChild=RightChild=0;}
BinaryTreeNode(const T&e,BinaryTreeNode *l,BinaryTreeNode *r){data=e;LeftChild=l;RightChild=r;}
T data;
BinaryTreeNode<T>*LeftChild;	//左子树
BinaryTreeNode<T>*RightChild;	//右子树

};

template<class T>
void Visit(BinaryTreeNode<T>*node)
{
cout<<node->data;
}

template<class T>
class BinaryTree
{
public:
BinaryTree(){root=0;}
~BinaryTree(){};
bool IsEmpty()const{return ((root)?false:true)};	//如果root存在则为false，也就是不为空。
bool Root(T&x)const;
void MakeTree(const T&element,BinaryTree<T>&left,BinaryTree<T>&right);
void BreakTree(T&element,BinaryTree<T>&left,BinaryTree<T>&right);
void PreOrder(void(*Visit)(BinaryTreeNode<T>*u)){PreOrder(Visit,root);}
void InOrder(void(*Visit)(BinaryTreeNode<T>*u)){InOrder(Visit,root);}
void PostOrder(void(*Visit)(BinaryTreeNode<T>*u)){PostOrder(Visit,root);}
void LevelOrder(void(*Visit)(BinaryTreeNode<T>*u));

//二叉树类的扩充
void PreOutput();
void InOutput();
void PostOutput();
void LevelOutput();
void Delete();			//删除二叉树并释放其节点
void AddNode(const T&u);			//删除二叉树并释放其节点
int Height(BinaryTreeNode<T>*t)const;			//返回树的高度
int Size();			//返回树中的节点数

BinaryTreeNode<T>*root;
void PreOrder(void(*Visit)(BinaryTreeNode<T>*u),BinaryTreeNode<T>*t);
void InOrder(void(*Visit)(BinaryTreeNode<T>*u),BinaryTreeNode<T>*t);
void PostOrder(void(*Visit)(BinaryTreeNode<T>*u),BinaryTreeNode<T>*t);
};

//取根节点的data域
//如果没有根节点则返回false
template<class T>
bool BinaryTree<T>::Root(T&x)const
{
if(root)
{
x=root->data;
return true;
}
else
{
return false;
}
}

//将left，right，element合并成一颗新树
//left、right和this必须是不同的树
template<class T>
void BinaryTree<T>::MakeTree(const T&element,BinaryTree<T>&left,BinaryTree<T>&right)
{
root = new BinaryTreeNode<T>(element,left.root,right.root);
left.root=right.root=0;			//禁止通过其他途径访问left和right
}

void BadInput(){
cout<<"Bad Input!"<<endl;
}

//将this拆分成left、right和element
//left、right和this必须是不同的树
template<class T>
void BinaryTree<T>::BreakTree(T&element,BinaryTree<T>&left,BinaryTree<T>&right)
{
if(root)
throw BadInput();//空树

//分解树
element=root->data;
left.root=root->LeftChild;
right.root=root->RightChild;

delete root;
root = 0;
}

//静态成员函数Output输出树
template<class T>
static void Output(BinaryTreeNode<T>*t)
{
cout<<t->data<<' ';
}

template<class T>
void BinaryTree<T>::PreOutput()
{
PreOrder(Output,root);
cout<<endl;
}

template<class T>
void BinaryTree<T>::InOutput()
{
InOrder(Output,root);
cout<<endl;
}

template<class T>
void BinaryTree<T>::PostOutput()
{
PostOrder(Output,root);
cout<<endl;
}

template<class T>
void BinaryTree<T>::LevelOutput()
{
LevelOrder(Output);
cout<<endl;
}

template<class T>
void BinaryTree<T>::PreOrder(void(*Visit)(BinaryTreeNode<T>*u),BinaryTreeNode<T>*t)
{
if(t)
{
Visit(t);
PreOrder(Visit,t->LeftChild);
PreOrder(Visit,t->RightChild);
}
}

template<class T>
void BinaryTree<T>::InOrder(void(*Visit)(BinaryTreeNode<T>*u),BinaryTreeNode<T>*t)
{
if(t)
{
InOrder(Visit,t->LeftChild);
Visit(t);
InOrder(Visit,t->RightChild);
}
}

template<class T>
void BinaryTree<T>::PostOrder(void(*Visit)(BinaryTreeNode<T>*u),BinaryTreeNode<T>*t)
{
if(t)
{
PostOrder(Visit,t->LeftChild);
PostOrder(Visit,t->RightChild);
Visit(t);
}
}

template<class T>
void BinaryTree<T>::LevelOrder(void(*Visit)(BinaryTreeNode<T>*u))
{
LinkedQueue<BinaryTreeNode<T>*>myQueue;
BinaryTreeNode<T>*t;
t=root;
while(t)
{
Visit(t);
if(t->LeftChild)
myQueue.Add(t->LeftChild);
if(t->RightChild)
myQueue.Add(t->RightChild);
if(!myQueue.IsEmpty())
{
myQueue.Delete(t);		//队列中删除一个节点并且将其赋值给t
}else{
break;
}

}
}

template<class T>
void BinaryTree<T>::AddNode(const T&u){
if(!root)
{
root = new BinaryTreeNode<T>;
root->data = u;
root->LeftChild=0;
root->RightChild=0;
return ;
}

cout<<"Root:"<<root->data<<endl;
BinaryTreeNode<T> *newNode = new BinaryTreeNode<T>;
newNode->data = u;

LinkedQueue<BinaryTreeNode<T>*>myQueue;
BinaryTreeNode<T>*t;
t=root;

while(t)
{
cout<<"t.data="<<t->data<<endl;
if(t->LeftChild){
myQueue.Add(t->LeftChild);
cout<<"Left is"<<t->LeftChild->data<<endl;
}
if(t->RightChild){
myQueue.Add(t->RightChild);
cout<<"Right is"<<t->RightChild->data<<endl;
}

if(!t->LeftChild)
{
cout<<"Put "<<newNode->data<<" in Left"<<endl;
t->LeftChild=newNode;
return;
}else{
cout<<"t.Leftdata="<<t->LeftChild->data<<endl;
}
if(!t->RightChild)
{
cout<<"Put "<<newNode->data<<" in Right"<<endl;
t->RightChild=newNode;
return;
}else{
cout<<"t.Rightdata="<<t->RightChild->data<<endl;
}

if(!myQueue.IsEmpty())
{
myQueue.Delete(t);		//队列中删除一个节点并且将其赋值给t
}

}
}
template<class T>
static void Free(BinaryTreeNode<T>*t)
{
delete t;
}

template<class T>
void BinaryTree<T>::Delete()
{
PostOrder(Free,root);
root = 0;
}

template<class T>
int BinaryTree<T>::Height(BinaryTreeNode<T>*t)const
{
if(!t)
return 0;
int hl = Height(t->LeftChild);
int hr = Height(t->RightChild);
return hl>hr?++hl:++hr;
}

template<class T>
int BinaryTree<T>::Size()
{
count = 0 ;
PreOrder(countTree,root);
return count;
}

int count = 0;
BinaryTree<int> a,x,y,z;

template<class T>
void countTree(BinaryTreeNode<T>*t)
{
count++;
}

void main()
{
cout<<"请逐层从左往右输入每一个元素，输入后回车，按0结束输入"<<endl;
int myInput = 0;
while(true)
{
cin>>myInput;
if(myInput==0)
{
break;
}else{
y.AddNode(myInput);
}
}

cout<<"前序排列:"<<endl;
y.PreOutput();
cout<<"中序排列:"<<endl;
y.InOutput();
cout<<"后序排列:"<<endl;
y.PostOutput();
cout<<"逐层排列:"<<endl;
y.LevelOutput();
cout<<"树的高度:"<<endl;
cout<<y.Height(y.root)<<endl;
cout<<"节点数目:"<<endl;
cout<<y.Size()<<endl;
}