//
// 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);
else if( x<t->element) insert(x,t->left);
else if( 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);
else if( x>t->element) remove(x,t->right);
else if( 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)return NULL;
if( t->left==NULL)return t;
return findMin(t->left);
}
BinaryNode *findMax(BinaryNode *t)const
{
if( t==NULL)return NULL;
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)return NULL;
return new 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)return false;
else if( x<t->element)return contains(x,t->left);
else if( 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;
}