二叉查找树基本操作实现

主要实现了二叉查找树的插入、删除等操作

树节点头文件tree_node.h

template<class T>
struct tree_node {
	tree_node() {
		left = NULL;
		right = NULL;
	}
	tree_node(T ndata) {
		data = ndata;
		left = NULL;
		right = NULL;
	}
	T data;
	tree_node<T> *left;
	tree_node<T> *right;
	
};

二叉查找树类文件

#include <iostream>
#include "tree_node.h" 
#include <cassert>

using namespace std;

template<class T>
class binary_search_tree {
public:
	binary_search_tree() {
		used = 0;
		root = NULL;
	}
	~binary_search_tree() {
		clear();
	}
	int size() { return used; }
	void clear() { 
		clearT(root);
		used = 0;
	}
	void in_print() { in_printT(root); }
	tree_node<T>* copy() { copyT(root); }
	void insert(const T& entry) { 
		insertT(root, entry);
		used++;
	 }
	bool erase(const T &target) {
		bool flag = deleteT(root, target);
		if(flag) used--;
		return flag;
	}
private:
	tree_node<T> *root;
	int used;
	//由底向上删除 
	void clearT(tree_node<T>*& proot) {		
		if(proot != NULL) {
			clearT(proot->left);
			clearT(proot->right); 
			delete proot;
			proot = NULL;	
		}	
	}
	//中序遍历 
	void in_printT(tree_node<T>* proot) {
		if(proot != NULL) {
			in_printT(proot->left);
			cout << proot->data << endl;
			in_printT(proot->right);
		} 	
	} 
	//由底向上拷贝 
	tree_node<T>* copyT(const tree_node<T> *proot) {
		if(proot == NULL)
			return NULL;
		else {
			tree_node<T> *lchild, *rchild;
			lchild = copyT(proot->left);
			rchild = copyT(proot->right);
			return new tree_node<T>(proot->data, lchild, rchild);	
		}
	} 
	//插入一个新项 
	void insertT(tree_node<T> *&proot, const T &entry) {
		tree_node<T> *p = new tree_node<T>(entry);
		if(proot == NULL) proot = p ;
		else {
			if(entry <= proot->data && proot->left == NULL) {
				proot->left = p;
				return;
			}
			if(entry > proot->data && proot->right == NULL) {
				proot->right = p;
				return;				
			}
			if(entry <= proot->data && proot->left !=NULL)
				insertT(proot->left, entry);
			if(entry > proot->data && proot->right != NULL)
				insertT(proot->right, entry);
		}
	}
	// 删除树中的最大项节点，将要删除的节点值设置为最大项的值 
	void remove_max(tree_node<T>*& rt, T &removed) {
		tree_node<T> *old;
		//右子树为空 
		if(rt->right == NULL) {
			removed = rt->data;
			old = rt;
			rt =  rt->left;
			delete old;			
		}
		//右子树非空 
		else
			remove_max(rt->right, removed);
	}
	//删除树中特定值 
	bool deleteT(tree_node<T> *&proot, const T &target) {
		if(proot == NULL) 
			return false;
		else {
			if(target < proot->data)
				deleteT(proot->left, target);
			else if(target > proot->data)
				deleteT(proot->right, target);
			//删除节点时分两种情况，有左孩子和无左孩子 
			else {
				tree_node<T> *old; 
				if(proot->left == NULL)	{ 			//无左孩子，右孩子成为父节点，包括了叶子节点情况 
					old = proot;
					proot = proot->right;
					delete old;
				}
				//有左孩子，则需要删除左子树中最大的值 
				else 
					remove_max(proot->left, proot->data);
				return true;
			}		
		}
	}
};