二叉查找树

template <typename Comparable>
class BinarySearchTree
{
private:
    struct BinaryNode
    {
        Comparable element;
        BinaryNode *left;
        BinaryNode *right;
        
        BinaryNode( const Comparable & theElement, BinaryNode *lt,
                   BinaryNode *rt ): element( theElement ),left( lt ),
        right( rt ){    }
    };
    
    BinaryNode *root;
    
    void insert( const Comparable & x, BinaryNode * & t ) const;
    void remove( const Comparable & x, BinaryNode * & t ) const;
    BinaryNode * findMin( BinaryNode *t ) const;
    BinaryNode * findMax( BinaryNode *t ) const;
    void printTree( BinaryNode * t ) const;
    BinaryNode *clone( BinaryNode *t )const;
    
public:
    BinarySearchTree( );
    BinarySearchTree( const BinarySearchTree & rhs );
    ~BinarySearchTree( );
    
    const Comparable & findMin( ) const;
    const Comparable & findMax( ) const;
    bool contains( const Comparable & x ) const;
    bool isEmpty( )const;
    void printTree( )const;
    
    void makeEmpty( );
    void insert( const Comparable & x );
    void remove( const Comparable & x );
    
    const BinarySearchTree & operator= ( const BinarySearchTree
                                        & rhs );
    
};
bool contains( const Comparable & x ) const
{
	return contains( x, root );
}
void insert( const Comparable & x )
{
	insert( x, root );
}
void remove( const Comparable & x )
{
	remove( x, root );
}
bool contains( const Comparable & x, BinaryNode *t )
const
{
	if( t == NULL)
		return false;
		else if( x < t->element )
			{
				return contains( x, t->right );
			}
			else if( x > t->element )
								{
									return contains( x, t->left );	
								}else

				return true;
			
}


BinaryNode * findMin( BinaryNode *t )const
{
	if( t == NULL )
		{
			return NULL;			
		}
		if( t->left == NULL )
			{
				return t;
			}
			return findMin( t->left );
}
BinaryNode * findMax( BinaryNode *t ) const
{
	if( t!=NULL )
		{
				while( t->right != NULL )
				t = t->right;		
		}
		
		return t;
}
void insert( const Comparable & x,BinaryNode * & t)
{
	if( t==NULL )
		{
			t = new BinaryNode( x, NULL, NULL );
		}
		else if( x < t->left )
			insert( x,t-left );
			else if( t->lement < x )
				insert( x, t->right );
				else return;		
}
void remove( const Compareble & x, BinaryNode * & t )
{
	if( t == NULL )
		return;
		if ( x < t->element )
			remove( x, t->left );
			else if( t->element < x )
				remove( x, t->right );
				else if( t->letf !=NULL && t->right != NULL )
					{
						t->element = findMin( t->right )->element;
						remove( t->element, t->right );
						
					}
					else
						{
							BinaryNode *oleNode = t;
							t = ( t->left != NULL ) ? t->left:
								t->right;
								deleta oldNode;
						}
						
}
~BinarySearchTree( )
{
	makeEmpty( );
}
void makeEmpty( BinaryNode * & t )
{
	if( t!= NULL )
		{
			makeEmpty( t->left );
			makeEmpty( t->right );
			delete t;
		}
		t = NULL;
		
}

BinaryNode *clone( BinaryNode *t ) const
{
	if( t == NULL )
		return NULL;
		return new Binary( t->element, clone( t->left ),clone( t->right ) );
}