Data Structures (Weiss) Chapter 4: Binary Search Tree C++

//

//  main.cpp

//  Data Structure TRY1

//

//  Created by zr9558 on 6/7/13.

//  Copyright (c) 2013 zr9558. All rights reserved.

//

// Data Structure C++, Weiss, P.126 BinarySearchTree

// add a function PrintTree

#include <iostream>

using namespace std;

template<typename Comparable>

class BinarySearchTree

{

public:

    BinarySearchTree() { root=NULL;}

    BinarySearchTree(const BinarySearchTree &rhs)

    {

       operator=(rhs);

    }

    

    ~BinarySearchTree()

    {

        makeEmpty();

    }

    

   const BinarySearchTree &operator=(const BinarySearchTree &rhs)

    {

       if(this!=&rhs)

        {

            makeEmpty();

            root=clone(rhs.root);

        }

       return *this;

    }

    

   const Comparable &findMin()const

    {

       return findMin(root)->element;

    }

    

   const Comparable &findMax()const

    {

       return findMax(root)->element;

    }

    

   bool contains(const Comparable &x)const;

   bool isEmpty()const;

    

   void printTreePreOrder()const

    {

        printTreePreOrder(root);

        cout<<endl;

    }

    

   void printTreeInOrder()const

    {

        printTreeInOrder(root);

        cout<<endl;

    }

    

   void printTreePostOrder()const

    {

        printTreePostOrder(root);

        cout<<endl;

    }

    

   void printTree()const

    {

        PrintTree(root,0);

    }

    

   void makeEmpty();

   void insert(const Comparable &x);

   void remove(const Comparable &x);

    

    

    

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

    {

       if( t==NULL) t=new BinaryNode(x,NULL,NULL);

       elseif( x<t->element) insert(x,t->left);

       elseif( x>t->element) insert(x,t->right);

        else ;//duplicate, do nothing.

    }

    

   void remove(const Comparable &x, BinaryNode * &t)const

    {

       if( t==NULL)return;

       if( x<t->element) remove(x,t->left);

       elseif( x>t->element) remove(x,t->right);

       elseif( t->left!=NULL && t->right!=NULL)

        {

            t->element=findMin(t->right)->element;

            remove( t->element, t->right);

        }

       else

        {

            BinaryNode *oldNode=t;

            t=(t->left!=NULL) ? t->left : t->right;

           delete oldNode;

        }

    }

    

    BinaryNode *findMin(BinaryNode *t)const

    {

       if( t==NULL)returnNULL;

       if( t->left==NULL)return t;

       return findMin(t->left);

    }

    

    BinaryNode *findMax(BinaryNode *t)const

    {

       if( t==NULL)returnNULL;

       if( t->right==NULL)return t;

       return findMax(t->right);

    }

    

   bool contains(const Comparable &x, BinaryNode *t)const;

   void makeEmpty( BinaryNode * &t)

    {

       if( t!=NULL)

        {

            makeEmpty(t->left);

            makeEmpty(t->right);

           delete t;

        }

        t=NULL;

    }

    

   void printTreePreOrder( BinaryNode *t)const

    {

       if( t!=NULL)

        {

            cout<<t->element<<" ";

            printTreePreOrder(t->left);

            printTreePreOrder(t->right);

        }

    }

   void printTreeInOrder( BinaryNode *t)const

    {

       if( t!=NULL)

        {

            printTreeInOrder(t->left);

            cout<<t->element<<" ";

            printTreeInOrder(t->right);

        }

    }

    

   void printTreePostOrder( BinaryNode *t)const

    {

       if( t!=NULL)

        {

            printTreePostOrder(t->left);

            printTreePostOrder(t->right);

            cout<<t->element<<" ";

        }

    }

    

    BinaryNode *clone( BinaryNode *t)const

    {

       if( t==NULL)returnNULL;

        

       returnnew BinaryNode(t->element, clone(t->left), clone(t->right));

    }

    

   void PrintTree( BinaryNode *t,int level) const

    {

       if( t!=NULL)

        {

            PrintTree( t->right, level+1);

           for(int i=0; i<6*level; ++i)

                cout<<" ";

            cout<<t->element<<endl;

            PrintTree(t->left,level+1);

        }

    }

    

};

template<typename Comparable>

bool BinarySearchTree<Comparable>::contains(const Comparable &x)const

{

   return contains(x,root);

}

template<typename Comparable>

void BinarySearchTree<Comparable>::insert(const Comparable &x)

{

    insert(x,root);

}

template<typename Comparable>

void BinarySearchTree<Comparable>::remove(const Comparable &x)

{

    remove(x,root);

}

template<typename Comparable>

bool BinarySearchTree<Comparable>::contains(const Comparable &x, BinaryNode *t)const

{

    if( t==NULL)returnfalse;

   elseif( x<t->element)return contains(x,t->left);

   elseif( x>t->element)return contains(x,t->right);

    else returntrue;

}

template<typename Comparable>

void BinarySearchTree<Comparable>::makeEmpty()

{

    makeEmpty(root);

}

template<typename Comparable>

bool BinarySearchTree<Comparable>::isEmpty()const

{

   return root==NULL;

}

int main()

{

    BinarySearchTree<int> T;

   for(int i=5; i<25; ++i)

        T.insert(i%10);

    

    T.printTreeInOrder();

    T.printTreePreOrder();

    T.printTreePostOrder();

    

    T.printTree();

    

    BinarySearchTree<int> T1(T), T2;

    T2=T;

    

    T1.printTreeInOrder();

    T1.printTreePreOrder();

    T1.printTreePostOrder();

    

    T2.printTreeInOrder();

    T2.printTreePreOrder();

    T2.printTreePostOrder();

    

    T2.remove(5);

    

    T2.printTreeInOrder();

    T2.printTreePreOrder();

    T2.printTreePostOrder();

    

    

    

    return 0;

}