二叉树

#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