二叉搜索树

话不多说，直接上代码。

#include<iostream>
#include<stdlib.h>
using namespace std;
template <class K>
struct BSTreeNode
{
	BSTreeNode<K>* _left;
	BSTreeNode<K>*_right;
	K _key;
	BSTreeNode(const K& key)
		:_left(NULL)
		, _right(NULL)
		, _key(key)
	{}
};
template<class K>
class BSTree
{
public:
	typedef BSTreeNode<K> Node;
	BSTree()
		:_Root(NULL)
	{}
	Node* Find(const K& key)//查找  递归
	{
		Node* cur = _Root;
		while (cur)
		{
			if (cur->_key > key)
			{
				cur = cur->_left;
			}
			else if (cur->_key < key)
			{
				cur = cur->_right;
			}
			else
			{
				return cur;
			}
		}
		return NULL;
	}
	bool Insert(const K& key)//插入  递归
	{
		if (_Root == NULL)
		{
			_Root = new Node(key);
		}
		Node *cur = _Root;
		Node* parent = NULL;
		while (cur)
		{
			if (cur->_key > key)
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (cur->_key < key)
			{
				parent = cur;
				cur = cur->_right;
			}
			else
			{
				return false;
			}
		}
		if (key < parent->_key)
		{
			parent->_left = new Node(key);
		}
		else
		{
			parent->_right = new Node(key);
		}
		return true;
	}
	bool Remove(const K& key)//删除  递归
	{
		Node *cur = _Root;
		Node *parent = NULL;
		while (cur)
		{
			if (cur->_key > key)
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (cur->_key < key)
			{
				parent = cur;
				cur = cur->_right;
			}
			else
			{
				if (cur->_left == NULL)
				{
					if (cur == _Root)
					{
						_Root = cur->_right;
					}
					else
					{
						if (parent->_left == cur)
						{
							parent->_left = cur->_right;
						}
						else
						{
							parent->_right = cur->_right;
						}
					}
					delete cur;
				}
				else if (cur->_right == NULL)//右为空
				{
					if (cur == _Root)//if(parent==NULL)
					{
						_Root = cur->_left;
					}
					else
					{
						if (parent->_left == cur)
						{
							parent->_left = cur->_left;
						}
						else
						{
							parent->_right = cur->_left;
						}
					}
					delete cur;
				}
				else//左右都不为空
				{
					Node * sub = cur->_right;
					Node *parent =cur;//给空如果while循环不进去，会出错
					while (sub->_left)
					{
						parent = sub;
						sub = sub->_left;
					}
					cur->_key = sub->_key;
					if (sub==parent->_left)
					{
						parent->_left = sub->_right;
					}
					else
					{
						parent->_right = sub->_right;
					}
					delete sub;
				}
				return true;
			}
		}
		return false;
	}
	
	Node* FindR(const K& key)
	{
		return _FindR(Root, key);
	}
	bool InsertR(const K&key)
	{
		return _InsertR(_Root, key);
	}
	bool RemoveR(const K&key)
	{
		return _RemoveR(_Root, key);
	}
	
	void Inorder()
	{
	  _Inorder(_Root);
    }
private:
	void _Inorder(Node* Root)
	{
		if (Root == NULL)
		{
			return;
		}
		else
		{
			_Inorder(Root->_left);
			cout << Root->_key << " ";
			_Inorder(Root->_right);
		}
	}
	Node* _FindR(Node* Root, const K& key)//非递归  查找
	{
		if (Root == NULL)
		{
			return NULL;
		}
		if (Root->_key > key)
		{
			return _Find(Root->_left, key);
		}
		else if (Root->_key < key)
		{
			return _Find(Root->_right, key)
		}
		else
		{
			return Root;
		}
	}
	bool _InsertR(Node*& Root, const K&key)//非递归  插入
	{
		if (Root == NULL)
		{
			Root = new Node(key);
			return true;
		}
		if (Root->_key > key)
		{
			return _InsertR(Root->_left, key);
		}
		else if(Root->_key<key)
		{
			return _InsertR(Root->_right, key);
		}
		else
		{
			return false;

		}
	}
	bool _RemoveR(Node*& Root, const K&key)//非递归  删除1
	{
		if (Root == NULL)
		{
			return false;
		}
		if (Root->_key > key)
		{
			return _RemoveR(Root->_left, key);
		}
		else if (Root->_key < key)
		{
			return _RemoveR(Root->_right, key);
		}
		else
		{ 
			Node* del = Root;
			if (Root->_left == NULL)
			{
				Root = Root->_right;
				delete del;
			}
			else if (Root->_right == NULL)
			{
				Root = Root->_left;
				delete del;
			}
			else
			{
				Node * sub = Root->_right;
				while (sub->_left)
				{
					sub = sub->_left;
				}
				Root->_key = sub->_key;
				_RemoveR(Root->_right, sub->_key);
			}
			return true;
		}
	}

    bool _RemoveR(Node*& Root, const K&key)///非递归  删除2
	{
		if (Root == NULL)
		{
			return false;
		}
		if (Root->_key > key)
		{
			return _RemoveR(Root->_left, key);
		}
		else if (Root->_key < key)
		{
			return _RemoveR(Root->_right, key);
		}
		else
		{
			Node* del = Root;
			if (Root->_left == NULL)
			{
				Root = Root->_right;
				delete del;
	
			}
			else if (Root->_right == NULL)
			{
				Root = Root->_left;
				delete del;
			}
			else
			{
				Node * sub = Root->_right;
				Node* parent = Root;
				while (sub->_left)
				{
					parent = sub;
					sub = sub->_left;
				}
				Root->_key = sub->_key;
				if (parent->_left == sub)
				{
					parent->_left = sub->_right;
				}
				else
				{
					parent->_right = sub->_right;
				}
				delete sub;
			}
			return true;
		}


	}

	

private:
	Node* _Root;
};
int main()
{
	BSTree<int> s1;
	int arr[] = { 2, 3, 5, 0, 9, 8, 7, 6, 1, 4 };
	for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
	{
		s1.InsertR(arr[i]);
	}
	s1.RemoveR(1);
	s1.Inorder();
	cout << endl;
	s1.RemoveR(2);
	s1.Inorder();
	cout << endl;
	s1.RemoveR(3);
	s1.RemoveR(4);
	s1.RemoveR(5);
	s1.RemoveR(6);
	s1.RemoveR(7);
	s1.RemoveR(8);
	s1.RemoveR(9);
	s1.Inorder();
	cout << endl;
	s1.RemoveR(0);
	s1.Inorder();
	cout << endl;
	system("pause");
	return 0;
}