【C++】二叉搜索树

因为涉及到二叉树的部分知识，建议在有一定的二叉树的基础上再来看这篇文章 

--------------

二叉搜索树

二叉搜索树的概念

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

简单来说，每一个节点的左子树都要比根节点小，每一个右子树都要比根节点大

这里看下面的一张图：

 

这就是一个较为标准的二叉搜索树，左节点<根<右节点，所以按照这样的思路，我们中序遍历的话是可以得到一个从小到大的顺序。

------

 二叉搜索树的一些操作

比较简单，插入，删除，查找，下面会提供两个版本：递归、非递归。

先简单看一下功能：

查找：如果查找的值比当前节点的大，就往右走，如果比当前节点的小，往左走，最多走树的高度次，走到空节点的时候那就是没找到，返回false。

（为什么这里不返回当前节点的位置，不是不能返回，是因为二叉搜索树的性质决定了每个值的位置，如果直接传位置的话一定要加上const防止修改）

插入；如果这个值比当前节点的大，往右走，如果比值小，左走，直到空节点，插入

删除是一个特例，这里之后实现部分再讲

模拟实现（非递归）

首先，定义一个模板，其次，跟模拟实现链表那块一样，这里放着的是根节点的指针，这个指针指向一个节点，节点是自定义的类型，在里面有存放的值，还有左孩子和右孩子

template<class T>
struct Tree_node
{
    T _val;
	Tree_node<T>* _lefe;
	Tree_node<T>* _right;
};


template<class T>
class binary_search_tree
{
public:
	typedef Tree_node<T> Node;

private:
	Node* _root = nullptr;
};

插入

首先，我们拿到一个要插入的值的时候，先判断一下，如果当前根节点为空，说明这是一个空树，要特殊处理一下。

其次，如果这个树不为空，就要找到它合适的位置放进去，再将它接到树里面去，这里就有注意一下，如果要链接起来，我们还需要一个值来找这个合适位置的父节点。

分析好情况，接下来就可以开始写了

在插入之前，先写一个节点的构造函数，方便我们之后开新节点

	Tree_node(const T& val)
		:_val(val)
		, _left(nullptr)
		, _right(nullptr)
	{}

给一个值，然后放进去，将其左右置空

很简单吧？

		bool insert(const T& val)
	{
		//判断根节点为空的空树情况
		if (_root == nullptr)
		{
			_root = new Node(val);
			return true;
		}
		else
		{
			//创建变量，防止修改_root
			Node* cur = _root;
			Node* parent = nullptr;
			//开始遍历往下找
			while (cur)
			{
				//当前值大于要找的，往左走并且将当前地址给父节点
				if (cur->_val > val)
				{
					parent = cur;
					cur = cur->_left;
				}
				//当前值小于要找的，往右走并且将当前地址给父节点
				else if (cur->_val < val)
				{
					parent = cur;
					cur = cur->_right;
				}
				//不允许有重复值
				else
				{
					return false;
				}
			}
			//找到了，新创节点并判断父节点大小方便链接
			cur = new Node(val);
			if (parent->_val > val)
			{
				parent->_lefe = cur;
			}
			else
			{
				parent->_right = cur;
			}
		}
		return true;
	}

查找

跟插入思路一样，比找的值小，右走，找的值大，左走，为空，找不到

返回值就不要返回当前节点的指针了，不让修改防止破坏树的结构

	bool find(const T& val)
	{
		Node* cur = _root;
		while (cur)
		{
			if (cur->_val > val)
			{
				cur = cur->_lefe;
			}
			else if (cur->_val < val)
			{
				cur = cur->_right;
			}
			else
			{
				return true;
			}
		}
		return false;
	}

因其思路过于简单就没有写注释，我相信各位也是可以看得懂的。

遍历

嗯，按照二叉搜索树的结构的话，如果中序遍历，我们得到的应该是一个有序数组，这里就简单写一个中序，肯定要用到递归，但是我们可以稍微封装一下：

    void InOrder()
	{
		_InOrder(_root);
	}	


void _InOrder(Node* root)
	{
		if (root == nullptr)
		{
			return;
		}
		else
		{
			_InOrder(root->_lefe);
			cout << root->_val << " ";
			_InOrder(root->_right);
		}
	}

上面是我们提供的接口，下面是接口的实现，下面的部分会放到隐私部分

这里简单的测试一下：

删除 

删除应该是二叉搜索树最难的一个部分，因为要理清思路：

1、这个节点有没有左右孩子

2、这个节点只有左孩子

3、这个节点只有右孩子

4、这个节点有两个孩子

1可以放到2 3里面去解决，这里分别说一下解决思路：

如果这个节点只有左孩子，那就要让父节点的指针指向被删节点的左子节点

如果这个节点只有右节点，那就要让父节点的指针指向本山节点的右子节点

如果这个节点有两个孩子，那就要用到替换法，我们在它的左子树里面找到最大的那个值，或者在右字数里面找最小的那个值，然后用那个值放进去，再将替换那个值的节点删掉

	bool Erase(const T& val)
	{
		Node* cur = _root;
		Node* parent = nullptr;

		while (cur)
		{
			//先找到要删除的节点
			if (cur->_val < val)
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (cur->_val > val)
			{
				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 (cur->_right == nullptr)
				{
					if (cur == _root)
					_root = cur->_left;
					else
					{
						if (cur == parent->_right)
							parent->_left = cur->_left;
						else
							parent->_right = cur->_left;
					}
					delete cur;
				}
				else
				{
					//找左边节点最大的
					Node* maxParent = cur;
					Node* maxleft = cur->_left;
					while (maxleft->_right != nullptr)
					{
						maxParent = maxleft;
						maxleft = maxleft->_right;
					}
					cur->_val = maxleft->_val;
					//链接起来
					if (maxParent->_left == maxleft)
					{
						maxParent->_left = maxleft->_left;
					}
					else
					{
						maxParent->_right = maxleft->_left;
					}
					//别忘了删除这个左边最大的节点
					delete maxleft;
				}
				//删完了返回真
				return true;
			}
		}
		//没找到就返回假
		return false;
	}

看看效果：

 模拟实现（递归）

递归大体思路跟非递归没有什么区别，唯一要注意的是细节方便，这里看代码理解会更好

template<class T>
class binary_search_tree_R
{
public:
	typedef Tree_node<T> Node;



	Node* _root = nullptr;
};

为了好看，我新创建一个类出来，_R代表这是一个递归版本

插入

思路参考非递归，找空节点插入，根节点特殊处理

	bool Insert(const T& val)
	{
		return _Insert(_root, val);
	}


private:

	bool _Insert(Node*& root, T val)
	{
		if (root == nullptr)
		{
			root = new Node(val);
			return true;
		}
		if (root->_val > val)
			return _Insert(root->_left,val);
		else if (root->_val < val)
			return  _Insert(root->_right, val);
		else
			return false;
	}

将根节点传进来，然后判断是否为空，为空就直接构建节点并赋值，不为空就返回自己下一个要找的节点的插入，直到找不到或者是插入完成。

这里为什么是Node*&，因为单纯用parent来记录当前节点的父节点会使得参数变多。

这里看图：

如果是按照之前的逻辑，那我们应该用一个节点来记录当前root的位置，让其链接上，但现在不一样的是我们传过去的是root所指向节点的别名，也就是说它其实是将root所指向的节点的别名传了过去，因为是别名，所以我们可以直接修改里面的值。

 可以这么理解，我们传过去的是不是root->right的地址拷贝，而是直接将root->right（或者是left）传了过去，对传过去的节点的修改是直接可以反应到树上，就不需要父节点了，当然也可以用，这里随自己喜欢。

查找

思路就不说了，直接看代码：

	bool find(const T& val)
	{
		return _find_R(_root, val);
	}


	bool _find_R(Node* root, const T& val)
	{
		if (root == nullptr)
			return false;
		if (root->_val > val)
		{
			_find_R(root->_left, val);
		}
		else if (root->_val < val)
		{
			_find_R(root->-right, val);
		}
		else
		{
			return true;
		}
	}

递归其实跟非递归实现的是一样的逻辑，如果懂了非递归，递归也很好理解

打印

其实非递归的打印也用了递归，这里就直接拿过来用即可

    void InOrder()
	{
		_InOrder(_root);
		return;
	}

	void _InOrder(Node* root)
		{
			if (root == nullptr)
			{
				return;
			}
			else
			{
				_InOrder(root->_left);
				cout << root->_val << " ";
				_InOrder(root->_right);
			}
		}

效果；

 删除

思路跟非递归一样，判断节点，然后根据节点条件来删除

		bool _Earse(Node*& root, const T& val)
		{
			//当前节点为空，没找到，返回失败
			if (root == nullptr)
				return false;
			//大于查找值，递归往左
			if (root->_val > val)
			{
				return _Earse(root->_left, val);
			}
			//小于查找值，递归往右
			else if (root->_val < val)
			{
				return _Earse(root->_right, val);
			}
			else
			{
				//先拿一个值记录等会要删的节点
				Node* del = root;

				//只有右节点
				if (root->_left == nullptr)
				{
					root = root->_right;
				}
				//只有左节点
				else if (root->_right == nullptr)
				{
					root = root->_left;
				}
				else
				{
					//先找到左边最大值
					Node* maxLeft = root->_left;
					while (maxLeft->_right != nullptr)
					{
						maxLeft = maxLeft->_right;
					}

					//交换左边最大值
					swap(root->_val, maxLeft->_val);

					//因为交换了之后也满足二叉搜索树的条件，且这个位置一定是叶子节点，可以递归调用自己
					return _Earse(root->_left, val);
				}
				delete del;
				return true;
			}
		}

其实可以看到，递归跟非递归，它们的思路大体都是一样的，只不过实现方式上有所不同，看着递归的代码少，但理解起来却比非递归麻烦的多。 

后续会有更新