搜索二叉树

1、与普通二叉树不同，二叉搜索树满足左树始终小于根节点，右子树始终大于左子树，对于子树也是一样。

2、实现：

（1）我们首先要用一个结构体控制树的节点

包括节点的值key，左子树与右子树，以及节点的初始构造函数

（2）其次我们用一个类封装树的活动：

（3）然后我们就可以在public中实现基本的函数：

a、查找：

按照左<根<右的顺序来进行查找

b、插入：

//插入函数
bool insert(const k& key)
{
//头结点为空
	if (_root == nullptr)
	{
		_root = new Node(key);
		return true;
	}
  //若不为空则先确定key的位置
//利用双指针在parent后插入
	Node* cur = _root;
	Node* parent = nullptr;
	while (cur)
	{
		if (cur->_key < key)
		{
			parent = cur;
			cur = cur->_right;
		}
		else if (cur->_key > key)
		{
			parent = cur;
			cur = cur->_left;
		}
		else
		{
			return false;
		}
	}

	cur = new Node(key);
  //按照左<根<右的顺序插入
	if (parent->_key < key)
	{
		parent->_right = cur;
	}
	else
	{
		parent->_left = cur;
	}

	return true;
}

c、删除：

//删除函数（用改值来做到删除）
//分为（1）叶子和一个孩子（2）两个孩子
bool erase(const k& key)
{
	Node* cur = _root;
	Node* parent = nullptr;
	while (cur)
	{
		if (cur->_key < key)
		{
			parent = cur;
			cur = cur->_right;
		}
		else if (cur->_key > key)
		{
			parent = cur;
			cur = cur->_left;
		}
		else
		{
			//0或1个孩子
			//只有右孩子
			if (cur->_left == nullptr)
			{
				//cur为根节点
				if(parent == nullptr)
				{ 
					_root = cur->_right;
				}
        //只有右孩子
				else
				{
					if (parent->_left == cur)
					{
						parent->_left = cur->_right;
					}
					else
						parent->_right = cur->_right;
				}
				delete cur;
				return true;
			}
			//只有左孩子
			else if (cur->_right == nullptr)
			{
				//cur为根节点
				if (parent == nullptr)
				{
					_root = cur->_left;
				}
				else
				{
					if (parent->_left == cur)
					{
						parent->_left = cur->_left;
					}
					else
						parent->_right = cur->_left;
				}
				delete cur;
				return true;
			}
			//有两个孩子
			//找替代节点，右最小或左最大（满足二叉搜索树要求）
			//左最大
			else
			{
				Node* leftmax = cur->_left;
				Node* leftmaxp = cur;
				//左子树的最右边为最大
				while (leftmax->_right)
				{
					leftmaxp = leftmax;
					leftmax = leftmax->_right;
				}

				cur->_key = leftmax->_key;
				if (leftmaxp->_left == leftmax)
				{
					leftmaxp->_left = leftmax->_left;
				}
				else
					leftmaxp->_right = leftmax->_left;
				delete leftmax;
				return true;
			}
			//右最小
			//else
			//{
			//	Node* rightmin = cur->_right;
			//	Node* rightminp = cur;
			//	//右子树的最左边为最小
			//	while (rightmin->_left)
			//	{
			//		rightminp = rightmin;
			//		rightmin = rightmin->_left;
			//	}

			//	cur->_key = rightmin->_key;
			//	if (rightminp->_left == rightmin)
			//	{
			//		rightminp->_left = rightmin->_right;
			//	}
			//	else
			//		rightminp->_right = rightmin->_right;
			//	delete rightmin;
			//	return true;
			//	}
		}
	}
}

d、中序遍历