Introduction to Algorithms Chapter 12: Binary Search Tree

//

//  main.cpp

//  Data Structure TRY1

//

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

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

//

// Introduction to Algorithms: Chapter 12 Binary Search Tree

#include<iostream>

using namespace std;

#include<math.h>

template<typename Comparable>

class BinarySearchTree

{

public:

    BinarySearchTree()

    {

       root=NULL;

    }

    

    BinarySearchTree(const BinarySearchTree &rhs)

    {

        

       root=clone(rhs.root);

    }

    

    constBinarySearchTree & operator=(const BinarySearchTree &rhs)

    {

       if( this!=&rhs)

        {

           makeEmpty(root);

           root=clone(rhs.root);

        }

       return *this;

    }

    

    ~BinarySearchTree()

    {

        makeEmpty(root);

    }

    

   const Comparable &findMin() const

    {

        returnTree_Minimum(root)->key;

    }

    

   const Comparable &findMax() const

    {

        returnTree_Maximum(root)->key;

    }

    

   bool contains( const Comparable x)const

    {

       if( Tree_Search(root,x)==NULL)return false;

        else return true;

    }

    

   void insert( const Comparable &x)

    {

       TreeNode *tt=newTreeNode(x, NULL,NULL, NULL);

       Tree_Insert(tt);

    }

    

   void remove( const Comparable &x)

    {

       TreeNode *tt=Tree_Search(root, x);

        

       if( tt!=NULL)

        {

           TreeNode *p=Tree_Delete(tt);

           delete p;

        }

    }

    

   void print()

    {

       Print(root,0);

    }

    

   void printInOrder()

    {

        PrintInOrder(root);

       cout<<endl;

    }

    

private:

   struct TreeNode

    {

        Comparable key;

       TreeNode *left, *right, *parent;

        

        TreeNode(const Comparable & x=Comparable(), TreeNode *lt=NULL, TreeNode *rt=NULL, TreeNode *pt=NULL)

        :key(x), left(lt),right(rt), parent(pt){}

    };

    

   TreeNode *root;

    

   TreeNode *Tree_Search( TreeNode *t, Comparable x) const

    {

       if( t==NULL || t->key==x)return t;

       else if( x< t->key)return Tree_Search(t->left, x);

       else returnTree_Search(t->right, x);

    }

    

   TreeNode *Tree_Minimum( TreeNode *t) const

    {

       while( t->left!=NULL)

            t=t->left;

        

       return t;

    }

    

   TreeNode *Tree_Maximum( TreeNode *t) const

    {

       while( t->right!=NULL)

            t=t->right;

        

       return t;

    }

    

   TreeNode *Tree_Successor( TreeNode *x) const

    {

       if( x->right!=NULL)

           return Tree_Minimum(x->right);

        

       TreeNode *y=x->parent;

        

       while( y!=NULL && x==y->right)

        {

            x=y; y=y->parent;

        }

       return y;

    }

    

   TreeNode *Tree_Predecessor( TreeNode *x) const 

    {

       if( x->left!=NULL)

           return Tree_Maximum(x->left);

        

       TreeNode *y=x->parent;

       while( y!=NULL && x==y->left)

        {

            x=y; y=y->parent;

        }

       return y;

    }

    

   void Tree_Insert( TreeNode *z)

    {

       TreeNode *y=NULL;

       TreeNode *x=root;

        

       while( x!=NULL)

        {

            y=x;

           if( z->key < x->key) x=x->left;

           else x=x->right;

        }

        

        z->parent=y;

       if( y==NULL)root=z;

       else if( z->key < y->key) y->left=z;

       else y->right=z;

        

    }

    

   TreeNode *Tree_Delete( TreeNode *z)

    {

       TreeNode *y=NULL;

       if( z->left==NULL || z->right==NULL)

            y=z;

       else y=Tree_Successor(z);

        

       TreeNode *x=NULL;

       if( y->left==NULL)

            x=y->left;

       else x=y->right;

        

       if( x!=NULL)

            x->parent=y->parent;

        

       if( y->parent==NULL)

           root=x;

       else if( y==y->parent->left)

            y->parent->left=x;

       else y->parent->right=x;

        

       if( y!=z)

            z->key=y->key;

        

       return y;

    }

    

   TreeNode *clone( TreeNode *t)const

    {

       if( t==NULL)return NULL;

       else returnnew TreeNode(t->key,clone(t->left),clone(t->right), t->parent);

    }

    

   void makeEmpty( TreeNode *t)

    {

       if( t!=NULL)

        {

           makeEmpty(t->left);

           makeEmpty(t->right);

           delete t;

        }

    }

    

   void Print( TreeNode *t,int level)

    {

       if( t!=NULL)

        {

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

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

               cout<<" ";

           cout<<t->key<<endl;

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

        }

    }

    

   void PrintInOrder( TreeNode *t)

    {

       if( t!=NULL)

        {

           PrintInOrder(t->left);

           cout<<t->key<<" ";

           PrintInOrder(t->right);

        }

    }

    

};

int main()

{

    BinarySearchTree<int> T1;

    

   for( int i=0; i<20; ++i)

        T1.insert(rand()%101);

    

    BinarySearchTree<int> T;

    

    T.insert(100);

    T.printInOrder();

    

    T=T1;

    

    

    T.print();

    

    T.printInOrder();

    

   int x;

   while( cin>>x)

    {

       cout<<T.contains(x)<<endl;

        T.remove(x);

        T.print();

        T.printInOrder();

    }

    

    

    

    return 0;

}