二叉搜索树

#include <iostream>
using namespace std;

template <typename T>
class BSTree;

template <typename type>
class BSTNode
{
	friend class BSTree<type>;

public:
	BSTNode() : data(type()), leftChild(NULL), rightChild(NULL) {}
	BSTNode(type d, BSTNode *left = NULL, BSTNode *right = NULL)
		: data(d), leftChild(left), rightChild(right) {}
	~BSTNode() {}

private:
	BSTNode *leftChild;
	BSTNode *rightChild;
	type data;
};

template <typename T>
class BSTree
{
public:
	BSTree() : root(NULL) { }
	BSTree(T *ar, int n) : root(NULL)
	{
		for (int i = 0; i < n; ++i)
			insert(ar[i]);
	}

public:
	bool insert(const T &x) { return insert(root, x); }

	T& max() { return max(root); }
	const T& max() const { return max(root); }
	T& min() { return min(root); }
	const T& min() const { return min(root); }

	BSTNode<T>* search(const T &key) const { return search(root, key); }
	BSTNode<T >* parent(const T &key) const { return parent(root, key); }

	bool remove(const T &key) { return remove(root, key); }
	void makeEmpty() { return makeEmpty(root); }

	bool equal(const BSTree<T> &bst) const { return equal(root, bst.root); }
	void copy(const BSTree<T> &bst) { root =  copy(bst.root); }

	void sortPrint() const { return sortPrint(root); }

protected:
	BSTNode<T>* copy(BSTNode<T> *root)
	{
		if (root == NULL)
			return NULL;

		BSTNode<T> *p = new BSTNode<T>(root->data);
		p->leftChild = copy(root->leftChild);
		p->rightChild = copy(root->rightChild);

		return p;
	}

	bool equal(const BSTNode<T> *root1, const BSTNode<T> *root2) const
	{
		if (NULL == root1 && NULL == root2)
			return true;

		if (root1 != NULL && root2 != NULL && root->data == root->data
				&& equal(root1->leftChild, root2->leftChild)
				&& equal(root1->rightChild, root2->rightChild))
			return true;

		return false;
	}

	bool remove(BSTNode<T> *&root, const T &key)
	{
		if (NULL == root)
			return false;

		if (root->data > key)
			remove(root->leftChild, key);
		else if (root->data < key)
			remove(root->rightChild, key);
		else
		{
			if (root->leftChild == NULL && root->rightChild == NULL)
			{
				delete root;
				root = NULL;
			}
			else if (root->leftChild != NULL && root->rightChild == NULL)
			{
				BSTNode<T> *p = root;
				root = p->leftChild;
				delete p;
				p = NULL;
			}
			else if (root->leftChild == NULL && root->rightChild != NULL)
			{
				BSTNode<T> *p = root;
				root = p->rightChild;
				delete p;
				p = NULL;
			}
			else	//左右子树都存在，该节点右子树中最小的一个节点值替换当前节点值，并删除该最小节点
			{
				BSTNode<T> *p = root->rightChild;
				while (p->leftChild != NULL)
					p = p->leftChild;

				root->data = p->data;
				remove(root->rightChild, p->data);
			}
		}
	}

	void makeEmpty(BSTNode < T> *&root)
	{
		if (NULL != root)
		{
			makeEmpty(root->leftChild);
			makeEmpty(root->rightChild);
			delete root;
			root = NULL;
		}
	}

	bool insert(BSTNode<T>* &t, const T &x)
	{
		if (NULL == t)
		{
			t = new BSTNode<T>(x);
			return true;
		}
		else if (t->data > x)
			return insert(t->leftChild, x);
		else if (t->data < x)
			return insert(t->rightChild, x);
		else					//该数据值已存在
			return false;	 
	}

	T& max(BSTNode<T> *root)
	{
		BSTNode<T> *p = root;
		while (p->rightChild != NULL)
			p = p->rightChild; 

		return p->data;
	}

	const T& max(BSTNode<T> *root) const
	{
		BSTNode<T> *p = root;
		while (p->rightChild != NULL)
			p = p->rightChild;

		return p->data;
	}

	T& min(BSTNode<T> *root)
	{
		BSTNode<T> *p = root;
		while (p->leftChild != NULL)
			p = p->leftChild;

		return p->data;
	}

	const T& min(BSTNode<T> *root) const
	{
		BSTNode<T> *p = root;
		while (p->leftChild != NULL)
			p = p->leftChild;

		return p->data;
	}

	BSTNode<T>* search(BSTNode<T> * root, const T &key) const
	{
		if (NULL == root)
			return NULL;
		else if (key == root->data)
			return root;
		else if (root->data > key)
			return search(root->leftChild, key);
		else
			return search(root->rightChild, key);
	}
	
	BSTNode<T >* parent(BSTNode<T> *root, const T &key) const
	{
		BSTNode<T> *p = search(key);
		if (p == NULL)
			return NULL;

		if (root->leftChild == p || root->rightChild == p)
			return root;
		else if (root->data > p->data)
			return parent(root->rightChild, key);
		else if (root->data < p->data)
			return parent(root->leftChild, key);

		return NULL;
	}

    //BST中序遍历
	void sortPrint(BSTNode<T> *root) const
	{
		if (root != NULL)
		{
			sortPrint(root->leftChild);
			cout << root->data << " ";
			sortPrint(root->rightChild);
		}
	}

private:
	BSTNode<T>	*root;
};