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);
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;
}