二叉树
来源：互联网 发布：电商淘宝是做什么的 编辑：程序博客网 时间：2024/04/16 16:14
#ifndef BINARYTREETWO_H
#define BINARYTREETWO_H
#include "LinkedQueue.h"
#include "LinkedStack.h"
template <class T>
struct BinTreeNode //二叉树结点类定义
{
T data; //数据域
BinTreeNode<T> *leftChild,*rightChild; //左右子女链域
BinTreeNode():leftChild(NULL),rightChild(NULL){}
BinTreeNode(T x,BinTreeNode<T> *left=NULL,BinTreeNode<T> *right=NULL):data(x),leftChild(left),rightChild(right){}
template<class T>
friend bool equal(BinTreeNode<T> *,BinTreeNode<T> *);
};
/*
template<class T>
struct stkNode //后序遍历时所用栈结点的类定义
{
BinTreeNode<T>* ptr; //指向树结点的指针
enum tag{L,R}; //该结点退栈标记
stkNode(BinTreeNode<T> *N = NULL):ptr(N),tag(L){};
};
*/
template <class T>
class BinaryTreeTwo //二叉树类定义
{
public:
BinaryTreeTwo():root(NULL){}
BinaryTreeTwo(T value):RefValue(value),root(NULL){}
BinaryTreeTwo(const BinaryTreeTwo<T> &);
~BinaryTreeTwo()
{
destroy(root);
}
bool IsEmpty()
{
return root==NULL;
}
BinTreeNode<T> * Parent(BinTreeNode<T> * current)
{
return (root==NULL||root==current) ? NULL : Parent(root,current);
}
BinTreeNode<T> * LeftChild(BinTreeNode<T> * current)
{
return (current != NULL) ? current->leftChild : NULL;
}
BinTreeNode<T> * RightChild(BinTreeNode<T> * current)
{
return (current != NULL) ? current->rightChild : NULL;
}
int Height()const
{
return Height(root);
}
int Size()const //返回结点数
{
return Size(root);
}
BinTreeNode<T> * GetRoot() const
{
return root;
}
void PreOrder(); //前序遍历
void InOrder(); //中序遍历
void PostOrder(); //后序遍历
void LevelOrder(); //层次遍历
void PrintBTree(); //以广义表的形式输出二叉树
int Insert(const T & item)
{
return Insert(root,item);
}
BinTreeNode<T> *Find(const T & item) const
{
return Find(root,item);
}
BinaryTreeTwo<T> operator= (const BinaryTreeTwo<T> &);
template<class T>
friend istream & operator >> (istream & in,BinaryTreeTwo<T> & Tree);
template<class T>
friend ostream & operator << (ostream & out,BinaryTreeTwo<T> & Tree);
template<class T>
friend bool operator == (const BinaryTreeTwo<T> &,const BinaryTreeTwo<T> &);
private:
BinTreeNode<T> *root; //二叉树根指针
T RefValue; //数据输入停止标志
void CreateBinTree(istream &in,BinTreeNode<T> *&subTree); //从文件读入建树
int Insert(BinTreeNode<T> *& current,const T & item);
void destroy(BinTreeNode<T> *& current);
BinTreeNode<T> * Copy(BinTreeNode<T> *);
int Height(const BinTreeNode<T> *subTree)const;
int Size(const BinTreeNode<T> *subTree)const;
BinTreeNode<T> * Parent(BinTreeNode<T> * start,BinTreeNode<T> * current);
BinTreeNode<T> *Find(BinTreeNode<T> * current,const T & item) const;
void Traverse(BinTreeNode<T> * current,ostream & out) const; //前序遍历输出
void PreOrder(BinTreeNode<T> *);
void InOrder(BinTreeNode<T> *);
void PostOrder(BinTreeNode<T> *);
void LevelOrder(BinTreeNode<T> *);
void PrintBTree(BinTreeNode<T> *);
};
//删除根为current的子树
template <class T>
void BinaryTreeTwo<T>::destroy(BinTreeNode<T> *& current)
{
if(current!=NULL)
{
destroy(current->leftChild);
destroy(current->rightChild);
delete current;
}
}
//从结点start开始搜索结点current的父结点，若找到则返回父结点，否则返回NULL
template <class T>
BinTreeNode<T> * BinaryTreeTwo<T>::Parent(BinTreeNode<T> * start,BinTreeNode<T> * current)
{
if(start==NULL)
return NULL;
if(start->leftChild==current||start->rightChild==current)
return start;
BinTreeNode<T> * p;
if((p=Parent(start->leftChild,current))!=NULL)
return p;
else
return Parent(start->rightChild,current);
}
template <class T>
void BinaryTreeTwo<T>::Traverse(BinTreeNode<T> * current,ostream & out) const
{
if(current!=NULL)
{
out<<current->data<<" ";
Traverse(current->leftChild,out);
Traverse(current->rightChild,out);
}
if(root==NULL)
cout<<"此二叉树是空树！"<<endl;
}
template <class T>
istream & operator >>(istream & in,BinaryTreeTwo<T> & Tree)
{
Tree.CreateBinTree(in,Tree.root);
return in;
}
template <class T>
ostream & operator << (ostream & out,BinaryTreeTwo<T> & Tree)
{
out<<"二叉树的前序遍历结果为："<<endl;
Tree.Traverse(Tree.root,out);
out<<endl;
return out;
}
/*
//从输入流in输入二叉树的广义表表示建立对应的二叉链表
template<class T>
void BinaryTreeTwo<T>::CreateBinTree(istream &in, BinTreeNode<T> *&subTree)
{
LinkedStack< BinTreeNode<T> * > s;
subTree = NULL; //置空二叉树
BinTreeNode<T> *p,*t;
int k; //用k作为处理左右子树的标记
T ch;
cout<<"请用广义表的方法输入二叉树:"<<endl;
in>>ch; //从in顺序读入一个字符
while (ch != RefValue) //逐个字符处理
{
switch (ch)
{
case '(': //进入子树
s.Push(p);
k = 1;
break;
case ')': //退出子树
s.Pop(t);
break;
case ',':
k = 2;
break;
default:
p = new BinTreeNode<T>(ch);
if(subTree == NULL)
subTree = p;
else if (k == 1)
{
s.GetTop(t);
t->leftChild = p; //链入*t的左子女
}
else
{
s.GetTop(t);
t->rightChild = p;
}
}
in>>ch;
}
}
*/
//以递归方式应用前序遍历建立二叉树
template<class T>
void BinaryTreeTwo<T>::CreateBinTree(istream& in,BinTreeNode<T>* &subTree)
{
T item;
if(! in.eof())
{
in >> item;
if (item != RefValue)
{
subTree = new BinTreeNode<T>(item);
if(subTree == NULL)
{
cerr<<"存储分配错误！"<<endl;
exit(1);
}
CreateBinTree(in,subTree->leftChild);
CreateBinTree(in,subTree->rightChild);
}
else
subTree = NULL;
}
}
template <class T>
void BinaryTreeTwo<T>::InOrder()
{
InOrder(root);
}
/*
//二叉树前序遍历的非递归算法
template<class T>
void BinaryTreeTwo<T>::InOrder()
{
LinkedStack< BinTreeNode<T>* > s;
BinTreeNode<T> *p = root; //p是遍历指针，从根结点开始
do
{
while (p != NULL) //遍历指针未到最左下的结点，不空
{
s.Push(p); //该子树沿途结点进栈
p = p->leftChild; //遍历指针进到左子女结点
}
if(!s.IsEmpty()) //栈不空时退栈
{
s.Pop(p);
cout<<p->data<<" "; //退栈，访问结点
p = p->rightChild; //遍历指针进到右子女结点
}
} while (p != NULL || !s.IsEmpty());
}
*/
template <class T>
void BinaryTreeTwo<T>::InOrder(BinTreeNode<T> * current)
{
if(current!=NULL)
{
InOrder(current->leftChild);
cout<<current->data<<" ";
InOrder(current->rightChild);
}
}
template <class T>
void BinaryTreeTwo<T>::PreOrder()
{
PreOrder(root);
}
/*
//二叉树前序遍历的非递归算法一
template<class T>
void BinaryTreeTwo<T>::PreOrder()
{
LinkedStack< BinTreeNode<T>* > s;
BinTreeNode<T> *p = root;
s.Push(NULL);
while (p != NULL)
{
cout<<p->data<<" "; //访问结点
if(p->rightChild != NULL)
s.Push(p->rightChild); //预留右子树指针在栈中
if(p->leftChild != NULL)
p = p->leftChild; //进左子树
else
s.Pop(p);
}
}
*/
/*
//二叉树前序遍历的非递归算法二
template<class T>
void BinaryTreeTwo<T>::PreOrder()
{
LinkedStack< BinTreeNode<T>* > s;
BinTreeNode<T> *p;
s.Push(root);
while (!s.IsEmpty())
{
s.Pop(p); //退栈
cout<<p->data<<" "; //访问结点
if(p->rightChild != NULL)
s.Push(p->rightChild);
if(p->leftChild != NULL)
s.Push(p->leftChild);
}
}
*/
template <class T>
void BinaryTreeTwo<T>::PreOrder(BinTreeNode<T> * current)
{
if(current!=NULL)
{
cout<<current->data<<" ";
PreOrder(current->leftChild);
PreOrder(current->rightChild);
}
}
template <class T>
void BinaryTreeTwo<T>::PostOrder()
{
PostOrder(root);
}
/*
template<class T>
void BinaryTreeTwo<T>::PostOrder()
{
LinkedStack< stkNode<T> > s;
stkNode<T> w;
BinTreeNode<T> *p = root; //p是遍历指针
do
{
while (p != NULL) //左子树经过结点加L进栈
{
w.ptr = p;
w.tag = L;
s.Push(w);
p = p->leftChild; //向最左下结点走下去
}
int continue1 = 1; //继续循环标记，用于R
while (continue1 && !s.IsEmpty())
{
s.Pop(w);
p = w.ptr; //栈不空，退栈
switch (w.tag) //判断栈顶的tag标记
{
case L: //从左子树退回，修改栈顶tag
w.tag = R;
s.Push(w);
continue1 = 0;
p = p->rightChild; //从右子树遍历下去
break;
case R: //从右子树退回，访问根结点
cout<<p->data<<" ";
break;
}
}
} while (! s.IsEmpty()); //还有结点未遍历，继续循环
cout<<endl;
}
*/
template <class T>
void BinaryTreeTwo<T>::PostOrder(BinTreeNode<T> * current)
{
if(current!=NULL)
{
PostOrder(current->leftChild);
PostOrder(current->rightChild);
cout<<current->data<<" ";
}
}
template<class T>
void BinaryTreeTwo<T>::LevelOrder()
{
LevelOrder(root);
}
template<class T>
void BinaryTreeTwo<T>::LevelOrder(BinTreeNode<T> * current)
{
LinkedQueue< BinTreeNode<T> * > Q;
BinTreeNode<T> *p = root;
Q.EnQueue(p);
while (! Q.IsEmpty())
{
Q.DeQueue(p);
cout<<p->data<<' ';
if(p->leftChild != NULL)
Q.EnQueue(p->leftChild);
if(p->rightChild != NULL)
Q.EnQueue(p->rightChild);
}
}
template<class T>
void BinaryTreeTwo<T>::PrintBTree()
{
PrintBTree(root);
}
template<class T>
void BinaryTreeTwo<T>::PrintBTree(BinTreeNode<T> *BT)
{
if (BT != NULL) //树为空时结束递归
{
cout<<BT->data; //输出根结点的值
if (BT->leftChild != NULL || BT->rightChild != NULL)
{
cout<<"("; //输出左括号
PrintBTree(BT->leftChild); //输出左子树
cout<<","; //输出逗号分隔符
if(BT->rightChild != NULL) //若右子树不为空
PrintBTree(BT->rightChild); //输出右子树
cout<<")";
}
}
}
template <class T>
int BinaryTreeTwo<T>::Size(const BinTreeNode<T> * t)const
{
if(t==NULL)
return 0;
return 1+Size(t->leftChild)+Size(t->rightChild);
}
template <class T>
int BinaryTreeTwo<T>::Height(const BinTreeNode<T> * t)const
{
if(t==NULL)
return 0;
else
{
int i = Height(t->leftChild);
int j = Height(t->rightChild);
return (i<j) ? j+1 : i+1;
}
}
template<class T>
BinaryTreeTwo<T> BinaryTreeTwo<T>::operator= (const BinaryTreeTwo<T> &b)
{
root = Copy(b.root);
return *this;
}
template <class T>
BinaryTreeTwo<T>::BinaryTreeTwo(const BinaryTreeTwo<T> & s)
{
root = Copy(s.root);
}
template <class T>
BinTreeNode<T> * BinaryTreeTwo<T>::Copy(BinTreeNode<T> * orignode)
{
if(orignode == NULL) //根为空，返回空指针
return NULL;
BinTreeNode<T> *temp = new BinTreeNode<T>; //创建根结点
temp->data = orignode->data;
temp->leftChild = Copy(orignode->leftChild);
temp->rightChild = Copy(orignode->rightChild);
return temp;
}
template <class T>
bool operator == (const BinaryTreeTwo<T> & s,const BinaryTreeTwo<T> & t)
{
return equal(s.root,t.root);
}
template <class T>
bool equal(BinTreeNode<T> * a,BinTreeNode<T> * b)
{
if(a==NULL && b==NULL)
return true;
if(a!=NULL && b!=NULL && a->data==b->data && equal(a->leftChild,b->leftChild) && equal(a->rightChild,b->rightChild))
return true;
else
return false;
}
template<class T>
BinTreeNode<T> *BinaryTreeTwo<T>::Find(BinTreeNode<T>* current,const T & item) const
{
if(current==NULL)
return NULL;
if(current->data==item)
return current;
else
{
if(Find(current->leftChild,item) == NULL)
Find(current->rightChild,item);
}
}
template<class T>
int BinaryTreeTwo<T>::Insert(BinTreeNode<T>*& current,const T& item)
{
if(current==root&&root==NULL)
{
root=new BinTreeNode<T>(item,NULL,NULL);
root->data=item;
return 1;
}
if(current==NULL)
return 0;
if(current->leftChild==NULL)
{
BinTreeNode<T>* temp=new BinTreeNode<T>(item,NULL,NULL);
current->leftChild=temp;
return 1;
}
if(current->rightChild==NULL)
{
BinTreeNode<T>* temp=new BinTreeNode<T>(item,NULL,NULL);
current->rightChild=temp;
return 1;
}
if(Height(current->leftChild)<=Height(current->rightChild))
return Insert(current->leftChild,item);
return Insert(current->rightChild,item);
}
#endif
