内容和提示:
1.在二叉链表上实现二叉树运算
(1)设计递归算法,实现下列二叉树元算:
删除一颗二叉树,
求一颗二叉树的高度,
求一棵二叉树中叶子结点数,
复制一棵二叉树,
交换一棵二叉树的左右子树。
//btnode.h
#include<iostream>
using namespace std;
template<class T>
struct BTNode
{
T element;
BTNode<T> *lChild,*rChild;
BTNode(){ lChild=rChild=NULL;}
BTNode(const T &x){element=x; lChild=rChild=NULL;}
BTNode(const T &x,BTNode *l,BTNode *r){element=x; lChild=l; rChild=r;}
};
//seqqueue.h
template <class T>
class SeqQueue
{
public:
SeqQueue(int mSize);
void InitiaQueue();
~SeqQueue() {delete []q;}
bool IsEmpty()const{return front == rear;}
bool IsFull()const{return (rear + 1) % maxSize == front;}
bool Front(T &x)const;
bool EnQueue(T x);
bool DeQueue();
void Clear(){front = rear = 0; }
int GetFront(){return front;}
private:
int front, rear;
int maxSize;
T *q;
};
template <class T>
SeqQueue<T>::SeqQueue(int mSize)
{
maxSize = mSize;
q = new T[maxSize];
front = rear = 0;
}
template <class T>
void SeqQueue<T>::InitiaQueue()
{
int i;
for ( i = 0; i < maxSize; i++ )
{
q[i] = 0; // 初始值都为0
front = 0;
rear = 0;
}
}
template <class T>
bool SeqQueue<T>::Front(T &x)const
{
if (IsEmpty())
{
cout<<"Empty!"<<endl;
return false;
}
x = q[(front + 1) % maxSize];
return true;
}
template <class T>
bool SeqQueue<T>::EnQueue(T x)
{
if (IsFull())
{
cout<<"Full!"<<endl;
return false;
}
q[(rear = rear + 1) % maxSize] = x; //rear++ OK?
return true;
}
template <class T>
bool SeqQueue<T>::DeQueue()
{
if (IsEmpty())
{
cout<<"Empty!"<<endl;
return false;
}
front = (front + 1) % maxSize;
return true;
}
//binarytree.h
#include"btnode.h"
#include"seqqueue.h"
template<class T>
class BinaryTree
{
public:
BinaryTree(){root=NULL;}
~BinaryTree(){Clear();}
void MakeTree(const T &x,BinaryTree<T> &left,BinaryTree<T> &right);
void BreakTree( T &x,BinaryTree<T> &left,BinaryTree<T> &right);
void PreOrder(void (*Visit)(T &x));
int Size();
void Copy(BinaryTree &temp);
int Height();
void Exchange();
int LeafNum();
void Clear();
void LevelOrder(void (*Visit)(T &x));
protected:
BTNode<T> *root;
private:
void PreOrder(void (*Visit)(T &x),BTNode<T> *t);
int Size(BTNode *t);
BTNode<T> * Copy(BTNode<T> * t);
int Height(BTNode<T>* t);
void Exchange(BTNode<T> *t);
int Size(BTNode<T> *t);
int LeafNum(BTNode<T> *t);
void Clear(BTNode<T> *x);
//void LevelOrder (void (*Visit)(T& x),BTNode<T>* &t);
void LevelOrder (BTNode<T>* t);
};
/*MakeTree*/
template<class T>
void BinaryTree<T>::MakeTree(const T &x,BinaryTree<T> &left,BinaryTree<T> &right)
{
if(root||&left==&right) return;
root=new BTNode<T>(x,left.root,right.root);
left.root=right.root=NULL;
}
/*BreakTree*/
template<class T>
void BinaryTree<T>::BreakTree(T &x,BinaryTree<T> &left,BinaryTree<T> &right)
{
if(!root||&left==&right||left.root||right.root) return;
x=root->element;
left.root=root->lChild;right.root=root->rChild;
delete root;root=NULL;
}
/*PreOrder*/
template<class T>
void Visit(T &x)
{
cout<<x<<" ";
}
template<class T>
void BinaryTree<T>::PreOrder(void (*Visit)(T &x))
{
PreOrder(Visit,root);
}
template<class T>
void BinaryTree<T>::PreOrder(void (*Visit)(T &x),BTNode<T> *t)
{
if(t)
{
Visit(t->element);
PreOrder(Visit,t->lChild);
PreOrder(Visit,t->rChild);
}
}
/*Size*/
template<class T>
int BinaryTree<T>::Size()
{
return Size(root);
}
template<class T>
int BinaryTree<T>::Size(BTNode<T> *t)
{
if(!t) return 0;
static int num=0;
if(t->lChild) num++;
if(t->rChild) num++;
Size(t->lChild);
Size(t->rChild) ;
return num+1;
//return Size(t->lChild)+Size(t->rChild)+1;
}
/*Copy*/
template<class T>
void BinaryTree<T>::Copy(BinaryTree<T> &temp)
{
root=Copy(temp.root);
}
template
<class T>
BTNode<T> * BinaryTree<T>::Copy(BTNode<T> * t)
{
if(!t) return NULL;
BTNode<T> *q= new BTNode<T>(t->element);
q->lChild=Copy(t->lChild);q->rChild=Copy(t->rChild);
return q;
}
/*Height*/
template<class T>
int BinaryTree<T>::Height()
{
return Height(root);
}
template<class T>
int BinaryTree<T>::Height(BTNode<T>* t)
{
int ltemp=0;
int rtemp=0;
if(!t)
return 0;
ltemp=Height(t->lChild);
rtemp=Height(t->rChild);
if(ltemp++ > rtemp++)
return ltemp;
else
return rtemp;
}
/*LeafNum*/
template<class T>
int BinaryTree<T>::LeafNum()
{
return LeafNum(root);
}
template<class T>
int BinaryTree<T>::LeafNum(BTNode<T> *t)
{
static int num=0;
if(!t) return 0;
if((!(t->lChild))&&(!(t->rChild))) num++;
LeafNum(t->lChild);
LeafNum(t->rChild);
return num;
}
/*Exchange*/
template <class T>
void BinaryTree<T>::Exchange()
{
Exchange(root);
}
template <class T>
void BinaryTree<T>::Exchange(BTNode<T> *t)
{
if (!t) return;
BTNode<T> *temp;
temp = t->lChild;
t->lChild = t->rChild;
t->rChild = temp;
Exchange(t->lChild);
Exchange(t->rChild);
}
/*Clear*/
template<class T>
void BinaryTree<T>::Clear()
{
Clear(root);
}
template <class T>
void BinaryTree<T>::Clear(BTNode<T> *x)
{
if (!x) return;
BinaryTree<T> a,b;
BTNode<T> *l=x->lChild,*r=x->rChild; //指向root指向的结点的左右孩子
BreakTree(x->element,a,b);
Clear(l);
Clear(r);
}
/*LevelOrder*/
template <class T>//存在小bug
void BinaryTree<T>::LevelOrder(void (*Visit)(T &x))
{
LevelOrder(root);
}
template <class T>
void BinaryTree<T>::LevelOrder(BTNode<T> *t)
{
SeqQueue<BTNode<T>*> Q(Size());
if (!t)
{
cout<<"空树!"<<endl;
return;
}
BTNode<T> * p;
p = root;
Q.EnQueue(p);
Visit(p->element);
if (p->lChild)
Q.EnQueue(p->lChild);
if (p->rChild)
Q.EnQueue(p->rChild);
while (!Q.IsEmpty())
{
Q.DeQueue();
Q.Front(p);
if (Q.GetFront() == 0)
break;
Visit(p->element);
if (p->lChild)
Q.EnQueue(p->lChild);
if (p->rChild)
Q.EnQueue(p->rChild);
}
Q.DeQueue();
return;
}
//main
#ifndef btnode_h
#define btnode_h
#endif
#include"binary_tree.h"
void main()
{
BinaryTree<char> a,b,x,y,z,newtree;
y.MakeTree('Y',a,b);
z.MakeTree('Z',a,b);
a.MakeTree('A',y,z);
x.MakeTree('X',a,b);cout<<"BinaryTree x:";x.PreOrder(Visit);cout<<endl;
cout<<"BinaryTree x size:"<<x.Size()<<endl;
cout<<"newtree:";newtree.Copy(x);newtree.PreOrder(Visit);cout<<endl;
cout<<"BinaryTree x height:"<<x.Height()<<endl;
x.Exchange();cout<<"Exchanged BinaryTree x:";x.PreOrder(Visit);cout<<endl;
cout<<"BinaryTree x LeafNum:"<<x.LeafNum()<<endl;
cout<<"LevelOrder:"; x.LevelOrder(Visit);
x.Clear();cout<<"BinaryTree x Clear :";x.PreOrder(Visit);cout<<endl;
}