二叉查找树

对于大量的输入数据，链表的线性访问时间太慢，不宜使用。取而代之，采用二叉查找树，其平均访问时间为O（logN）

.h

struct Node
{
	int data;
	Node *left;
	Node *right;
};

class BinaryTree
{
	public:
		BinaryTree();
		~BinaryTree();
		
		void  Insert(int data);
		void  Delete(int data);
		Node *Find(int data);
		Node *FindMin();
		Node *FindMax();
		void  MidPrint();   
		
	private:
		Node *_Insert(Node* root, int data);
		Node *_Delete(Node* root, int data);
		Node *_Find(Node* root, int data);
		Node *_FindMin(Node* root);
		Node *_FindMax(Node* root);
		void  _MakeEmpty(Node *root);
		void  _MidPrint(Node *root);
		
		Node *_root;
};

.cpp

BinaryTree::BinaryTree()
{
	_root = NULL;
}
BinaryTree::~BinaryTree()
{
	_MakeEmpty(_root);	
}
void  BinaryTree::Insert(int data)
{
	_root = _Insert(_root, data);
}
void  BinaryTree::Delete(int data)
{
	_root = _Delete(_root, data);
}
Node* BinaryTree::Find(int data)
{
	return _Find(_root, data); 
}
Node* BinaryTree::FindMin()
{
	return _FindMin(_root);
}
Node* BinaryTree::FindMax()
{
	return _FindMax(_root);
}
Node* BinaryTree::_Find(Node* root, int data)
{
	if(root == NULL)
		return NULL;
	
	if(data > root->data)
	{
		return _Find(root->right, data);
	}
	else if(data < root->data)
	{
		return _Find(root->left, data);
	}
	return root;
}
Node* BinaryTree::_FindMin(Node* root)
{
	if(root == NULL)
		return NULL;
	
	if(root->left == NULL)
		return root;
	else
		return _FindMin(root->left);
}
Node* BinaryTree::_FindMax(Node* root)
{
	if(root == NULL)
		return NULL;
	
	if(root->right == NULL)
		return root;
	else
		return _FindMax(root->right);
}
void  BinaryTree::_MakeEmpty(Node *root)
{
	if(root != NULL)
	{
		_MakeEmpty(root->left);
		_MakeEmpty(root->right);
		delete root;
	}
}
Node* BinaryTree::_Insert(Node* root, int data)
{
	if(root == NULL)
	{
		root = new Node;
		root->data = data;
		root->left = root->right = NULL;
	}
	else if( data > root->data)
	{
		root->right = _Insert(root->right, data);
	}
	else if( data < root->data)
	{
		root->left  = _Insert(root->left, data);
	}
	return root;
}

Node* BinaryTree::_Delete(Node* root, int data)
{
	if(root == NULL)
		return NULL;
		
	if(data > root->data)
	{
		root->right = _Delete(root->right, data);
	}
	else if(data < root->data)
	{
		root->left  = _Delete(root->left, data);
	}
	else
	{
		if(root->left != NULL && root->right != NULL)
		{
			Node *tmp  = _FindMin(root->right);
			root->data = tmp->data;
			root->right = _Delete(root->right, tmp->data); 
		}
		else
		{
			Node *tmp = root;
			if(root->left == NULL)
				root = root->right;
			else
				root = root->left;
			delete tmp;
		}
	}
	return root;
}

void BinaryTree::MidPrint()
{
	_MidPrint(_root);
	cout << endl;
}		

void BinaryTree::_MidPrint(Node *root)
{
	if(root != NULL)
	{
		_MidPrint(root->left);
		cout << root->data << " ";
		_MidPrint(root->right);
	}	
}