关于二叉树的算法集合

。
#include<iostream.h>
#include<assert.h>
//enum {DefaultSize=100};
template <class Type> class Queue;

template <class Type> class QueueNode { 
friend class Queue<Type>;
private:
    Type data;     //¶ÓÁнáµãÊý¾Ý
    QueueNode<Type> *link;  //½áµãÁ´Ö¸Õë
    QueueNode ( Type d=0, QueueNode
      *l=NULL ) : data (d), link (l) { }
};   
template <class Type> class Queue { 
public:
    Queue ( ) : rear ( NULL ), front ( NULL ) { }
    ~Queue ( );      
    void EnQueue ( const Type & item );
    Type DeQueue ( );     
    Type GetFront ( );     
    void MakeEmpty ( ) { front = rear = NULL; }
    int IsEmpty ( ) const
                    { return front == NULL; } 
private:
    QueueNode<Type> *front, *rear; //¶ÓÁÐÖ¸Õë
};
template <class Type>Queue<Type>::~Queue ( ) {
//¶ÓÁеÄÎö¹¹º¯Êý
   QueueNode<Type> *p;
    while ( front != NULL ) {  //Öð¸ö½áµãÊÍ·Å
        p = front;  front = front->link;  delete p;
    }
}
template <class Type>void  Queue<Type>:: EnQueue ( const Type & item ) {
//½«ÐÂÔªËØitem²åÈëµ½¶ÓÁеĶÓβ
    if ( front == NULL )
  front = rear = new QueueNode<Type> ( item, NULL );
    else
     rear = rear->link = new QueueNode<Type> ( item, NULL );
}
template <class Type> Type
Queue<Type>::DeQueue ( ) {
//ɾȥ¶ÓÍ·½áµã£¬²¢·µ»Ø¶ÓÍ·ÔªËصÄÖµ
    assert ( !IsEmpty ( ) ); //ÅжӿյĶÏÑÔ
    QueueNode<Type> *p = front;  
    Type retvalue = p->data; //±£´æ¶ÓÍ·µÄÖµ
    front = front->link;   delete p;   //жÓÍ·
    return retvalue;    
}
template <class Type>
Type Queue<Type>::GetFront ( ) {
//Èô¶Ó²»¿Õ£¬Ôòº¯Êý·µ»Ø¶ÓÍ·ÔªËصÄÖµ;
//Èô¶Ó¿Õ£¬Ôòº¯Êý·µ»Ø0¡£
    assert ( !IsEmpty ( ) );   
    return front->data;    
}

template <class Type> class Stack;   
template <class Type> class StackNode {
friend class Stack<Type>;
private:
    Type  data;                          //½áµãÊý¾Ý 
    StackNode<Type> *link;  //½áµãÁ´Ö¸Õë 
    StackNode ( Type d=0, StackNode<Type>
         *l=NULL ) : data (d), link (l) { }
};
template <class Type> class Stack { 
public:
    Stack ( ) : top ( NULL ) { }
    ~Stack ( );
    void Push ( const Type & item);
    Type Pop ( );
    Type GetTop ( );
    void MakeEmpty ( ) {top=NULL;}
    int IsEmpty ( ) const
         { return top == NULL; }
private:
    StackNode<Type> *top;       //Õ»¶¥Ö¸Õë
};
template <class Type> Stack<Type>::~Stack ( )
 {
     StackNode <Type>  *p;
     while ( top != NULL )      //Öð½áµã»ØÊÕ
   { p = top;  top = top->link;  delete p; }
}
template <class Type> void Stack<Type>::Push ( const Type &item )
 {
    top = new StackNode<Type> ( item, top );
    //нáµãÁ´Èëtop֮ǰ, ²¢³ÉΪÐÂÕ»¶¥
}
template <class Type> Type Stack<Type>::Pop ( )
{
    assert ( !IsEmpty ( ) );    
    StackNode<Type> *p = top;
    Type retvalue = p->data;  //ÔÝ´æÕ»¶¥Êý¾Ý
    top = top->link;           //ÐÞ¸ÄÕ»¶¥Ö¸Õë
    delete p;   return retvalue;  //ÊÍ·Å,·µ»ØÊý¾Ý
}     
template <class Type> Type Stack<Type>::GetTop ( )
{
    assert ( !IsEmpty ( ) );
    return top->data;
}  

template <class Type> class BinaryTree;  

template <class Type> class BinTreeNode
{
friend class BinaryTree;
public:
    BinTreeNode ( ) :parent(NULL), leftchild (NULL), rightchild (NULL) { }
    BinTreeNode (Type item, BinTreeNode<Type> *left = NULL,BinTreeNode<Type> *right = NULL ) :data (item),  leftchild (left), rightchild(right) { }
    Type & GetData ( ) const { return data; }
 BinTreeNode<Type> *GetLeft ( ) const
      { return leftchild; }  
    BinTreeNode<Type> *GetRight ( ) const
      { return rightchild; }
  BinTreeNode<Type> *GetParent ( ) const
      { return parent; }  
    void SetData ( const Type & item )
   { data = item; }
    void SetLeft ( BinTreeNode <Type> *L )
     { leftchild = L; } 
    void SetRight ( BinTreeNode <Type> *R )
 { rightchild = R; }
   void SetParent ( BinTreeNode <Type> *g )
 { Parent = g; }
 void CreateBinaryTree(BinTreeNode<Type>* &root);
    void BinaryTreerse(BinTreeNode<Type> *&root);
void LevelOrder (  BinTreeNode<Type>*&current);
//private:
    BinTreeNode<Type> *leftchild,  *rightchild,*parent;     
    Type data;
};
template <class Type> class BinaryTree
{ 
public:
    BinaryTree ( ) : root (NULL) { }
    BinaryTree ( Type value ) : RefValue(value) { root=NULL;}  
    virtual ~BinaryTree ( ) { destroy ( root ); }
   void CreateBinaryTree(BinTreeNode<Type>* &root);
    virtual int IsEmpty ( )
    { return root == NULL ? 1 : 0;
 }    
    virtual BinTreeNode <Type> *Parent ( BinTreeNode <Type> *current ) 
    { return root == NULL || root == current?NULL:Parent(root, current);
    }
   virtual BinTreeNode <Type> *leftchild (BinTreeNode <Type> *current )
   { return root != NULL?current->leftchild : NULL;
   }
   virtual BinTreeNode <Type> *rightchild (BinTreeNode <Type> *current)
    { return root != NULL ?current->rightchild : NULL;
 }
    void insert( BinTreeNode<Type> *&current,Type item);
   
    BinTreeNode <Type> *GetRoot ( ) const
        { return root; }
   

 
 friend istream &operator >> (istream &in, BinaryTree<Type> &Tree ) ;
  
 friend ostream &operator << (ostream &out, BinaryTree <Type> &Tree );
  
void BinaryTreerse(BinTreeNode<Type> *&root);
void LevelOrder (  BinTreeNode<Type>*&current);
BinTreeNode <Type> *root,*current;

          private:
    
   
   Type RefValue;
   
   BinTreeNode <Type> *Parent (BinTreeNode <Type> *start,BinTreeNode <Type> *current);
   
   int Insert ( BinTreeNode<Type> * &current,  Type item ) ;
   
   void Traverse ( BinTreeNode<Type> *current,ostream &out ) const;
   
   int Find ( BinTreeNode<Type> *current, const Type &item ) const  ;           
   
   void destroy(BinTreeNode<Type> *current);
};
template<class Type> void BinaryTree<Type>::insert( BinTreeNode<Type> *&current,Type item)
{ 
if(current==NULL)
current=new BinTreeNode<Type>(item);
else if(current->data>item)
 insert(current->leftchild,item);
else if(current->data<=item)
 insert(current->rightchild,item);
}

template<class Type> void BinaryTree<Type>:: destroy ( BinTreeNode<Type> *current )
{
    if ( current != NULL )
 {
       destroy ( current->leftchild );
       destroy ( current->rightchild );
       delete current;
    }
}
template <class Type> BinTreeNode <Type> *BinaryTree <Type>::Parent ( BinTreeNode <Type>*start, BinTreeNode <Type> *current ) {
    if ( start == NULL ) return NULL;
    if ( start->leftchild == current || start->rightchild == current )
  return start; 
    BinTreeNode <Type> *p;
    if ( ( p = Parent ( start->leftchild, current ) ) != NULL ) return p; 
    else return Parent ( start->rightchild, current );
}
template <class Type> void BinaryTree<Type>::Traverse ( BinTreeNode <Type> *current, ostream &out ) const
 {
    if ( current != NULL )
 {           
        out << current->data << "  ";
        Traverse ( current->leftchild, out );  
        Traverse ( current->rightchild, out );
    }
}
template <class Type> istream & operator>>( istream & in, BinaryTree <Type> &Tree )
{     Type item;
     
         cout << "¹¹Ôì¶þ²æÊ÷:/n ";      
        cout << "ÊäÈëÊý¾Ý (Óà " << Tree.RefValue <<"½áÊø): ";
       in >> item;      
       while ( item != Tree.RefValue ) {   
    Tree.insert ( Tree.root,item );
       //cout << "ÊäÈëÊý¾Ý (Óà " << Tree.RefValue <<"½áÊø): ";  
       in >> item;
    }
    return in;
}
template <class Type> ostream & operator<<( ostream & out, BinaryTree <Type> &Tree )
{  
    out << "µÝ¹é¶þ²æÊ÷µÄÇ°Ðò±éÀú./n";
    Tree.Traverse ( Tree.root, out );
    out << endl;
    return out;
}
template<class Type>void BinaryTree<Type>::CreateBinaryTree(BinTreeNode<Type>* &root)
{
  //°´Ç°ÐòÐòÁÐÊäÈë¶þ²æÊ÷ÖнáµãµÄÖµ(Ò»¸ö×Ö·û)£¬¿Õ¸ñ×Ö·û±íʾ¿ÕÊ÷£¬¹¹Ôì¶þ²æÁ´±í±íʾµÄ¶þ²æÊ÷T.
  int ch;
  cin>>ch;
  while(ch!=10)
 { cin>>ch;
  //if(ch==' ') root=NULL;
  //else{
      root=new BinTreeNode<Type>();
      //if(!t ) {cerr<<"½¨Á¢²»³É¹¦";     exit(1);}
      root->data=ch;
  //}//³É¸ù½áµã
     CreateBinaryTree(root->leftchild); //¹¹Ôì×ó×ÓÊ÷
     CreateBinaryTree(root->rightchild); //¹¹ÔìÓÒÓÚÊ÷
   
 }
 cout<<"½¨Á¢³É¹¦";
}//£¯£¯CreateBinaryTree

template<class Type>void BinaryTree<Type>::BinaryTreerse(BinTreeNode<Type> * &root)
{
  //²ÉÓöþ²æÁ´±í´æ´¢½á¹¹
  Stack <BinTreeNode<Type>*>s;
  BinTreeNode<Type> *p=root;
  s.MakeEmpty();
  //s.Push(p);//¸ùÖ¸Õë½øÕ»
  cout<<"·ÇµÝ¹é¶þ²æÊýµÄÖÐÐò±éÀú"<<endl;
  while(p!=NULL|| !s.IsEmpty())
  {
    while(p!=NULL)  { s.Push(p);p=p->leftchild;}//Ïò×ó×ßµ½¾¡Í·
    if(!s.IsEmpty())
 {    //·ÃÎʽáµã£¬ÏòÓÒÒ»²½
      p=s.Pop();
  
   cout<<p->data<<"  ";
     p=p->rightchild;
    }//if
  }//while
  cout<<endl;
}// lnOrderTraverse
template <class Type> void BinaryTree<Type>::LevelOrder ( BinTreeNode<Type>*&current)
 {

Queue<BinTreeNode<Type>*> Qu ;
// BinTreeNode<Type> *p;
//BinTreeNode<Type> *current1;

       Qu.EnQueue ( current );
    cout<<"·ÇµÝ¹é²ã´Î±éÀú"<<endl;;
       while ( !Qu.IsEmpty ( ) )
    {  //¶ÓÁв»¿Õ
    current = Qu.DeQueue ( ); 
   
   cout<<current->data<<"  ";//¸ù½ø¶ÓÁÐ
    //visit ( );  
            //Í˳ö¶ÓÁÐ,·ÃÎÊ
 if(current->leftchild)
   Qu.EnQueue ( current->leftchild );
 if(current->rightchild)
  Qu.EnQueue(current->rightchild);
 

        }
    cout<<endl;
}
  

void main()
{

 BinaryTree <int>*Tree=new BinaryTree<int>(10);
//Tree->CreateBinaryTree(Tree->root);
cin>>*Tree;
Tree->BinaryTreerse(Tree->root);
cout<<*Tree;
Tree->LevelOrder(Tree->root);

}