C++：二叉搜索树

1.二叉搜索树的概念

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

若它的左子树不为空，那么左子树上的所有节点的值都小于等于根节点的值
若它的右子树不为空，那么左子树上的所有节点的值都大于等于根节点的值
它的左子树和右子树也是二叉搜索树
二叉搜索树支持插入相等的值，也可以不支持插入相等的值，具体看使用场景定义，后续我们学习map/set/multimap/multiset系列的容器底层就是二叉搜索树，其中map/set不支持插入相等的值，multimap/multiset支持插入相等的值

二叉搜索树样例：

2.二叉搜索树的性能分析

最优情况下，二叉搜索树为完全二叉树（或者接近完全二叉树），其高度为：O(logN)

最差情况下，二叉搜索树退化为单支树(或者类似单支）,其高度为：O(N)

所以综合而言二叉搜索树的时间复杂度为：O(N)

另外需要说明的是，二分查找也可以实现O(logN)级别的查找效率，但是二分查找有两大缺陷：

1.需要存储在支持下标随机访问的结构中(如数组），并且有序

2.插入和删除数据效率很低，这是因为存储在下标随机访问的结构中，插入和删除数据一般需要挪动数据

3.二叉搜索树的插入

插入的具体过程如下：

1.如果这棵树为空树，那么直接新增节点，赋值给root节点

2.如果这棵树不为空树，按照二叉搜索树的性质，如果插入值比当前节点的值就往右走，插入值比当前节点的值小就往左走，找到空位置，新增节点并插入新节点

3.如果支持插入相等的值，如果插入值跟当前节点的值相等，可以往右走也可以向左走，找到空位置，插入新节点（要注意的是保持逻辑的一致性，插入相等的值不要一会往右走，一会往左走）

例子1：

int a[] = { 8,3,1,10,6,4,7,14,13};

代码：

cpp 复制代码

template<class K>
struct BSTNode
{
	K _key;
	BSTNode<K>* _left;
	BSTNode<K>* _right;
	BSTNode(const K& key)
		:_key(key)
		, _left(nullptr)
		, _right(nullptr)
	{}
};

// Binary Search Tree
template<class K>
class BSTree
{
	typedef BSTNode<K> Node;
public:
	bool Insert(const K& key)
	{
		if (_root == nullptr)
		{
			_root = new Node(key);
			return true;
		}
		Node* parent = nullptr;
		Node* cur = _root;
		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;
	}
	void InOrder()
	{
		_InOrder(_root);
		cout << endl;
	}
private:
	void _InOrder(Node* root)
	{
		if (root == nullptr)
		{
			return;
		}
		_InOrder(root->_left);
		cout << root->_key << " ";
		_InOrder(root->_right);
	}
private:
	Node* _root = nullptr;
};

int main()
{
	int a[] = { 8,3,1,10,6,4,7,14,13 };

	//插入值为16的节点
	BSTree<int> t;
	for (auto e : a)
	{
		t.Insert(e);
	}

	t.Insert(16);
	t.InOrder();

	return 0;
}

代码分析：

首先我们通过一个模版结构体template<class K> struct BSTNode定义了二叉搜索树的节点，它允许你指定一个类型为K作为节点的类型，K _key; 存储节点的值

BSTNode<K>* _left; 表示指向左节点的指针

BSTNode<K>* _right;表示指向左节点的指针

接着通过一个初始化列表初始化节点；

然后我们定义了一个模版类BSTree来表示一个二叉搜索树，接着我们在类里面先实现了插入操作，我们首先判断该节点是否为空，如果为空则代表着这是一颗空树，所以我们需要自己手动增加新节点，接着我们定义一个指向父节点的指针parent和一个指向当前节点的指针cur，cur首先赋值为根节点，然后我们使用一个while循环，如果当前节点不为空节点，那么我们继续进入循环，如果当前cur节点的值小于要插入树的值，我们让parent节点走到cur节点的位置，cur节点走到cur节点的右边（这是因为右节点大于根节点）；如果当前cur节点的值小大于要插入树的值，我们让parent节点走到cur节点的位置，cur节点走到cur节点的左边（这是因为左节点小于根节点）。当走到空位置时，我们跳出循环，重新新增一个节点。接着我们要判断一下cur节点当前要在哪里，如果要插入的值大于parent节点的值，那么在parent节点的右侧插入，如果要插入的值小于parent节点的值，那么在parent节点的左侧插入
此外，我们还定义了一个中序遍历函数void _InOrder(Node* root)来遍历这棵树，中序遍历的遍历方式是左子树，根，右子树，由于二叉搜索树的左子树的值都小于等于根节点，二叉搜索树的右子树的值都大于等于根节点，所以使用中序遍历的结果必然是有序的。这里之所以重新定义了一个void InOrder()函数是因为 _InOrder函数是被定义为私有的，不能在类外访问

执行结果：

4.二叉搜索树的查找

1.从根开始比较，查找x，如果x比根的值大则往右走，x比根的值小则往左走

2.最多查找高度次，如果走到空都没有找到，那么这个值不存在

3.如果不支持插入相等的值，找到x即可返回

4.如果支持插入相等的值，意味着有多个x存在，一般要求查找中序的第一个x。

例子2：

代码：

cpp 复制代码

bool Find(const K& key)
{
    //从根节点开始查找
	Node* cur = _root;
	while (cur)
	{
        //当前节点的值小于要查找的值，向右查找
		if (cur->_key < key)
		{
			cur = cur->_right;
		}
        //当前节点的值大于要查找的值，向左查找
		else if (cur->_key > key)
		{
			cur = cur->_left;
		}
        //两个值相等代表已经找到了，返回true
		else
		{
			return true;
		}
	}
    //此时当前指针已经走到空位置还没有找到，返回false
	return false;
}

代码分析：

首先从根开始比较，查找key，如果key比根的值大则往右走，key比根的值小则往左走,最多查找高度次，如果走到空都没有找到（即已经走出while循环），那么这个值不存在,返回false

5.二叉搜索树的删除

首先查找元素是否在二叉搜索树中，如果不存在，则返回false

如果查找元素存在则分以下4种情况分别处理：（假设要删除的节点为N）

1.要删除的节点N左右节点均为空

2.要删除的节点N左孩子为空，右孩子节点不为空

3.要删除的节点N右孩子为空，左孩子节点不为空

4.要删除的节点N左右节点均不为空

对应以上4中情况的解决方案：

1.把N节点的父节点对应的孩子指针指向空，直接删除N节点（把情况1当作情况2或者情况3处理是一样的）

2.把N节点的父节点对应的孩子指针指向N的右孩子，直接删除N节点

3.把N节点的父节点对应的孩子指针指向N的左孩子，直接删除N节点

4.无法直接删除N节点，因为N的两个孩子节点无处安放，只能用替换分删除。找N左子树的值的最大节点replace（最右节点）或者N右子树的值的最小节点replace（最左节点）替换N，因为这两个节点的任意一个放到N的位置都满足二叉搜索树的规则。替换N的意思是把N节点和replace节点的值交换，转而变成删除replace节点，replace节点符合情况2或情况3，可以直接删除。

情况1样例：

情况2 样例：

情况3样例：

情况4样例：

代码：

cpp 复制代码

bool Erase(const K& key)
{
	Node* parent = nullptr;
	Node* cur = _root;

	while (cur)
	{
		if (cur->_key < key)
		{
			parent = cur;
			cur = cur->_right;
		}

		else if (cur->_key > key)
		{
			parent = cur;
			cur = cur->_left;
		}

		else
		{
			//找到了，删除
			//左为空
			if (cur->_left == nullptr)
			{
				if (cur == _root)
				{
					_root = cur->_right;
				}

				else
				{
					//该节点为父节点的左孩子
					if (cur == parent->_left)
					{
						parent->_left = cur->_right;
					}

					//该节点为父节点的右节点
					else
					{
						parent->_right = cur->_right;
					}
				}

				delete cur;
			}

			//右为空
			else if (_root->_right == nullptr)
			{
				if (cur == _root)
				{
					_root = cur->_left;
				}

				else
				{
					//该节点为父节点的左节点
					if (cur == parent->_left)
					{
						parent->_left = cur->_left;
					}

					//该节点为父节点的右节点
					else
					{
						parent->_right = cur->_left;
					}
				}
				delete cur;
			}

			//左右节点都不为空
			else
			{
				Node* replaceParent = cur;
				Node* replace = cur->_right;

				//查找右子树中最左节点替换根节点
				while (replace->_left)
				{
					replaceParent = replace;
					replace = replace->_left;
				}

				cur->_key = replace->_key;

				if (replace == replaceParent->_left)
				{
					replaceParent->_left = replace->_right;
				}

				else
				{
					replaceParent->_right = replace->_right;
				}

				delete replace;
			}

			return true;
		}
	}

	return false;
}

代码分析：

我们定义两个指针一个指向当前节点cur，一个指向当前节点的父节点parent，首先我们在这棵二叉树中查找这个要删除的值，如果要删除的值大于当前节点的值，那么cur继续向右查找，如果要删除的值小于当前节点的值，那么cur继续向左查找，走到else语句中代表已经找到要删除的值的节点了，开始进行删除操作。

根据上面的描述我们可以知道我们可以分三种情况讨论：

第一种是左为空，右不为空：此时也分两种情况讨论：

a：是如果当前节点为根节点，那么根节点就变换成为根节点的右节点

b：如果当前节点为父节点的左孩子，就将父节点的左节点指向当前cur节点的右节点，如果当前节点为父节点的右孩子，就将父节点的右节点指向当前cur节点的右节点

第二种是右为空，左不为空，尝试也分两种情况讨论：

a：是如果当前节点为根节点，那么根节点就变换成为根节点的左节点

b：如果当前节点为父节点的左孩子，就将父节点的左节点指向当前cur节点的左节点，如果当前节点为父节点的右孩子，就将父节点的右节点指向当前cur节点的左节点

第三种是左右都为空（在此例子中使用的是查找右子树中最左节点替换要删除的节点）

此时我们需要多定义两个指针，一个指向被替换节点，一个指向被替换节点的父节点，此时被替换节点replace节点指向要删除节点的右节点，如果replace节点不为空，那么一直更新replace节点的位置，直到找到右子树中的最左节点，此时replace节点就是最左节点，将cur节点的值和replace节点的值交换，如果replace节点位于其父节点的左侧，将replaceparent节点的左节点指向replace节点的右节点，否者将replaceparent节点的右节点指向replace节点的右节点

完整代码：

cpp 复制代码

#define  _CRT_SECURE_NO_WARNINGS 1
#include<iostream>

using namespace std;


template<class K>
struct BSTNode
{
	K _key;
	BSTNode<K>* _left;
	BSTNode<K>* _right;
	BSTNode(const K& key)
		:_key(key)
		, _left(nullptr)
		, _right(nullptr)
	{}
};

// Binary Search Tree
template<class K>
class BSTree
{
	typedef BSTNode<K> Node;
public:
	bool Insert(const K& key)
	{
		if (_root == nullptr)
		{
			_root = new Node(key);
			return true;
		}
		Node* parent = nullptr;
		Node* cur = _root;
		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;
	}

	bool Find(const K& key)
	{
		Node* cur = _root;
		while (cur)
		{
			if (cur->_key < key)
			{
				cur = cur->_right;
			}
			else if (cur->_key > key)
			{
				cur = cur->_left;
			}
			else
			{
				return true;
			}
		}
		return false;
	}

	bool Erase(const K& key)
	{
		Node* parent = nullptr;
		Node* cur = _root;

		while (cur)
		{
			if (cur->_key < key)
			{
				parent = cur;
				cur = cur->_right;
			}

			else if (cur->_key > key)
			{
				parent = cur;
				cur = cur->_left;
			}

			else
			{
				//找到了，删除
				//左为空
				if (cur->_left == nullptr)
				{
					if (cur == _root)
					{
						_root = cur->_right;
					}

					else
					{
						//该节点为父节点的左孩子
						if (cur == parent->_left)
						{
							parent->_left = cur->_right;
						}

						//该节点为父节点的右节点
						else
						{
							parent->_right = cur->_right;
						}
					}

					delete cur;
				}

				//右为空
				else if (_root->_right == nullptr)
				{
					if (cur == _root)
					{
						_root = cur->_left;
					}

					else
					{
						//该节点为父节点的左节点
						if (cur == parent->_left)
						{
							parent->_left = cur->_left;
						}

						//该节点为父节点的右节点
						else
						{
							parent->_right = cur->_left;
						}
					}
					delete cur;
				}

				//左右节点都不为空
				else
				{
					Node* replaceParent = cur;
					Node* replace = cur->_right;

					//查找右子树中最左节点替换根节点
					while (replace->_left)
					{
						replaceParent = replace;
						replace = replace->_left;
					}

					cur->_key = replace->_key;

					if (replace == replaceParent->_left)
					{
						replaceParent->_left = replace->_right;
					}

					else
					{
						replaceParent->_right = replace->_right;
					}

					delete replace;
				}

				return true;
			}
		}

		return false;
	}
	void InOrder()
	{
		_InOrder(_root);
		cout << endl;
	}
private:
	void _InOrder(Node* root)
	{
		if (root == nullptr)
		{
			return;
		}
		_InOrder(root->_left);
		cout << root->_key << " ";
		_InOrder(root->_right);
	}
private:
	Node* _root = nullptr;
};

int main()
{
	int a[] = { 8,3,1,10,6,4,7,14,13 };

	//插入值为16的节点
	BSTree<int> t;
	for (auto e : a)
	{
		t.Insert(e);
	}

	t.Insert(16);
	t.InOrder();

	t.Find(7);
	t.InOrder();

	t.Erase(8);
	t.InOrder();

	return 0;
}