library management system simulation(first)

最新推荐文章于 2023-08-11 02:11:35 发布
最新推荐文章于 2023-08-11 02:11:35 发布
阅读量536 收藏
点赞数
CC 4.0 BY-SA版权
文章标签： library system string null books tree
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/chenloug/article/details/6853653 
//**************************************************************
//                     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);
	}
}


 







                

        

    

    
  



    

      

        

            

              
                
                  chenloug
                
              
            

            

                关注
              
            

        

        

          
      

      










                



	

		

			

				
					
t7_Building a Trading System in Python_unittest_deque

				
			

			

				

					Linli522362242的专栏
				

				

					01-19
					
					1259
					
				

			

		

		

			
				
We have learned how to create a trading strategy by analyzing historical data. In this chapter, we are going to study how to convert data analysis into real-time software that will connect to a real exchange to actually apply the theory that you've pr...

			
		

	



                

            
              



	

		

			

				
					
【C#、C++ 和 Java】实现忍者跑酷（Ninja Runner / Parkour）游戏

				
			

			

				

					走向CTO的路上...
				

				

					05-27
					
					1283
					
				

			

		

		

			
				
忍者跑酷是一款复杂度较高的实时二维平台跑酷游戏。实现它能锻炼对实时物理模拟、复杂碰撞检测与响应、玩家状态机和资源管理的掌握。核心挑战在于构建一个稳定可靠的物理和碰撞系统，实现玩家多样的跑酷技能，并将其与连续滚动的关卡有效结合。虽然从头实现一个完整的跑酷游戏是巨大的工程，但理解其基本原理（玩家状态、基本物理、AABB 碰撞、输入处理）是入门的关键。对于此类复杂游戏 Games，强烈推荐使用游戏引擎或功能强大的游戏开发框架来简化开发流程，它们提供了大量现成的工具和系统。

			
		

	



              


  
              

                


	

		

			

				
					
library的英语怎么读音_library.是什么意思

				
			

			

				

					weixin_39517199的博客
				

				

					12-24
					
					1054
					
				

			

		

		

			
				
1. We welcome everyone to Kitchener Public Library.我们欢迎大家来基奇纳公共图书馆。2. Mrs. bennet rang the bell, and miss elizabeth was summoned to the library.班纳特太太拉下了铃，伊丽莎白小姐给叫到书房里来了。3. Only the most significant on...

			
		

	





	

		

			

				
					
Exploring EDA Algorithms with the Boost Graph Library

				
			

			

				

					wsh6759的CGIS专栏
				

				

					04-18
					
					1301
					
				

			

		

		

			
				
Exploring EDA Algorithms with the Boost Graph Library
Electronic Design Automation (EDA) algorithms are typically graph-based. For example, a logic circuit can be modeled as a graph of vertices, each

			
		

	



		

			
		



	

		

			

				
					
Cross Platform library in C++ for Windows, WM, WinCE, MacOS, iPhone

				
			

			

				

					logcabin的专栏
				

				

					09-07
					
					7874
					
				

			

		

		

			
				
Cross Platform library in C++ for Windows, WM, WinCE, MacOS, iPhone


from:   http://www.24hsoftware.com/DevelopersForum/CrossPlatform-C-Library.html

Is there a portable (Cross Platform) library

			
		

	





	

		

			

				
					
The Research And Development of Intelligent Parking System Based On QT

				
			

			

				

					codylele的博客
				

				

					07-27
					
					796
					
				

			

		

		

			
				
This is an intelligent parking simulation system based on QT, which involves the design and implementation of the parking lot interface. Each car can enter or leave the parking lot, and the information of each car will be displayed.

			
		

	





	

		

			

				
					
第四题

				
			

			

				

					bigheart的博客
				

				

					03-04
					
					832
					
				

			

		

		

			
				
Part 4: Hawkweed Eradication
Contents:

Classes and Methods
Inheritance and Polymorphism
Exceptions
The Structure of Projects and Command Line Arguments
Exercise 4: Hawkweed Eradication — 50 Marks
Useful Things

Classes and Methods
As we have seen, everyth

			
		

	





	

		

			

				
					
qemu-system-x86_64（1）-Linux手册页

					
热门推荐

				
			

			

				

					攻城狮
				

				

					10-08
					
					1万+
					
				

			

		

		

			
				
qemu-system-x86_64名称概要描述选项printf ``letmein'' > mypasswd.txt # qemu-system-x86_64 -object secret,id=sec0,file=mypasswd.txt,format=raw

qemu-system-x86_64：QEMU版本4.2.0用户文档

qemu-system-x86_64在Linux中 显示手册的命令：
$ man 1 qemu-system-x86_64

名称
qemu-doc-QEMU版本4.

			
		

	





	

		

			

				
					
Open Source GIS

				
			

			

				

					cnhome的专栏
				

				

					04-24
					
					4648
					
				

			

		

		

			
				
转自:http://opensourcegis.org/
 
[Last update: 12/12/08 - 247 projects listed.
Kalypso-Simulation-Platform, KIDS, Rgeo, GEOS, p.mapper, NetTopologySuite, GeoVista Studio, Kosmo, SharpShape, BASINS, N

			
		

	





	

		

			

				
					
portability of c programs and the unix system

				
			

			

				

					weixin_33781606的博客
				

				

					03-21
					
					1042
					
				

			

		

		

			
				
2019独角兽企业重金招聘Python工程师标准>>>   
                                        
         ...

			
		

	





	

		

			

				
					
Extended Monte Carlo Simulation: Integration with Other Tools in MATLAB

				
			

			

				

					
				

			

		

		

			
				
# Extended Monte Carlo Simulation: Integration with Other Tools in MATLAB  ## 1. Basics of Monte Carlo Simulation  Monte Carlo simulation is a numerical technique based on random sampling to solve ...

			
		

	





	

		

			

				
					
项目管理: Agile实践方法与工具介绍

				
			

			

				

					AI天才研究院
				

				

					08-11
					
					470
					
				

			

		

		

			
				
作者：禅与计算机程序设计艺术Project management (PM) refers to the process of planning and organizing projects that involve diverse stakeholders with varied roles and responsibilities. In this article, we will explore several agile methodologies and tools in project mana

			
		

	





	

		

			

				
					
MATLAB Supply Chain Management Optimization: Strategies for Enhancing Efficiency and Case Studies

				
			

			

				

					
				

			

		

		

			
				
 Overview of MATLAB Applications in Supply Chain Management  Supply chain management (SCM) is a critical component of business operations, involving all aspects from the procurement of raw materials, ...

			
		

	





	

		

			

				
					
基于Java医院药品管理系统论文

					
最新发布

				
			

			

				

					08-12
				

			

		

		

			
				
基于Java医院药品管理系统论文

			
		

	





	

		

			

				
					
Kafka消息队列架构及高可用配置实战.doc

				
			

			

				

					08-12
				

			

		

		

			
				
Kafka消息队列架构及高可用配置实战.doc

			
		

	





	

		

			

				
					
springboot基于Java的宠物用品系统的设计与实现.doc

				
			

			

				

					08-12
				

			

		

		

			
				
springboot基于Java的宠物用品系统的设计与实现

			
		

	





	

		

			

				
					
接口逻辑电平标准.pptx

				
			

			

				

					08-12
				

			

		

		

			
				
电路设计+接口逻辑电路+各种接口电平+学习和交流

			
		

	





	

		

			

				
					
JAVA某店POS积分管理系统(源代码+论文)

				
			

			

				

					08-12
				

			

		

		

			
				
java

			
		

	





	

		

			

				
					
Infrared Simulation Library

				
			

			

				

					05-14
				

			

		

		

			
				
Infrared Simulation Library (ISL) is a software library that provides developers with a set of tools to simulate infrared sensors and imaging systems. The library includes models for various types of ...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

  
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值