//**************************************************************
// customer_exception.h
// ************************************************************
#ifndef CUSTOMER_EXCEPTION_H_
#define CUSTOMER_EXCEPTION_H_
#include<stdexcept>
#include<string>
class customerException :public std::logic_error
{
public:
customerException(const std::string &message=""):
logic_error(message.c_str())
{}
};
#endif
//***********************************************************
// book_exception.h
//***********************************************************
#ifndef BOOK_EXCEPTION_H_
#define BOOK_EXCEPTION_H_
#include<stdexcept>
#include<string>
class bookException:public std::logic_error
{
public:
bookException(const std::string &message=""):
logic_error(message.c_str())
{}
};
#endif
//********************************************************
// book_item.h implemention file---book_item.cpp
//********************************************************
#ifndef BOOK_ITEM_H_
#define BOOK_ITEM_H_
#include<string>
#include<iostream>
#include<fstream>
using namespace std;
class bookItem
{
private:
string title;
string author;
string ISBN;
string publisher;
string category;
string custID;
float price;
int pages;
//construtor function
public:
bookItem(const bookItem&_item);
bookItem();
void createBookItem();
string getTitle()const;
string getAuthor()const;
string getISBN()const;
string getPublisher()const;
string getCategory()const;
string getCustID()const;
bool getStatus()const;
void setCustID(const string &_custID);
bookItem & getPtr();
void display()const;
friend ifstream & operator>>(ifstream &fin,bookItem &_item);
friend ofstream & operator<<(ofstream &fout,const bookItem &_item);
};
#endif
//*****************************************************************
// book_item.cpp book's information
//*****************************************************************
#include"book_item.h"
#include<cstddef>
using namespace std;
bookItem::bookItem(const bookItem &_item)
{
title=_item.title;
author=_item.author;
ISBN=_item.ISBN;
publisher=_item.publisher;
category=_item.category;
custID=_item.custID;
price=_item.price;
pages=_item.pages;
}
bookItem::bookItem()
{
title="";
author="";
ISBN="";
publisher="";
category="";
custID="";
price=0.0;
pages=0;
}
void bookItem::createBookItem()
{
bool isok=false;
char ch;
while(!isok)
{
cout<<"\t\t\t create book item !"<<endl<<endl<<endl;
cout<<" \t\t\tenter the book's title :";
getline(cin,title);
cout<<"\n \t\t\tenter the book's author :";
getline(cin,author);
cout<<"\n \t\t\tenter the book's ISBN :";
getline(cin,ISBN);
cout<<"\n \t\t\tenter the book's publisher :";
getline(cin,publisher);
cout<<"\n \t\t\tenter the book's category :";
getline(cin,category);
cout<<"\n \t\t\tenter the book's price :";
cin>>price;
while(cin.get()!='\n')
;
cout<<"\n \t\t\tenter the book's pages :";
cin>>pages;
while(cin.get()!='\n')
;
cout<<endl<<endl<<endl;
cout<<" \t\t\tbook information is ok !"<<endl;
cout<<" \t\t\tS for Save And R for Reset :";
cin>>ch;
while(cin.get()!='\n')
;
if(ch=='S'||ch=='s')
isok=true;
}
}
string bookItem::getTitle()const
{
return title;
}
string bookItem::getAuthor()const
{
return author;
}
string bookItem::getISBN()const
{
return ISBN;
}
string bookItem::getPublisher()const
{
return publisher;
}
string bookItem::getCategory()const
{
return category;
}
string bookItem::getCustID()const
{
return custID;
}
bool bookItem::getStatus()const
{
if(custID.empty())
return false;
else
return true;
}
void bookItem::setCustID(const string &_custID)
{
custID=_custID;
}
bookItem & bookItem::getPtr()
{
return *this;
}
void bookItem::display()const
{
cout<<"********************************************************************************"<<endl<<endl;
cout<<"**\t\tbook's title : "<<title<<endl;
cout<<"**\t\tbook's author : "<<author<<endl;
cout<<"**\t\tbook's ISBN : "<<ISBN<<endl;
cout<<"**\t\tbook's publisher : "<<publisher<<endl;
cout<<"**\t\tbook's category : "<<category<<endl;
cout<<"**\t\tbook's price : $ "<<price<<endl;
cout<<"**\t\tbook's pages : "<<pages<<endl;
if(getStatus())
cout<<"\t\t\t\tthis book has been borrowed !"<<endl;
else
cout<<"\t\t\t\tthis book is still in lirary !"<<endl;
cout<<"\n********************************************************************************"<<endl<<endl;
}
ifstream &operator>>(ifstream &fin,bookItem &_item)
{
if(fin.peek()=='\n')
fin.ignore(1);
getline(fin,_item.title,'~');
getline(fin,_item.author,'~');
getline(fin,_item.ISBN,'~');
getline(fin,_item.publisher,'~');
getline(fin,_item.category,'~');
if(fin.peek()=='~')
{
fin.ignore(1);
_item.custID="";
}
else
getline(fin,_item.custID,'~');
fin>>_item.price>>_item.pages;
return fin;
}
ofstream &operator<<(ofstream &fout,const bookItem &_item)
{
fout<<_item.title<<'~'<<_item.author<<'~'<<_item.ISBN<<'~'<<_item.publisher<<'~'<<_item.category
<<'~'<<_item.custID<<'~'<<_item.price<<' '<<_item.pages<<endl;
return fout;
}
//************************************************************
// customer_item.h implemention file--customer_item.cpp
//************************************************************
#ifndef CUSTOMER_ITEM_H_
#define CUSTOMER_ITEM_H_
#include<string>
#include<iostream>
#include<fstream>
#include"book_tree.h"
#include"book_item.h"
using namespace std;
class customerItem
{
private:
static const int MAX=5;
string name;
string ID;
string unit;
string password;
int numb;
bookItem *books[MAX];
public:
customerItem();
customerItem(const customerItem &_item);
~customerItem();
void createCustomerItem();
customerItem &operator=(const customerItem &_item);
bookItem*& operator[](int index);
void setPassword(const string &_str);
string getPassword()const;
string getID()const;
void display()const;//attention
void borrow(bookItem &_item);
void revert(const string &_ISBN);
ifstream& readCitem(ifstream &fin,bookTree &btree);
friend ofstream &operator<<(ofstream &fout, customerItem &_item);
};
#endif
//***************************************************************
// customer_item.cpp customer information
//**************************************************************
#include"customer_item.h"
#include"book_item.h"
customerItem::customerItem()
{
name="";
ID="";
unit="";
password="";
numb=0;
for(int i=0;i<MAX;i++)
{
books[i]=NULL;
}
}
customerItem::customerItem(const customerItem &_item)
{
name=_item.name;
ID=_item.ID;
unit=_item.unit;
password=_item.password;
numb=_item.numb;
for(int i=0;i<numb;i++)
books[i]=_item.books[i];
}
customerItem::~customerItem()
{
}
void customerItem::createCustomerItem()
{
bool isok=false;
char ch;
while(!isok)
{
cout<<"\t\t\tcreate new customer information !"<<endl<<endl<<endl;
cout<<"\t\t\tenter the customer's name :";
getline(cin,name);
cout<<"\n\t\t\tenter the customer's ID :";
getline(cin,ID);
cout<<"\n\t\t\tenter the customer's unit :";
getline(cin,unit);
cout<<"\a\n\n\t\t\t customer information is ok "<<endl<<endl;
cout<<"\t\t S for Save or R for Reset :";
cin>>ch;
while(cin.get()!='\n')
;
if(ch=='s'||ch=='S')
isok=true;
}
}
customerItem &customerItem::operator=(const customerItem &_item)
{
if(this == &_item)
return *this;
else
{
name=_item.name;
ID=_item.ID;
unit=_item.unit;
password=_item.password;
numb=_item.numb;
for(int i=0;i<numb;i++)
books[i]=_item.books[i];
}
return *this;
}
void customerItem::setPassword(const string &_str)
{
password=_str;
}
string customerItem::getPassword()const
{
return password;
}
string customerItem::getID()const
{
return ID;
}
void customerItem::display()const
{
cout<<"********************************************************************************"<<endl<<endl;
cout<<"**\t\tthe customer's name :"<<name<<endl;
cout<<"**\t\tthe customer's ID :"<<ID<<endl;
cout<<"**\t\tthe customer's unit :"<<unit<<endl<<endl;
if(numb==0)
cout<<"\t\t\t you has borrowed 0 book !"<<endl;
else
{
cout<<"\t\t\t you has borrow "<<numb<<" books ."<<endl;
cout<<"\t\t\t\t AS follows :"<<endl;
for(int i=0;i<numb;i++)
books[i]->display();
}
}
void customerItem::borrow(bookItem &_item)
{
if(numb>=MAX)
{
cout<<"\a\a\a\t\t more than "<<MAX<<" books you have borrowed !\n";
cout<<"\t\t\t borrowing is canceled "<<endl<<endl;
}
else
{
_item.setCustID(ID);
books[numb]=&(_item.getPtr());
numb++;
cout<<"\t\t\t borrowing success !"<<endl<<endl;
}
}
void customerItem::revert(const string &_ISBN)
{
int index=0;
while(books[index]->getISBN()!=_ISBN && index<numb)
{
index++;
}
if(books[index]->getISBN()!=_ISBN)
cout<<"\t\t\t you didnot borrow this book !"<<endl<<endl;
else
{
int i;
string tem="";
books[index]->setCustID(tem);
for(i=index;i<numb-1;i++)
{
books[i]=books[i+1];
}
books[i]=NULL;
numb--;
cout<<"\t\t\t revert book success !"<<endl<<endl;
}
}
ofstream &operator<<(ofstream &fout, customerItem &_item)
{
fout<<_item.name<<'~'<<_item.ID<<'~'<<_item.unit<<'~'<<_item.password<<'~'<<_item.numb<<'~';
for(int i=0;i<_item.numb;i++)
{
fout<<_item[i]->getISBN()<<'~';
}
fout<<endl;
return fout;
}
ifstream& customerItem::readCitem(ifstream &fin, bookTree &_tree)
{
getline(fin,name,'~');
getline(fin,ID,'~');
getline(fin,unit,'~');
getline(fin,password,'~');
fin>>numb;
if(fin.peek()=='~')
fin.ignore(1);
for(int i=0;i<numb;i++)
{ string temp;
getline(fin,temp,'~');
books[i]=&(_tree.search(temp).getPtr());
}
while(fin.get()!='\n')
;
return fin;
}
bookItem *&customerItem::operator[](int index)
{
return books[index];
}
//************************************************************
// custoemr_node.h implemention file---customer_node.cpp
//************************************************************
#ifndef CUSTOMER_NODE_H_
#define CUSTOEMR_NODE_H_
#include"customer_item.h"
class customerNode
{
private:
customerItem item;
customerNode *leftchild;
customerNode *rightchild;
customerNode();
customerNode(const customerItem &_item,customerNode *leftPtr=NULL,
customerNode *rightPtr=NULL);
~customerNode();
friend class customerTree;
};
#endif
//*****************************************************************
// customer_node.cpp binary's customer node
//*****************************************************************
#include"customer_node.h"
customerNode::customerNode()
{
item=customerItem();
leftchild=rightchild=NULL;
}
customerNode::customerNode(const customerItem &_item,customerNode *leftPtr,
customerNode *rightPtr):item(_item),leftchild(leftPtr),rightchild(rightPtr)
{}
customerNode::~customerNode()
{}
//*****************************************************************
// book_node.h implemention file---book_node.cpp
//*****************************************************************
#ifndef BOOK_NODE_H_
#define BOOK_NODE_H_
#include"book_item.h"
class bookNode
{
private:
bookItem item;
bookNode *leftchild;
bookNode *rightchild;
explicit bookNode();
bookNode(const bookItem &_item,bookNode *leftPtr=NULL,
bookNode *rightPtr=NULL);
~bookNode();
friend class bookTree;
};
#endif
//****************************************************************
// book_node.cpp binary's book node
//****************************************************************
#include"book_node.h"
bookNode::bookNode()
{
item=bookItem();
leftchild=NULL;
rightchild=NULL;
}
bookNode::bookNode(const bookItem &_item,bookNode *leftPtr,bookNode *rightPtr):
item(_item),leftchild(leftPtr),rightchild(rightPtr)
{}
bookNode::~bookNode()
{}
//**********************************************************
// book_tree.h implemention file---book_tree.cpp
//**********************************************************
#ifndef BOOK_TREE_H_
#define BOOK_TREE_H_
#include<fstream>
#include<iostream>
#include<cstddef>
#include<string>
#include"book_node.h"
#include"book_exception.h"
using namespace std;
typedef void (*Function)(const bookItem &_item);
class bookTree
{
private:
bookNode *root;
int amount;
public:
bookTree();
bookTree(const bookItem &_item);
~bookTree();
bool isEmpty()const;
int getAmount()const{return amount;}
void insert(const bookItem &newitem)throw(bookException);
void remove(const string &_ISBN)throw(bookException);
void search(const string &_key,char & _type)const;
bookItem & search(const string &_ISBN)throw(bookException);
void traverse(Function visit);
void write(ofstream &fout);
void read(ifstream &fin,int n);
protected:
void insertItem(bookNode*& treePtr,const bookItem &newItem)throw(bookException);
void removeItem(bookNode *& treePtr,const string &_ISBN)throw(bookException);
void removeNode(bookNode*& treePtr);
void processLeft(bookNode*& treePtr,bookItem &_item);
void destory(bookNode * &_treePtr);
void retrieveInorde(bookNode *const & treePtr,const string &_key,char &_type)const;
bookItem & retrieveTree(bookNode * & treePtr,const string &_ISBN)throw(bookException);
void traverseItem(bookNode * & treePtr,Function visit);
void writeItem(bookNode * & treePtr,ofstream &fout);
void readItem(bookNode *& treePtr,ifstream &fin,int n);
};
#endif
//**************************************************************
// book_tree.cpp search binary tree storing book items
//**************************************************************
#include<cassert>
#include<cstdlib>
#include<cstddef>
#include"book_tree.h"
bookTree::bookTree()
{
root=NULL;
amount=0;
}
bookTree::bookTree(const bookItem &_item)
{
root=new bookNode(_item,NULL,NULL);
assert(root!=NULL);
amount=1;
}
bookTree::~bookTree()
{
destory(root);
}
bool bookTree::isEmpty()const
{
return (root==NULL);
}
void bookTree::insert(const bookItem &newitem)throw(bookException)
{
try{
insertItem(root,newitem);
}catch(bookException &bexvept)
{
throw;
}
}
void bookTree::remove(const string &_ISBN)throw(bookException)
{
try
{
removeItem(root,_ISBN);
}
catch(bookException &bexcept)
{
throw;
}
}
void bookTree::search(const string &_key,char & _type)const
{
retrieveInorde(root,_key,_type);
}
bookItem & bookTree::search(const string &_ISBN)throw(bookException)
{
try{
return(retrieveTree(root,_ISBN));
}
catch(bookException &cexcept)
{
throw;
}
}
void bookTree::traverse(Function visit)
{
traverseItem(root,visit);
}
void bookTree::write(ofstream &fout)
{
writeItem(root,fout);
}
void bookTree::read(ifstream &fin,int n)
{
readItem(root,fin,n);
}
void bookTree::insertItem(bookNode *&treePtr,const bookItem &newitem)
throw(bookException)
{
if(treePtr==NULL)
{
treePtr=new bookNode(newitem,NULL,NULL);
if(treePtr==NULL)
throw bookException("bookException :can't allocate memory in insert function !\a\a\a\a\a");
amount++;
}
else if((treePtr->item.getISBN())>newitem.getISBN())
insertItem(treePtr->leftchild,newitem);
else
insertItem(treePtr->rightchild,newitem);
}
void bookTree::removeItem(bookNode *& treePtr,const string &_ISBN)throw(bookException)
{
if(treePtr==NULL)
throw bookException("bookException :delete the key book failed in remove function !\a\a\a\a\a");
else if(treePtr->item.getISBN()>_ISBN)
removeItem(treePtr->leftchild,_ISBN);
else if(treePtr->item.getISBN()==_ISBN)
{
removeNode(treePtr);
amount--;
}
else
removeItem(treePtr->rightchild,_ISBN);
}
void bookTree::removeNode(bookNode *& treePtr)
{
bookNode *delPtr;
bookItem tempItem;
if(treePtr->leftchild==NULL&&treePtr->rightchild==NULL)
{
delete treePtr;
treePtr=NULL;
}
else if(treePtr->leftchild==NULL)
{
delPtr=treePtr;
treePtr=treePtr->rightchild;
delPtr->rightchild=NULL;
delete delPtr;
}
else if(treePtr->rightchild==NULL)
{
delPtr=treePtr;
treePtr=treePtr->leftchild;
delPtr->leftchild=NULL;
delete delPtr;
}
else
{
processLeft(treePtr->rightchild,tempItem);
treePtr->item=tempItem;
}
}
void bookTree::processLeft(bookNode *&treePtr,bookItem &_item)
{
if(treePtr->leftchild==NULL)
{
_item=treePtr->item;
bookNode *tempPtr=treePtr;
treePtr=treePtr->rightchild;
tempPtr->rightchild=NULL;
delete tempPtr;
}
else
processLeft(treePtr->leftchild,_item);
}
void bookTree::destory(bookNode *&_treePtr)
{
if(_treePtr!=NULL)
{
destory(_treePtr->leftchild);
destory(_treePtr->rightchild);
delete _treePtr;
_treePtr=NULL;
amount--;
}
}
void bookTree::retrieveInorde(bookNode *const & treePtr,const string &_key,char & _type)const
{
if(treePtr!=NULL)
{
if(_type=='T'||_type=='t')
{
retrieveInorde(treePtr->leftchild,_key,_type);
if(treePtr->item.getTitle()==_key)
{
treePtr->item.display();
}
retrieveInorde(treePtr->rightchild,_key,_type);
}
else if(_type=='A'||_type=='a')
{
retrieveInorde(treePtr->leftchild,_key,_type);
if(treePtr->item.getAuthor()==_key)
{
treePtr->item.display();
}
retrieveInorde(treePtr->rightchild,_key,_type);
}
else if(_type=='I'||_type=='i')
{
retrieveInorde(treePtr->leftchild,_key,_type);
if(treePtr->item.getISBN()==_key)
{
treePtr->item.display();
}
retrieveInorde(treePtr->rightchild,_key,_type);
}
else if(_type=='P'||_type=='p')
{
retrieveInorde(treePtr->leftchild,_key,_type);
if(treePtr->item.getPublisher()==_key)
{
treePtr->item.display();
}
retrieveInorde(treePtr->rightchild,_key,_type);
}
else if(_type=='C'||_type=='c')
{
retrieveInorde(treePtr->leftchild,_key,_type);
if(treePtr->item.getCategory()==_key)
{
treePtr->item.display();
}
retrieveInorde(treePtr->rightchild,_key,_type);
}
}
}
bookItem &bookTree::retrieveTree(bookNode *&treePtr,const string &_ISBN)
throw(bookException)
{
if(treePtr==NULL)
throw bookException("bookException :seek the key book failed in search function !\a\a\a\a\a");
else if(treePtr->item.getISBN()==_ISBN)
return treePtr->item;
else if(treePtr->item.getISBN()>_ISBN)
retrieveTree(treePtr->leftchild,_ISBN);
else
retrieveTree(treePtr->rightchild,_ISBN);
}
void bookTree::traverseItem(bookNode *&treePtr,Function visit)
{
if(treePtr!=NULL)
{
traverseItem(treePtr->leftchild,visit);
visit(treePtr->item);
traverseItem(treePtr->rightchild,visit);
}
}
void bookTree::writeItem(bookNode *&treePtr,ofstream &fout)
{
if(treePtr!=NULL)
{
writeItem(treePtr->leftchild,fout);
fout<<treePtr->item;
writeItem(treePtr->rightchild,fout);
}
}
void bookTree::readItem(bookNode *&treePtr ,ifstream &fin,int n)
{
if(n>0)
{
treePtr=new bookNode();
readItem(treePtr->leftchild,fin,n/2);
fin>>treePtr->item;
amount++;
readItem(treePtr->rightchild,fin,(n-1)/2);
}
}
//****************************************************************
// customer_tree.h implemention file---customer_tree.cpp
//*******************************************************************
#ifndef CUSTOMER_TREE_H_
#define CUSTOMER_TREE_H_
#include<string>
#include<fstream>
#include<iostream>
#include<cstddef>
#include"customer_node.h"
#include"customer_exception.h"
using namespace std;
typedef void (*FunctionType)(const customerItem &_item);
class customerTree
{
private:
customerNode *root;
int amount;
public:
customerTree();
customerTree(const customerItem &_item);
~customerTree();
int getAmount()const{return amount;}
bool isEmpty()const;
void insert(const customerItem &newitem)throw(customerException);
void remove(const string &_ID)throw(customerException);
customerItem & search(const string &_ID)throw(customerException);
void traverse(FunctionType visit);
void write(ofstream &fout);
void read(ifstream &fin,int n, bookTree &_tree);
protected:
void insertItem(customerNode *&treePtr,const customerItem &newitem)throw(customerException);
void removeItem(customerNode *&treePtr,const string &_ID)throw(customerException);
void removeNode(customerNode *&treePtr);
void processLeft(customerNode *&treePtr,customerItem &_item);
void destory(customerNode *&treePtr);
customerItem & retrieveTree(customerNode *&treePtr,const string &_ID)throw(customerException);
void traverseItem(customerNode *&treePtr,FunctionType visit);
void writeItem(customerNode *&treePtr,ofstream &fout);
void readItem(customerNode *&treePtr,ifstream &fin,int n,bookTree &_tree);
};
#endif
//************************************************************************
// customer_tree.cpp search binary tree storing customer items
//************************************************************************
#include<cassert>
#include<cstddef>
#include"customer_tree.h"
#include"book_tree.h"
customerTree::customerTree()
{
root=NULL;
amount=0;
}
customerTree::customerTree(const customerItem &_item)
{
root=new customerNode(_item,NULL,NULL);
assert(root!=NULL);
amount=1;
}
customerTree::~customerTree()
{
destory(root);
}
bool customerTree::isEmpty()const
{
return (root==NULL);
}
void customerTree::insert(const customerItem &newitem)throw(customerException)
{
try
{
insertItem(root,newitem);
}
catch(customerException &cExcept)
{
throw;
}
}
void customerTree::remove(const string &_ID)throw(customerException)
{
try
{
removeItem(root,_ID);
}
catch(customerException &cexcept)
{
throw;
}
}
customerItem &customerTree::search(const string &_ID)throw(customerException)
{
try{
return retrieveTree(root,_ID);
}
catch(customerException &cexcept)
{
throw;
}
}
void customerTree::traverse(FunctionType visit)
{
traverseItem(root,visit);
}
void customerTree::read(ifstream &fin,int n,bookTree &_tree)
{
readItem(root,fin,n,_tree);
}
void customerTree::write(ofstream &fout)
{
writeItem(root,fout);
}
void customerTree::writeItem(customerNode *&treePtr,ofstream &fout)
{
if(treePtr!=NULL)
{
writeItem(treePtr->leftchild,fout);
fout<<treePtr->item;
writeItem(treePtr->rightchild,fout);
}
}
void customerTree::readItem(customerNode *& treePtr,ifstream &fin,int n,bookTree &_tree)
{
if(n>0)
{
treePtr=new customerNode();
readItem(treePtr->leftchild,fin,n/2,_tree);
treePtr->item.readCitem(fin,_tree);
amount++;
readItem(treePtr->rightchild,fin,(n-1)/2,_tree);
}
}
void customerTree::insertItem(customerNode *&treePtr,const customerItem &newitem)throw(customerException)
{
if(treePtr==NULL)
{
treePtr= new customerNode(newitem,NULL,NULL);
if(treePtr==NULL)
throw customerException("customerException :allocate memory failed in insert function !\a\a\a\a\a");
amount++;
}
else if(treePtr->item.getID()>newitem.getID())
insertItem(treePtr->leftchild,newitem);
else
insertItem(treePtr->rightchild,newitem);
}
void customerTree::removeItem(customerNode *&treePtr,const string &_ID)throw(customerException)
{
if(treePtr==NULL)
throw customerException("customerException :delete failed in remove function !\a\a\a\a\a");
else if(treePtr->item.getID()>_ID)
removeItem(treePtr->leftchild,_ID);
else if(treePtr->item.getID()==_ID)
{
removeNode(treePtr);
amount--;
}
else
removeItem(treePtr->rightchild,_ID);
}
void customerTree::removeNode(customerNode *&treePtr)
{
customerNode *delPtr;
customerItem tempItem;
if(treePtr->leftchild==NULL &&treePtr->rightchild==NULL)
{
delete treePtr;
treePtr=NULL;
}
else if(treePtr->leftchild==NULL)
{
delPtr=treePtr;
treePtr=treePtr->rightchild;
delPtr->rightchild=NULL;
delete delPtr;
}
else if(treePtr->rightchild==NULL)
{
delPtr=treePtr;
treePtr=treePtr->leftchild;
delPtr->leftchild=NULL;
delete delPtr;
}
else
{
processLeft(treePtr->rightchild,tempItem);
treePtr->item=tempItem;
}
}
void customerTree::processLeft(customerNode *&treePtr,customerItem &_item)
{
if(treePtr->leftchild==NULL)
{
_item=treePtr->item;
customerNode *delPtr=treePtr;
treePtr=treePtr->rightchild;
delPtr->rightchild=NULL;
delete delPtr;
}
else
processLeft(treePtr->leftchild,_item);
}
void customerTree::destory(customerNode *&treePtr)
{
if(treePtr!=NULL)
{
destory(treePtr->leftchild);
destory(treePtr->rightchild);
delete treePtr;
treePtr=NULL;
}
}
customerItem &customerTree::retrieveTree(customerNode *&treePtr,const string &_ID)
throw(customerException)
{
if(treePtr==NULL)
throw customerException("customerException :seek the key customer failed in search function !\a\a\a\a\a");
else if(treePtr->item.getID()>_ID)
retrieveTree(treePtr->leftchild,_ID);
else if(treePtr->item.getID()==_ID)
return treePtr->item;
else
retrieveTree(treePtr->rightchild,_ID);
}
void customerTree::traverseItem(customerNode *&treePtr,FunctionType visit)
{
if(treePtr!=NULL)
{
traverseItem(treePtr->leftchild,visit);
visit(treePtr->item);
traverseItem(treePtr->rightchild,visit);
}
}