c++学习之搜索二叉树

目录

一，什么是搜索二叉树？

二，搜索二叉树的实现 

非递归实现

节点与类成员

插入

查找

删除

 递归实现

插入

查找

 删除

---

一，什么是搜索二叉树？

搜索二叉树（Binary Search Tree）是一种常见的二叉树数据结构，它的每个节点都包含一个关键字，且每个节点的关键字都大于其左子树中任意节点的关键字，小于其右子树中任意节点的关键字。

这种特性使得搜索二叉树非常适合用于查找操作。在搜索二叉树中查找一个元素时，我们可以从根节点开始，如果当前节点的值等于要查找的值，则查找成功；如果当前节点的值大于要查找的值，则在左子树中继续查找；如果当前节点的值小于要查找的值，则在右子树中继续查找.

搜索二叉树还有一些其他的性质，例如：对于一棵有n个节点的搜索二叉树，它的高度不会超过log(n) . 这些性质使得搜索二叉树在计算机科学中有着广泛的应用，例如在数据库索引、编译器符号表等领域。

如下就是一个二叉搜索树：

二，搜索二叉树的实现 

这里主要指的是实现而二叉树的增删查，搜索二叉树不能被修改。

非递归实现

根据搜索二叉树的特性，实现也是好比较实现的：

到了删除，这个是比较麻烦的，因为我们不能直接删除这个节点，若为叶子节点还好，但凡这个节点但有两个孩子，删除直接会破坏搜索二叉树的结构，那么如何删除。

用如下的搜索二叉树为例：

情况一：首先对于叶子节点我们找到后可以直接删除

情况二：删除的节点左子树为空，右子树不为空

如这里的节点10，我们可以将它的孩子托付给它的父亲，即链接8节点的right与14节点，删除节点10。

情况三：删除的节点右子树为空，左子树不为空

情况三与情况四的方法类似，还是用它的父亲节点管理它的孩子节点。

情况四：删除的节点右子树，左子树都不为空

如这里删除节点3，上述思路就不行了。

解决办法：替换法   

所谓替换法就是去找一个其他节点来接管我们的孩子，如删除节点3，我么可以看到节点4可以替换3，节点1也可以替换3，虽然他也是这里的子节点，当然节点6理论可以，但它自身也有孩子。

或者删除节点8为例，我们必须要找到一个比8节点左边都大的，且比右边的每个数最小

总结：因此我们可以选择已该节点为起点，它的左子树中最大的节点（左边最大）节点4，右子树中最小（左子树中最右节点）节点7，这两个都可以是我们替换的对象是最为合适的。

节点与类成员

//结点的定义
templatestruct BSTreeNOde
{
	BSTreeNOde(const k& key) :_left(nullptr),_right(nullptr)
	{
		this->key = key;
	}
	BSTreeNOde* _left;
	BSTreeNOde* _right;
	k key;
};
templateclass BSTree
{
public:
typedef BSTreeNOde  Node;//搜索二叉树的节点
//成员函数......
private:
	Node* _root=nullptr;
}

插入

//节点插入
bool insert(const k& key)
{
	if (_root == nullptr)
	{
		_root = new Node(key);
		return true;
	}
	Node* cur = _root;
	Node* parent = nullptr;
	while (cur)
	{
		if (key < cur->key)
		{
			parent = cur;
			cur = cur->_left;
		}
		else if (key > cur->key)
		{
			parent = cur;
			cur = cur->_right;
		}
		else
		{
			//相等就不枉搜索二叉树里插入了
			return false;
		}
	}
    //cur为空的时候，即找到了合适的位置，就可以插入了
    cur = new Node(key);
	//链接
	if (key > parent->key)
	{
		parent->_right = cur;
	}
	else
	{
		parent->_left = cur;
	}
	return true;
}

查找

//查找
bool find(const k key)
{
	if (_root == nullptr)
	{
		return false;
	}
	Node* cur = _root;
	while (cur)
	{
		if (key > cur->key)
		{
			cur = cur->_right;
		}
		else if (key > cur->key)
		{
			cur = cur->left;
		}
		else
		{
			return true;
		}

	}
	return false;
}

删除

对于上述分析的情况，情况一就是情况二或情况三的一种，全空可以为左为空或者右为空。

不为空时，我们这里选择替换右子树中的最小值：

对于删除，我们这里断开和删除节点的链接即可，其次对于为空时，我们这里选择替换右子树中的最小值是分两种情况的：当我们的的右子树的第一个节点的左子树是否为空，不为空，我们去一直找最左边的，左子树为空，那么最小的就是第一个右子树节点。

//删除节点
bool Erase(const k& key)
{
	Node* parent = nullptr;
	Node* cur = _root;
	while (cur)
	{
		if (key > cur->key)
		{
			parent = cur;
			cur = cur->_right;
		}
		else if (key < cur->key)
		{
			parent = cur;
			cur = cur->_left;
		}
		else
		{
			//开始删除 
			//叶子节点可以当作左为空或这右为空处理

			//左为空
			if (cur->_left == nullptr)
			{
				//先判断删除的节点是否为根节点
				if (cur == _root)
				{
					//直接用孩子替换为新的根节点
					_root = cur->_right;
				}
				else
				{
					//直接让它的父亲指向它的右孩子
					if (cur == parent->_right)
					{
						parent->_right = cur->_right;
					}
					else
					{
						parent->_left = cur->_right;
					}
				}
			}
			else if (cur->_right == nullptr)
				//右为空
			{
				if (cur == _root)
				{
					//直接用孩子替换为新的根节点
					_root = cur->_left;
				}
				else
				{
					//直接让它的父亲指向它的右孩子
					if (cur == parent->_right)
					{
						parent->_right = cur->_left;
					}
					else
					{
						parent->_left = cur->_left;
					}
				}
			}
			//左右都不为空
			else
			{
				//对于这里左子树的最大（最右），右子树的最小（最左）这两个节点都可以被我们所替换

				//找右树的最小节点（最左）
				Node* subleft = cur->_right;
				Node* parent = cur;
				if (subleft == nullptr)
				{

					cur->_left;
				}
				while (subleft->_left)
				{
					parent = subleft;
					subleft = subleft->_left;
				}
				swap(cur->key, subleft->key);
				//此时subleft的右子树不一定为空  或者 在寻找前此时的左子树整个为空，用他的右子树链接
				if (subleft == parent->_left)
				{
					parent->_left = subleft->_right;
				}
				else
				{
					parent->_right = subleft->_right;
				}
			}
			return true;
		}
	}
	return false;

}

 递归实现

对于增删查，不仅仅可以通过循环，我们也可以通过递归实现

递归实现时，我们可以直接传root的引用，无需用cur来遍历，不过我们需要内部下一个函数来访问到我们的root。利用root的引用，再增加和删除时，递归到该位置我们可直接改变这个节点。

插入

插入的主要过程就是递归左右子树遍历直到此时的root为空，就可插入，return true。否则false。

bool insertR(const k& key)
	{
		return _insertR(key, _root);
	}
	bool _insertR(const k& key, Node*& root)
	{
		if (root == nullptr)
		{
			//递归直到此时为空，链接
			root = new Node(key);
			return true;
		}
		if (root)
		{
			if (key < root->key)
			{
				return _insertR(key, root->_left);
			}
			else if (key > root->key)
			{
				return _insertR(key, root->_right);
			}
			else
			{
				//相等就不往搜索二叉树里插入了
				return false;
			}
		}
	}

查找

原理同上，递归的左右子树，遍历找我们需要的元素。

bool findR(const k& key)
	{
		return _findR(_root,key);
	}
	bool _findR(Node* root, const k& key)
	{
		if (root == nullptr)
		{
			return false;
		}

		if (root->key < key)
		{
			return _findR(root->_right, key);
		}
		else if (root->key > key)
		{
			return _findR(root->_left, key);
		}
		else
		{
			return true;
		}
	}

 删除

因为循环时无法复用我们在当左子树右子树都不为空时，我们去找右子树的最小值，即右树的最左值，循环右数的左子树的最左直到为空，交换之后，开始删除，我们想要服用左子树为空的删除问题，但此时的父亲不一样，我们不能去服用。

但对于递归，当我们要去找右子树的最左孩子，找到之后交换，然后变成子问题递归，左子树为空删除。

bool EraseR(const k& key)
	{
		_EraseR(_root, key)
	}
	bool _EraseR(Node*& root, const k& key)
	{
		if (root == nullptr)
			return false;
	
		if (root->_key < key)
		{
			return _EraseR(root->_right, key);
		}
		else if (root->_key > key)
		{
			return _EraseR(root->_left, key);
		}
		else
		{
			// 删除
			if (root->_left == nullptr)
			{
				Node* del = root;
				root = root->_right;
				delete del;
	
				return true;
	
			}
			else if (root->_right == nullptr)
			{
				Node* del = root;
				root = root->_left;
				delete del;
	
				return true;
			}
			else
			{
				Node* subLeft = root->_right;
				while (subLeft->_left)
				{
					subLeft = subLeft->_left;
				}
	
				swap(root->_key, subLeft->_key);
	
				// 转换成在子树去递归删除
				return _EraseR(root->_right, key);
			}
		}