概念

二叉搜索树又称为二叉排序树，有以下几个特征

左子树的值都比根节点的值小
右子树的值都比根节点的值大
左右子树也是二叉搜索树
中序遍历是升序
一般不支持改变元素

接口实现

注意：以下为C++模板实现

节点定义

template<class K>
struct BSTreeNode
{
	BSTreeNode(const K& val = val())
	{
		_left = nullptr;
		_right = nullptr;
		_val = val;
	}
	BSTreeNode* _left;
	BSTreeNode* _right;
	K _val;
};

插入元素

非递归版本

bool Insert(const K& val)
		{
			if (_root == nullptr)
			{
				_root = new Node(val);
				return true;
			}
			Node* cur = _root;
			Node* parent = nullptr;
			while (cur)
			{
				if (val > cur->_val)
				{
					parent = cur;
					cur = cur->_right;
				}
				else if (val < cur->_val)
				{
					parent = cur;
					cur = cur->_left;
				}
				else
				{
					return false;
				}
			}

			Node* newNode = new Node(val);
			if (val > parent->_val)
				parent->_right = newNode;
			else
				parent->_left = newNode;
			return true;
		}

递归版本

InsertR()函数为公有，_InesertR()函数为私有，调用时直接调用InsertR()即可。

bool InsertR(const K& val)
		{
			return _InsertR(_root, val);
		}
bool _InsertR(Node*& root, const K& val)
		{
			if (root == nullptr)
			{
				root = new Node(val);
				return true;
			}

			if (val > root->_val)
				return _InsertR(root->_right, val);
			else if (val < root->_val)
				return _InsertR(root->_left, val);
			else
				return false;
		}

删除元素

非递归版本

bool Erase(const K& val)
		{
			Node* cur = _root;
			Node* parent = nullptr;
			while (cur)
			{
				if (val > cur->_val)
				{
					parent = cur;
					cur = cur->_right;
				}
				else if (val < cur->_val)
				{
					parent = cur;
					cur = cur->_left;
				}
				else
				{
					if (cur == _root)
					{
						if (cur->_left == nullptr)
						{
							_root = _root->_right;
							delete cur;
							cur = nullptr;
							return true;
						}
						else if (cur->_right == nullptr)
						{
							_root = _root->_left;
							delete cur;
							cur = nullptr;
							return true;
						}
						else
						{
							Node* min = cur->_right;
							Node* minParent = cur;
							while (min->_left)
							{
								minParent = min;
								min = min->_left;
							}
							if (minParent == cur)
							{
								std::swap(minParent->_val, min->_val);
								minParent->_right = min->_right;
								delete min;
								min = nullptr;
								return true;
							}
							else
							{
								std::swap(cur->_val, min->_val);
								minParent->_left = min->_right;
								delete min;
								min = nullptr;
								return true;
							}
						}

					}
					else
					{
						if (cur->_left == nullptr)
						{
							if (parent->_left == cur)
								parent->_left = cur->_right;
							else
								parent->_right = cur->_right;
						}
						else if (cur->_right == nullptr)
						{
							if (parent->_left == cur)
								parent->_left = cur->_left;
							else
								parent->_right = cur->_left;
						}
						else
						{
							Node* min = cur->_right;
							Node* minParent = cur;
							while (min->_left)
							{
								minParent = min;
								min = min->_left;
							}
							if (minParent == cur)
							{
								std::swap(minParent->_val, min->_val);
								minParent->_right = min->_right;
								delete min;
								min = nullptr;
								return true;
							}
							else
							{
								std::swap(cur->_val, min->_val);
								minParent->_left = min->_right;
								delete min;
								min = nullptr;
								return true;
							}
						}
					}
					return true;
				}
			}
		}

递归版本

EraseR()为公有，_EraseR()为私有，调用时直接调用Erase()即可。

bool EraseR(const K& val)
		{
			return _EraseR(_root, val);
		}
bool _EraseR(Node*& root, const K& val)
		{
			if (root == nullptr)
				return false;

			if (val > root->_val)
			{
				return _EraseR(root->_right, val);
			}
			else if (val < root->_val)
			{
				return _EraseR(root->_left, val);
			}
			else
			{
				Node* del = root;
				if (root->_left == nullptr)
				{
					root = root->_right;
					delete del;
					del = nullptr;
					return true;
				}
				else if (root->_right == nullptr)
				{
					root = root->_left;
					delete del;
					del = nullptr;
					return true;
				}
				else
				{
					Node* min = root->_right;
					Node* minParent = root;
					while (min->_left)
					{
						minParent = min;
						min = min->_left;
					}
					if (minParent == root)
					{
						std::swap(root->_val, min->_val);
						minParent->_right = min->_right;
						delete min;
						min = nullptr;
						return true;
					}
					std::swap(root->_val, min->_val);
					return _EraseR(root->_right, val);
				}
				
			}
		}

查找元素

非递归版本

Node* Find(const K& val)
		{
			Node* cur = _root;
			while (cur)
			{
				if (val > cur->_val)
					cur = cur->_right;
				else if (val < cur->_val)
					cur = cur->_left;
				else
					return cur;
			}
			return nullptr;
		}

递归版本

FindR()为公有，_FindR()为私有，调用时直接调用FindR()即可。

Node* FindR(const K& val)
		{
			return _FindR(_root, val);
		}
Node* _FindR(Node*& root, const K& val)
		{
			if (root == nullptr)
				return nullptr;

			if (val > root->_val)
				return _FindR(root->_right, val);
			else if (val < root->_val)
				return _FindR(root->_left, val);
			else
				return root;
		}