二叉搜索树

二叉树在前面《二叉树从入门到精通》已经讲过，本节介绍二叉搜索树。

1. map和set特性需要先铺垫二叉搜索树，二叉搜索树也是一种树形结构
2. 二叉搜索树的特性了解，有助于更好的理解map和set的特性

二叉搜索树的概念

二叉搜索树又称为二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树：

• 若它的左子树不为空，则左子树上所有结点的值都小于根结点的值。
• 若它的右子树不为空，则右子树上所有结点的值都大于根结点的值。
• 它的左右子树也分别是二叉搜索树。

例如:

二叉搜索树的性质，我们可以看到它进行中序遍历后，得到的是升序序列。

二叉搜索树的实现

结点类

要实现二叉搜索树，我们首先需要实现一个结点类：

• 结点类当中包含三个成员变量：结点值、左指针、右指针。
• 结点类当中只需实现一个构造函数即可，用于构造指定结点值的结点。

template<class K>
struct BSTreeNode
{
	BSTreeNode<K>* _left;
	BSTreeNode<K>* _right;

	K _key;

	//构造函数
	BSTreeNode(const K& key)
		:_left(nullptr)
		,_right(nullptr)
		,_key(key)
		{}

};

各函数接口总览

//二叉搜索树
template<class K>
class BSTree
{
	typedef BSTreeNode<K> Node;
public:
	//构造函数
	BSTree();

	//拷贝构造函数
	BSTree(const BSTree<K>& t);

	//赋值运算符重载函数
	BSTree<K>& operator=(BSTree<K> t);

	//析构函数
	~BSTree();

	//插入函数
	bool Insert(const K& key);

	//删除函数
	bool Erase(const K& key);

	//查找函数
	bool Find(const K& key);

	//中序遍历
	void InOrder();
private:
	Node* _root=nullptr; //指向二叉搜索树的根结点
};

中序遍历接口

为了在实现其他接口的过程中方便随时检查，最好实现一个二叉搜索树的中序遍历接口，当我们实现完一个接口后，可以调用中序遍历接口对二叉搜索树进行遍历，若二叉搜索树进行操作后的遍历结果仍为升序，则可以初步判断所实现的接口是正确。

void InOrder()
	{
		_InOrder(_root);
		cout << endl;
	}
private:
//中序遍历的子函数
	void _InOrder(Node* root)
	{
		if (root == nullptr)
		{
			return;
		}

		_InOrder(root->_left);
		cout << root->_key << " ";
		_InOrder(root->_right);
	}

注意：为什么我们要多此一举写一个子函数，采用通过InOrder()调用中序遍历的子函数的形式来实现中序，而不是直接调用中序遍历呢–

我们在子函数接口前都加了private-私有（权限修饰符），外部想要调用此接口，只有通过InOrder（）才能进行调用，这样增加了安全性。

构造函数

//构造函数
BSTree()
	:_root(nullptr)
{}

拷贝构造函数

拷贝一棵和所给二叉搜索树相同的树。

//拷贝树
Node* _Copy(Node* root)
{
	if (root == nullptr) //空树直接返回
		return nullptr;

	Node* copyNode = new Node(root->_key); //拷贝根结点
	copyNode->_left = _Copy(root->_left); //拷贝左子树
	copyNode->_right = _Copy(root->_right); //拷贝右子树
	return copyNode; //返回拷贝的树
}
//拷贝构造函数
BSTree(const BSTree<K>& t)
{
	_root = _Copy(t._root); //拷贝t对象的二叉搜索树
}

注意： 拷贝构造函数完成的是深拷贝。

赋值运算符重载函数

对于赋值运算符重载函数，下面提供两种实现方法：

传统写法

完成所给二叉搜索树的拷贝即可。

//传统写法
const BSTree<K>& operator=(const BSTree<K>& t)
{
	if (this != &t) //防止自己给自己赋值
	{
		_root = _Copy(t._root); //拷贝t对象的二叉搜索树
	}
	return *this; //支持连续赋值
}

现代写法

赋值运算符重载函数的现代写法非常精辟，函数在接收右值时并没有使用引用进行接收，因为这样可以间接调用BSTree的拷贝构造函数完成拷贝构造。我们只需将这个拷贝构造出来的对象的二叉搜索树与this对象的二叉搜索树进行交换，就相当于完成了赋值操作，而拷贝构造出来的对象t会在该赋值运算符重载函数调用结束时自动析构。

//现代写法
BSTree<K>& operator=(BSTree<K> t) //编译器接收右值的时候自动调用拷贝构造函数
{
	swap(_root, t._root); //交换这两个对象的二叉搜索树
	return *this; //支持连续赋值
}

注意： 这里传统写法和现代写法完成的都是深拷贝。

析构函数

析构函数完成对象中二叉搜索树结点的释放，注意释放时采用后序释放，当二叉搜索树中的结点被释放完后，将对象当中指向二叉搜索树的指针及时置空即可。

//释放树中结点
void _Destory(Node* root)
{
	if (root == nullptr) //空树无需释放
		return;

	_Destory(root->_left); //释放左子树中的结点
	_Destory(root->_right); //释放右子树中的结点
	delete root; //释放根结点
}
//析构函数
~BSTree()
{
	_Destory(_root); //释放二叉搜索树中的结点
	_root = nullptr; //及时置空
}

插入函数

插入的具体过程如下：

a.若树为空，则直接插入：

b.树不为空，按二叉搜索树性质查找插入位置，插入新节点:

若不是空树，插入结点的具体操作如下：

• 若待插入结点的值小于根结点的值，则需要将结点插入到左子树当中。
• 若待插入结点的值大于根结点的值，则需要将结点插入到右子树当中。
• 若待插入结点的值等于根结点的值，则插入结点失败。

如此进行下去，直到找到与待插入结点的值相同的结点判定为插入失败，或者最终插入到某叶子结点的左右子树当中（即空树当中）。

非递归实现

使用非递归方式实现二叉搜索树的插入函数时，我们需要定义一个parent指针，该指针用于标记待插入结点的父结点。
这样一来，当我们找到待插入结点的插入位置时，才能很好的将待插入结点与其父结点连接起来。

但是需要注意在连接parent和cur时，需要判断应该将cur连接到parent的左边还是右边。

//迭代实现插入（非递归）
bool Insert(const K& key)
{
	if (_root == nullptr) //空树
	{
		_root = new Node(key); //直接申请值为key的结点作为二叉搜索树的根结点
		return true; //插入成功，返回true
	}
	Node* parent = nullptr;
	Node* cur = _root;
	while (cur)
	{
		if (key < cur->_key) //key值小于当前结点的值
		{
			//往该结点的左子树走
			parent = cur;
			cur = cur->_left;
		}
		else if (key > cur->_key) //key值大于当前结点的值
		{
			//往该结点的右子树走
			parent = cur;
			cur = cur->_right;
		}
		else //key值等于当前结点的值
		{
			return false; //插入失败，返回false
		}
	}
	cur = new Node(key); //申请值为key的结点
	if (key < parent->_key) //key值小于当前parent结点的值
	{
		parent->_left = cur; //将结点连接到parent的左边
	}
	else //key值大于当前parent结点的值
	{
		parent->_right = cur; //将结点连接到parent的右边
	}
	return true; //插入成功，返回true
}

递归实现

递归实现二叉搜索树的插入操作要特别注意的一点就是，递归插入函数的子函数接收参数root时，必须采用引用接收，因为只有这样我们才能将二叉树当中的各个结点连接起来

巧妙之处：采用引用后，当前节点root,也是其父节点的left(或者right)的别名，因此在找到相应插入后，不需要再手动将插入节点和其父节点进行连接。

//递归插入函数的子函数
bool _InsertR(Node*& root, const K& key) //注意引用
{
	if (root == nullptr) //空树
	{
		root = new Node(key); //直接申请值为key的结点作为树的根结点
		return true; //插入成功，返回true
	}

	if (key < root->_key) //key值小于根结点的值
	{
		return _InsertR(root->_left, key); //应将结点插入到左子树当中
	}
	else if (key > root->_key) //key值大于根结点的值
	{
		return _InsertR(root->_right, key); //应将结点插入到右子树当中
	}
	else //key值等于根结点的值
	{
		return false; //插入失败，返回false
	}
}
//递归插入函数
bool InsertR(const K& key)
{
	return _InsertR(_root, key); //调用子函数进行插入
}

查找函数

根据二叉搜索树的特性，我们在二叉搜索树当中查找指定值的结点的方式如下：

若树为空树，则查找失败，返回false。
若key值小于当前结点的值，则应该在该结点的左子树当中进行查找。
若key值大于当前结点的值，则应该在该结点的右子树当中进行查找。
若key值等于当前结点的值，则查找成功，返回对应结点的地址。

非递归实现

二叉搜索树查找函数的非递归实现如下：

//查找函数
Node* Find(const K& key)
{
	Node* cur = _root;
	while (cur)
	{
		if (key < cur->_key) //key值小于该结点的值
		{
			cur = cur->_left; //在该结点的左子树当中查找
		}
		else if (key > cur->_key) //key值大于该结点的值
		{
			cur = cur->_right; //在该结点的右子树当中查找
		}
		else //找到了值为key的结点
		{
			return cur; //查找成功，返回结点地址
		}
	}
	return nullptr; //树为空或查找失败，返回nullptr
}

递归实现

二叉搜索树查找函数的递归实现如下：

//递归查找函数的子函数
Node* _FindR(Node* root, const K& key)
{
	if (root == nullptr) //树为空
		return nullptr; //查找失败，返回nullptr

	if (key < root->_key) //key值小于根结点的值
	{
		return _FindR(root->_left, key); //在根结点的左子树当中查找
	}
	else if (key > root->_key) //key值大于根结点的值
	{
		return _FindR(root->_right, key); //在根结点的右子树当中查找
	}
	else //key值等于根结点的值
	{
		return root; //查找成功，返回根结点地址
	}
}

//递归查找函数
Node* FindR(const K& key)
{
	return _FindR(_root, key); //在_root当中查找值为key的结点
}

删除函数

二叉搜索树的删除函数是最难实现的，若是在二叉树当中没有找到待删除结点，则直接返回false表示删除失败即可，但若是找到了待删除结点，此时就有以下三种情况：

• 待删除结点的左子树为空（待删除结点的左右子树均为空包含在内）。
• 待删除结点的右子树为空。
• 待删除结点的左右子树均不为空。

下面我们分别对这三种情况进行分析处理：

1、待删除结点的左子树为空

• 若待删除结点的左子树为空，那么当我们在二叉搜索树当中找到该结点后，只需先让其父结点指向该结点的右孩子结点，然后再将该结点释放便完成了该结点的删除，进行删除操作后仍保持二叉搜索树的特性。

2、待删除结点的右子树为空

• 若待删除结点的右子树为空，那么当我们在二叉搜索树当中找到该结点后，只需先让其父结点指向该结点的左孩子结点，然后再将该结点释放便完成了该结点的删除，进行删除操作后仍保持二叉搜索树的特性。

3、待删除结点的左右子树均不为空

• 若待删除结点的左右子树均不为空，那么当我们在二叉搜索树当中找到该结点后，可以使用替换法进行删除。
• 可以将让待删除结点左子树当中值最大的结点，或是待删除结点右子树当中值最小的结点代替待删除结点被删除（下面都以后者为例），然后将待删除结点的值改为代替其被删除的结点的值即可。而代替待删除结点被删除的结点，必然左右子树当中至少有一个为空树，因此删除该结点的方法与前面说到的情况一和情况二的方法相同。
• 注意只能是待删除结点左子树当中值最大的结点，或是待删除结点右子树当中值最小的结点代替待删除结点被删除，因为只有这样才能使得进行删除操作后的二叉树仍保持二叉搜索树的特性。
  

非递归实现

在遇到待删除结点的左右子树均不为空的情况时，采用的处理方法如下：

• 使用minParent标记待删除结点右子树当中值最小结点的父结点。
• 使用minRight标记待删除结点右子树当中值最小的结点。

当找到待删除结点右子树当中值最小的结点时，先将待删除结点的值改为minRight的值，之后直接判断此时minRight是minParent的左孩子还是右孩子，然后对应让minParent的左指针或是右指针转而指向minRight的右孩子（注意：minRight的左孩子为空），最后将minRight结点进行释放即可。

//删除函数
bool Erase(const K& key)
{
	Node* parent = nullptr; //标记待删除结点的父结点
	Node* cur = _root; //标记待删除结点
	while (cur)
	{
		if (key < cur->_key) //key值小于当前结点的值
		{
			//往该结点的左子树走
			parent = cur;
			cur = cur->_left;
		}
		else if (key > cur->_key) //key值大于当前结点的值
		{
			//往该结点的右子树走
			parent = cur;
			cur = cur->_right;
		}
		else //找到了待删除结点
		{
			if (cur->_left == nullptr) //待删除结点的左子树为空
			{
				if (cur == _root) //待删除结点是根结点，此时parent为nullptr
				{
					_root = cur->_right; //二叉搜索树的根结点改为根结点的右孩子即可
				}
				else //待删除结点不是根结点，此时parent不为nullptr
				{
					if (cur == parent->_left) //待删除结点是其父结点的左孩子
					{
						parent->_left = cur->_right; //父结点的左指针指向待删除结点的右子树即可
					}
					else //待删除结点是其父结点的右孩子
					{
						parent->_right = cur->_right; //父结点的右指针指向待删除结点的右子树即可
					}
				}
				delete cur; //释放待删除结点
				return true; //删除成功，返回true
			}
			else if (cur->_right == nullptr) //待删除结点的右子树为空
			{
				if (cur == _root) //待删除结点是根结点，此时parent为nullptr
				{
					_root = cur->_left; //二叉搜索树的根结点改为根结点的左孩子即可
				}
				else //待删除结点不是根结点，此时parent不为nullptr
				{
					if (cur == parent->_left) //待删除结点是其父结点的左孩子
					{
						parent->_left = cur->_left; //父结点的左指针指向待删除结点的左子树即可
					}
					else //待删除结点是其父结点的右孩子
					{
						parent->_right = cur->_left; //父结点的右指针指向待删除结点的左子树即可
					}
				}
				delete cur; //释放待删除结点
				return true; //删除成功，返回true
			}
			else //待删除结点的左右子树均不为空
			{
				//替换法删除
				Node* minParent = cur; //标记待删除结点右子树当中值最小结点的父结点
				Node* minRight = cur->_right; //标记待删除结点右子树当中值最小的结点
				//寻找待删除结点右子树当中值最小的结点
				while (minRight->_left)
				{
					//一直往左走
					minParent = minRight;
					minRight = minRight->_left;
				}
				cur->_key = minRight->_key; //将待删除结点的值改为minRight的值
				//注意一个隐含条件：此时minRight的_left为空
				if (minRight == minParent->_left) //minRight是其父结点的左孩子
				{
					minParent->_left = minRight->_right; //父结点的左指针指向minRight的右子树即可
				}
				else //minRight是其父结点的右孩子
				{
					minParent->_right = minRight->_right; //父结点的右指针指向minRight的右子树即可
				}
				delete minRight; //释放minRight
				return true; //删除成功，返回true
			}
		}
	}
	return false; //没有找到待删除结点，删除失败，返回false
}

递归实现

• 递归实现二叉搜索树的删除函数的思路如下：

• 若树为空树，则结点删除失败，返回false。
• 若所给key值小于树根结点的值，则问题变为删除左子树当中值为key的结点。
• 若所给key值大于树根结点的值，则问题变为删除右子树当中值为key的结点。
• 若所给key值等于树根结点的值，则根据根结点左右子树的存在情况不同，进行不同的处理。

在遇到待删除结点的左右子树均不为空的情况时，在找到待删除结点右子树当中值最小的结点后，先将minRight的值记录下来，然后再重新调用递归删除函数的子函数从当前根结点的右子树开始，删除右子树当中的minRight，当minRight被删除后再将根结点的值改为minRight的值，这样也完成了左右子树均不为空的结点的删除。

//递归删除函数的子函数
bool _EraseR(Node*& root, const K& key)
{
	if (root == nullptr) //空树
		return false; //删除失败，返回false

	if (key < root->_key) //key值小于根结点的值
		return _EraseR(root->_left, key); //待删除结点在根的左子树当中
	else if (key > root->_key) //key值大于根结点的值
		return _EraseR(root->_right, key); //待删除结点在根的右子树当中
	else //找到了待删除结点
	{
		if (root->_left == nullptr) //待删除结点的左子树为空
		{
			Node* del = root; //保存根结点
			root = root->_right; //根的右子树作为二叉树新的根结点
			delete del; //释放根结点
		}
		else if (root->_right == nullptr) //待删除结点的右子树为空
		{
			Node* del = root; //保存根结点
			root = root->_left; //根的左子树作为二叉树新的根结点
			delete del; //释放根结点
		}
		else //待删除结点的左右子树均不为空
		{
			Node* minRight = root->_right; //标记根结点右子树当中值最小的结点
			//寻找根结点右子树当中值最小的结点
			while (minRight->_left)
			{
				//一直往左走
				minRight = minRight->_left;
			}
			K minKey = minRight->_key; //记录minRight结点的值
			_EraseR(root->_right, minKey); //删除右子树当中值为minkey的结点，即删除minRight
			root->_key = minKey; //将根结点的值改为minRight的值
		}
		return true; //删除成功，返回true
	}
}
//递归删除函数（方法二）
bool EraseR(const K& key)
{
	return _EraseR(_root, key); //删除_root当中值为key的结点
}

二叉搜索树的性能分析

对于二叉搜索树来说，无论的插入查找还是删除操作，都需要先进行查找，因此查找的效率代表了二叉搜索树中各个操作的性能。

对于二叉搜索树这棵特殊的二叉树，我们每进行一次查找，若未查找到目标结点，则还需查找的树的层数就减少了一层，所以我们最坏情况下需要查找的次数就是二叉搜索树的深度，深度越深的二叉搜索树，比较的次数就越多。

对于有n个结点的二叉搜索树：

• 最优的情况下，二叉搜索树为完全二叉树，其平均比较次数为：l o g N
• 最差的情况下，二叉搜索树退化为单支树，其平均比较次数为：N / 2

而时间复杂度描述的是最坏情况下算法的效率，因此普通二叉搜索树各个操作的时间复杂度都是O ( N ) 。

所以实际上，二叉搜索树在极端情况下是没办法保证效率的，因此由二叉搜索树又衍生出来了AVL树、红黑树等，它们对二叉搜索树的高度进行了优化，使得二叉搜索树非常接近完全二叉树，因此对于这些树来说，它们的效率是可以达到O ( l o g N ) 的。

顺便说一下：
B树和B+树是查找存储在磁盘当中的数据时经常用到的数据结构，B树系列对树的高度提出了更高的要求，此时二叉树已经不能满足要求了，为了降低树的高度，于是衍生出了多叉树，而实际上这些树都是由二叉搜索树演变出来的，它们各有各的特点，适用于不同的场景。

---

the end!