C++数据结构（搜索二叉树）

1.二叉树搜索的概念

二叉搜索数也成为二叉排序树，它或者是一颗空树，或者是满足以下性质的树：
1.若他的左子树不为空，则左子树上的所有节点的值都小于等于根节点的值。
2.若他的右子树不为空，则右子树上的所有节点的值都大于等于根节点的值。
3.他的左右子树也都是搜索二叉树。
4.二叉搜索树中支持插入相等的值，也可以不支持插入相等的值，具体看使用场景定义。

我们这里实现的是不支持同一值插入的搜索二叉树

1.1搜索二叉树的性能分析

所以在搜索二叉树中，我们如果要找一个值的话，如果需要找的值，比根节点小就向左子树寻找，如果比根节点大我们就去右子树找。这样的话我们查找的次数都是树的高度。
不过我们要注意的是，如果在极端情况下，搜索二叉树会退化成链表的情况，这样的话我们的时间复杂度就成了O(N)的状态了。

左边接近满二叉树时性能可以到O(logN)。右边这种时极端的情况下，这样我们只有O(N)的时间复杂度了。

2.搜索二叉树的实现

2.1定义二叉树的结构

因为二叉树的每个节点不仅仅只储存一个数值，还需要储存孩子节点的地址，所以我们需要定义每个节点的结构：

#pragma once
#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)
	{}
};

这里我们为了应对不同的数据类型我们使用一个模板参数来构建节点，这样我们的节点中的值不仅可以存储整形，还可以存储字符等等。

2.2搜索二叉树的插入（简单）

首先我们这里写搜索二叉树我们直接封装一个类，这里using的作用跟typedef作用相同，在这里用来重命名节点名称，简化代码，后面我们可以直接使用Node即可。

template <class K>
class BSTree
{
	//typedef BSTNode<K> Node;
	using Node = BSTNode<K>;
private:
	Node* _root=nullptr;
};

再插入二叉树节点的时候我们这里首先判断树中有没有节点，如果没有我们这里传进来的值直接充当根节点。
我们这里没有选择使用递归算法，使用简单的循环便可解决问题。

public:
	bool insert(const K& key)
	{
		if (_root == nullptr)
		{
			_root = new Node(key);
			return true;
		}
		Node* parent = nullptr;//这个parent指针用来记录cur节点的父亲节点方便我们进行插入操作
		Node* cur = _root;//定义cur指针用来找到插入节点的位置

		while (cur)//循环主题逻辑
		{
			if (cur->_key< key)
			{
				parent = cur;//cur每次寻找都需要更新parent指针
				cur = cur->_right;
			}
			else if (cur->_key > key) {
				parent = cur;
				cur = cur->_left;
			}
			else {
				//因为我们实现的是不支持相同值的插入，所以这里相同时直接返回false
				return false;
			}
		}
		cur = new Node(key);//最后作比较选择插入左边或者右边
		if (parent->_key < key) { parent->_right = cur; }
		else { parent->_left = cur; }
		return true;
	}

为了验证我们的插入代码的正确性，这里我们先写一个中序遍历进行测试

private:
	void _Inorder(Node* root)
	{
		if (root == nullptr)
			return;
		_Inorder(root->_left);
		cout << root->_key << " ";
		_Inorder(root->_right);
	}

因为在类中，如果我们需要对树这类结构进行递归调用，我们都是需要根节点，而为了程序的安全性，根节点是存在树类中的private属性中的，所以这个时候我们用一个办法可以完美的解决。就是在类中public中定义一个Inorder函数，在类中去调用_Inorder函数，在外部直接调用Inorder函数，这样就不存在访问不到的问题了。

#pragma once
#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)
	{}
};

template <class K>
class BSTree
{
	//typedef BSTNode<K> Node;
	using Node = BSTNode<K>;
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;
};

测试函数test.c的代码：

#include"BinarySearch.h"

int main()
{
	int a[] = {14,5,69,45,24,78 };
	BSTree<int> t;
	for (auto e : a)
	{
		t.insert(e);
	}
	t.Inorder();
	return 0;
}

以上就是基本结构和插入操作加上测试代码的完整版（这里是为了让大家看到定义的结构体和类的写法），这里我们来看看运行结果：

根据我们的中序输出的规则是完美契合的，所以我们的插入排序暂时写完。

2.3搜索二叉树的查找（简单）

查找对于插入来说，更加简单，因为插入我们也是一种查找的过程，根据搜索二叉树的规则进行插入。
**实现原理：**这里我们跟插入的思路差不多，定义一个cur指针，一直向下寻找，找到返回当前节点指针，否则返回空。

Node* 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 cur;
		}
	}
	return nullptr;
}

在主函数中写个测试函数调用一下：

if (!t.Find(2))
{
	cout << "nullptr" << endl;
}
else
	cout << t.Find(2)->_key << endl;

if (!t.Find(14))
{
	cout << "nullptr" << endl;
}
else
	cout << t.Find(14)->_key << endl;

以上是两个用例，一个是输入的2，我们的树中并没有这个值，所以打印nullptr，输入14，便会打印出来。

2.4搜索二叉树的删除（微难）

搜索二叉树最难的应该就是在这个删除，因为父子节点不仅关系紧密，而且还有他特定的规则，这里我们对于二叉搜索树的删除总结了几个点。
这里我们假设要删掉的节点是（N）

1.要删除的节点N左右孩子均为空，这个时候我们把N节点的父节点对应只想N节点的指针置为空，同时直接N删除节点。
2.要删除的节点N左孩子为空，右孩子不为空，此时把N节点的父亲节点对该孩子的指针指向N的右孩子，同时直接删除N节点。
3.要删除的节点N右孩子为空，左孩子不为空，此时把N节点的父亲节点对该孩子的指针指向N的左孩子，同时直接删除N节点。
4.要删除的孩子左右节点均不为空，此时使用代替删除法，我们找到以N为根节点的左子树中的最大值，或者找以N为根节点的右子树中的最小值来代替N，因为这两个一个是左子树中最大值和右子树最小值，替换后依旧符合搜索二叉树的规则。替换后我们再进行循环对比，如果符合1，2，3这三个情况则可以直接删除。

直接上代码在代码中会有表明注释：

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
		{
			//来到这里说明我们已经找到需要删除的节点
			if (cur->_left == nullptr)
			{
			//这里我们处理上面的第2条，左孩子为空。
			//要记得处理的是如果要删除的是根节点，并且没有左孩子，我们直接将根节点的第一个右孩子置为根节点
				if (cur == _root)
				{
					_root = _root->_right;
				}
				else {
				//如果不是根节点这个时候我们判断一下要删除的节点是父节点的左孩子还是右孩子，随后将孩子“过继”给父节点
					if (parent->_left == cur)
					{
						parent->_left = cur->_right;
					}
					else
					{
						parent->_left = cur->_right;
					}
				}
				delete cur;
			}
			else if (cur->_right == nullptr)
			{
			//这里是要删除的节点没有右孩子，跟上同理。
				if (cur == _root)
				{
					_root = _root->_left;
				}
				else {
					if (parent->_left == cur)
					{
						parent->_left = cur->_left;
					}
					else
					{
						parent->_right = cur->_left;
					}
				}
				delete cur;
			}
			else
			{
			//这里就是最复杂的左右都有孩子的情况
				Node* parents = cur;//一样的，只要不是连续的空间我们在对节点操作时需要保留上一个节点的位置
				//这里有两个选择上面我们介绍到了，要不然用左子树的最大节点或者是右子树的最小节点
				Node* tmp = cur->_left;
				while (tmp->_right)
				{
				//这里我们选择找到左边的最大节点
					parents = tmp;
					tmp = tmp->_right;
				}
				//找到后将tmp节点的值赋给需要删除的节点/
				cur->_key = tmp->_key;
				//这里跟上面删除节点同理，直接删掉就好
				if (parents->_left == tmp)
				{
					parents->_left = tmp->_left;
				}
				else
				{
					parents->_right = tmp->_left;
				}
				//记得释放空间
				delete tmp;
			}
			return true;
		}
	}
	return false;
}

完全体代码展示（测试代码可以自己去写）

#pragma once
#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)
	{}
};

template <class K>
class BSTree
{
	//typedef BSTNode<K> Node;
	using Node = BSTNode<K>;
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;
	}

	Node* 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 cur;
			}
		}
		return nullptr;
	}

	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
			{
				
				if (cur->_left == nullptr)
				{
					if (cur == _root)
					{
						_root = _root->_right;
					}
					else {
						if (parent->_left == cur)
						{
							parent->_left = cur->_right;
						}
						else
						{
							parent->_left = cur->_right;
						}
					}
					delete cur;
				}
				else if (cur->_right == nullptr)
				{
					if (cur == _root)
					{
						_root = _root->_left;
					}
					else {
						if (parent->_left == cur)
						{
							parent->_left = cur->_left;
						}
						else
						{
							parent->_right = cur->_left;
						}
					}
					delete cur;
				}
				else
				{
					Node* parents = cur;
					Node* tmp = cur->_left;
					while (tmp->_right)
					{
						parents = tmp;
						tmp = tmp->_right;
					}
					cur->_key = tmp->_key;
					if (parents->_left == tmp)
					{
						parents->_left = tmp->_left;
					}
					else
					{
						parents->_right = tmp->_left;
					}
					delete tmp;
				}
				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;
};

#include"BinarySearch.h"

int main()
{
	int a[] = {14,5,69,45,24,78 };
	BSTree<int> t;
	for (auto e : a)
	{
		t.insert(e);
	}
	t.Inorder();
	t.Erase(5);
	t.Inorder();

	return 0;
}

代码测试完全体测试结果：

删除成功！
到此，简单的搜索二叉树已经结束~