二叉排序树

// 二叉排序树
#include <stdio.h>
#include <iostream>

using namespace std;

template<typename T>
struct Node
{
	T m_value;
	Node *m_p1;
	Node *m_p2;
};

template<typename T>
class BST
{

public:
	BST()
	{
		m_size=0;
		m_head=NULL;
	}
	size_t size(){return m_size;}
	bool isEmpty(){ return m_size==0; }

	void Insert(T &t_value )
	{
		xInsert(m_head, t_value);

	}

	void Print(int n=0)
	{
		if (n==0)
		{
			xPrint0(m_head);
		}else if (n==1)
		{
			xPrint1(m_head);
		}
		else
		{
			xPrint_1(m_head);
		}

	}
	Node<int> * Search(T &t_value)
	{
		return xSearch(m_head, t_value);
	}
	~BST()
	{
		xDestroy(m_head);
		m_size=0;
	}

	bool Remove(T t_value)
	{

		//1.search
		Node<T> *p=m_head;
		Node<T> *q=NULL;
		while(p!=NULL)
		{
			if (p->m_value == t_value)
			{
				break;
			}
			q=p;
			if (t_value < p->m_value)
			{
				p=p->m_p1;
			}else
			{
				p=p->m_p2;
			}
		}
		if (p==NULL)
		{
			return false;
		}

		//2.judge
		if (p->m_p1 == NULL)
		{
			if (q==NULL)
			{
				m_head = p->m_p2;
				delete p; p= NULL;
			}else
			{
				if (q->m_p1 == p)
				{
					q->m_p1=p->m_p2;
					delete p;p=NULL;
				}else
				{
					q->m_p2=p->m_p2;
					delete p;p=NULL;
				}
			}
			return true;
		}

		if (p->m_p2==NULL)
		{
			if (q==NULL)
			{
				m_head = p->m_p1;
				delete p; p= NULL;
			}else
			{
				if (q->m_p1 == p)
				{
					q->m_p1=p->m_p1;
					delete p;p=NULL;
				}else
				{
					q->m_p2=p->m_p1;
					delete p;p=NULL;
				}
			}
			return true;
		}

		//
		q=p;
		Node<T>*s=NULL;
		p=p->m_p2;
		while (p->m_p1!=NULL)
		{
			s=p;
			p=p->m_p1;
		}
		if (s==NULL)
		{
			q->m_value=p->m_value;
			q->m_p2=p->m_p2;
			delete p;p=NULL;
		}else
		{
			q->m_value=p->m_value;
			s->m_p1=p->m_p2;
			delete p;p=NULL;
		}


	}
	Node<T> *m_head;
private:

	size_t m_size;
	void xDestroy(Node<T> *p)
	{
		if (p!=NULL)
		{
			xDestroy(p->m_p1);
			xDestroy(p->m_p2);
			delete p;
		}
	}

	void xPrint0(Node<T> *p)
	{
		if (NULL != p) 
		{ 
			if (p->m_p1 != NULL) 
			{
				xPrint0(p->m_p1);
			}
			cout<<p->m_value<<endl;
			if (p->m_p2 != NULL)
			{
				xPrint0(p->m_p2);
			}
		}
	}

	void xPrint1(Node<T> *p)
	{
		if (NULL != p) 
		{ 
			if (p->m_p1 != NULL) 
			{
				xPrint1(p->m_p1);
			}
			if (p->m_p2 != NULL)
			{
				xPrint1(p->m_p2);
			}
			cout<<p->m_value<<endl;
		}
	}


	void xPrint_1(Node<T> *p)
	{
		if (NULL != p) 
		{ 
			cout<<p->m_value<<endl;
			if (p->m_p1 != NULL) 
			{
				xPrint_1(p->m_p1);
			}
			if (p->m_p2 != NULL)
			{
				xPrint_1(p->m_p2);
			}

		}
	}

	Node<T> * xSearch(Node<T> *p, T &t_value)
	{
		if (p==NULL)
		{
			return NULL;
		}
		if (t_value < p->m_value)
		{
			return xSearch(p->m_p1, t_value);
		}
		else if (t_value > p->m_value)
		{
			return xSearch(p->m_p2, t_value);
		}else
		{
			return p;
		}
	}
	void xInsert(Node<T> *&p, T &t_value )
	{
		if (p==NULL)
		{ 
			p=new Node<T>;
			p->m_p2=NULL;
			p->m_p1=NULL;
			p->m_value = t_value;
			m_size++;
		} 
		else
		{
			if (t_value < p->m_value)
			{
				xInsert(p->m_p1, t_value);
			}
			else if (t_value > p->m_value)
			{
				xInsert(p->m_p2, t_value);
			}
			else
			{
				return;
			}
		}
	}
};

int main()
{

	BST<int> bst;
	int i;
	for (i=0; i<20; i++)
	{
		bst.Insert(i);
	}
	cout<<"中序遍历："<<bst.size()<<endl;
	bst.Print(0);
	//cout<<"先序遍历："<<bst.size()<<endl;
	//bst.Print(-1);
	//cout<<"后序遍历："<<bst.size()<<endl;
	//bst.Print(1);

	//for (i=10;i<30;i++)
	//{
	//	Node<int> *p=bst.Search(i);
	//	if (p==NULL)
	//	{
	//		cout<<"NULL"<<endl;
	//	}
	//	else
	//	{
	//		cout<<p->m_value<<endl;
	//	}
	//}

	//
	for (i=0;i<5;i++) // 删除0,2,4,6,8
	{
		bst.Remove(i*2);
	}
	cout<<"remove："<<bst.size()<<endl;
	bst.Print(0);
	return 0;

}

二叉排序树。