比较全的二叉查找树(BinarySearchTree)的实现

新年到！中大黑熊祝大家新年快乐！在这里，po上二叉查找树的比较全的实现，我自己整理的，没有测试过，希望有错的能和我说一声，赐教赐教一下我哈！

#ifndef BinaryTree_H
#define BinaryTree_H

template<typename T>
struct BinaryNode
{
	T element;
	BinaryNode * left;
	BinaryNode * right;
	BinaryNode(const T & theElement,BinaryNode *lt = NULL,BinaryNode *rt = NULL):element(theElement),left(lt),right(rt) {}
};
template<typename T>
class BinarySearchTree
{
public:
	BinarySearchTree();
	BinarySearchTree(const BinarySearchTree & rhs);
	~BinarySearchTree();

	const T & findMin() const;
	const T & findMax() const;
	bool contains(const T & x) const;
	bool isEmpty() const;
	void printTree() const;

	void makeEmpty();
	void insert(const T & x);
	void remove(const T & x);

	const BinarySearchTree & operator=(const BinarySearchTree & rhs);

	int countNodes() const;
	int countLeaves() const;
	int countFull() const;

	bool check() const;
	
	//在树上查找k1<=Keys(X)<=k2的值
	void printRange(T & lower,T & upper,BinaryNode<T>* &root); 

private:


	BinaryNode * root;

	void insert(const T & x,BinaryNode * &t) const
	{
		if(t == NULL)
			t = new BinaryNode(x);
		else if(x < t->element)
			insert(x,t->left);
		else if(x > t->element)
			insert(x,t->right);
		else
			;
	}
	void remove(const T & 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)  //Two children
		{
			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;
		else
		{
			while(t->left != NULL)
				t = t->left;
			return t;
		}
	}
	BinaryNode * findMax(BinaryNode * t) const
	{
		if(t == NULL)
			return NULL;
		else
		{
			while(t->right != NULL)
				t = t->right;
			return t;
		}
	}
	bool contains(const T & x,BinaryNode *t) const
	{
		if(t == NULL)
			return false;
		else if(x < t->element)
			return contains(x,t->left);
		else if(c > t->element)
			return contains(x,t->right);
		else
			return true;
	}
	void makeEmpty(BinaryNode *t) const
	{
		if(t == NULL)
			;
		else
		{
			makeEmpty(t->left);
			makeEmpty(t->right);
			delete t;
		    t = NULL;
		}
	}
	BinaryNode * clone(BinaryNode * t) const
	{
		if(t == NULL)
			return NULL;
		else
			return new BinaryNode(t->element,clone(t->left),clone(t->right));
	}
	void printTree(BinaryNode * &t) const
	{//这里采用中缀遍历
		cout << t->element << endl;
		printTree(t->left);
		printTree(t->right);
	}

	//统计t中结点的个数
	int countNodes(BinaryNode * &t) const
	{
		if(t==NULL)
			return 0;
		else
			return countNodes(t->left)+countNodes(t->right)+1;
	}
	
	//统计t中树叶的片数
	int countLeaves(BinaryNode * &t) const
	{
		if(t == NULL)
			return 0;
		else if(t->left == NULL && t->right == NULL)
			return 1;
		else
			return countLeaves(t->left)+countLeaves(t->right);
	}

	//统计t中满结点的个数
	int countFull(BinaryNode * &t) const
	{
		if(t == NULL)
			return 0;
		int tIsFull = (t->left != NULL && t->right != NULL) ? 1:0;
		return tIsFull + countFull(t->left) + countFull(t->right);
	}

	//测试一棵二叉树是否在每一个结点都满足查找树的序的性质
	bool check(BinaryNode * &t) const
	{
		if(t->left == NULL && t->right == NULL)
			return true;
		else if(!(t->element > findMin(t)->element && t->element < findMax(t)->element))
			return false;
		check(t->left);
		check(t->right);
	}
};


#endif

 

#include "BinaryTree.h"
#include <iostream>
using namespace std;

template<typename T>
BinarySearchTree<T>::BinarySearchTree()
{
	root = NULL;
}

template<typename T>
BinarySearchTree<T>::BinarySearchTree(const BinarySearchTree & rhs)
{
	root = NULL;
	*this = rhs;
}

template<typename T>
BinarySearchTree<T>::~BinarySearchTree()
{
	makeEmpty();
}

template<typename T>
const T & BinarySearchTree<T>::findMin() const
{
	if(!isEmpty())
		return findMin(root)->element;
}

template<typename T>
const T & BinarySearchTree<T>::findMax() const
{
	if(!isEmpty())
		return findMax(root)->element;
}

template<typename T>
bool BinarySearchTree<T>::contains(const T & x) const
{
	return contains(x,root);
}

template<typename T>
bool BinarySearchTree<T>::isEmpty() const
{
	return root == NULL;
}

template<typename T>
void BinarySearchTree<T>::printTree() const
{
	if(isEmpty())
		cout << "Empty tree." << endl;
	else
		printTree(root);
}

template<typename T>
void BinarySearchTree<T>::makeEmpty()
{
	makeEmpty(root);
}

template<typename T>
void BinarySearchTree<T>::insert(const T & x)
{
	insert(x,root);
}

template<typename T>
void BinarySearchTree<T>::remove(const T & x)
{
	remove(x,root);
}


/* Deep Copy*/

template<typename T>
const BinarySearchTree<T> &BinarySearchTree<T>::operator=(const BinarySearchTree<T> & rhs)
{
	if( this != &rhs )
	{
		makeEmpty();
		root = clone(rhs.root);
	}
	return *this;
}


template<typename T>
int BinarySearchTree<T>::countNodes() const
{
	return countNodes(root);
}

template<typename T>
int BinarySearchTree<T>::countLeaves() const
{
	return countLeaves(root);
}

template<typename T>
int BinarySearchTree<T>::countFull() const
{
	return countFull(root);
}

template<typename T>
bool BinarySearchTree<T>::check() const
{
	return check(root);
}

template<typename T>
void BinarySearchTree<T>::printRange(T & lower,T & upper,BinaryNode<T>* &root)
{
	if(root != NULL)
	{
		if(lower <= t->element)
			printRange(lower,upper,root->left);
		if(lower <= t->element && t->element >= upper)
			cout << t->element << endl;
		if(t->element <= upper)
			printRange(lower,upper,root->right);
	}
}