搜索二叉树模拟实现

前言

大家好，我是jiantaoyab，在学习map和set之前，先来认识一下BST，搜索二叉树（Binary Search Tree，简称BST）是一种特殊的二叉树，它的每个节点都包含一个可比较的键（key）以及相关联的值。对于树中的每个节点X，其左子树中所有节点的键都小于X的键，而其右子树中所有节点的键都大于X的键。搜索二叉树的主要应用之一是高效地查找、插入和删除数据项。

搜索二叉树的特性

1. 左子树特性：如果左子树不为空，则左子树上所有节点的值均小于它的根节点的值。
2. 右子树特性：如果右子树不为空，则右子树上所有节点的值均大于它的根节点的值。
3. 中序遍历：对搜索二叉树进行中序遍历（左-根-右）会得到一个递增的有序序列。

搜索二叉树的性能

搜索二叉树的性能取决于树的结构。在最坏的情况下（树退化为链表），搜索、插入和删除操作的时间复杂度为O(n)，其中n是树中节点的数量。然而，在平均情况下（树保持相对平衡），这些操作的时间复杂度为O(log n)，这使得搜索二叉树成为一种高效的数据结构。为了保持搜索二叉树的平衡，可以使用平衡搜索树（如AVL树、红黑树等），这些树在插入和删除节点时会自动调整以保持平衡。

搜索二叉树模拟实现

BSTReeNode

struct BSTreeNode
{
	BSTreeNode<K>* _left;
	BSTreeNode<K>* _right;
	K _key;

	BSTreeNode(const K& key)
		:_left(nullptr)
		, _right(nullptr)
		, _key(key)
	{}
};

BSTree插入

1. 从根节点开始。
2. 如果树为空，创建一个新节点作为根节点。
3. 如果要插入的键等于当前节点的键，返回false
4. 如果要插入的键小于当前节点的键，在左子树中插入（递归）。
5. 如果要插入的键大于当前节点的键，在右子树中插入（递归）。

//迭代版本
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->_left;
			}
			else if (cur->_key < key)
			{
				parent = cur;
				cur = cur->_right;
			}
			else return false;
		}
		//开始插入新节点
		cur = new Node(key);
		if (parent->_key > cur->_key) parent->_left = cur;
		else parent->_right = cur;
		return true;
	}

//递归版本
bool InsertR(const K& key)
{
	return _InsertR(_root, key);
}

bool _InsertR(Node* &root, const K& key)
{
		if (root == nullptr)
		{
			root = new Node(key);
			return true;
		}
		if (root->_key < key)
		{
			return _InsertR(root->_right, key);
		}
		else if(root->_key > key)
		{
			return _InsertR(root->_left, key);
		}
		else 
			return false;
}

---

BSTree删除

1. 从根节点开始。
2. 如果要删除的节点没有子节点或只有一个子节点，直接删除。
3. 如果要删除的节点有两个子节点，则找到其右子树中的最小节点（或左子树中的最大节点），用该节点的值替换要删除的节点的值，然后删除该最小（或最大）节点。

//迭代版本
bool erase(const K& key)
	{
		Node* parent = nullptr;
		Node* cur = _root;
		while(cur)
		{
			if (cur->_key > key)
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (cur->_key < key)
			{
				parent = cur;
				cur = cur -> _right;
			}
			//找到了
			else
			{
				//只有右孩子
				if (cur->_left == nullptr)
				{
					
					if (parent == nullptr) _root = cur->_right; //细节
					else
					{
						if (parent->_left == cur)
						{
							parent->_left = cur->_right;
						}
						else
						{
							parent->_right = cur->_right;
						}
					}
					
					delete cur;
				}
				//只有左孩子
				else if (cur->_right == nullptr)
				{
					if (parent == nullptr) _root = cur->_left;
					else
					{
						if (parent->_left == cur)
						{
							parent->_left = cur->_left;
						}
						else
						{
							parent->_right = cur->_left;
						}
					}		
					delete cur;
				}
				//一个孩子都没
				else
				{
					//找到右子树的最左节点
					Node* r_mid = cur->_right;
					Node* p_r_mid = cur;
					while (r_mid->_left)
					{
						p_r_mid = r_mid;
						r_mid = r_mid->_left;
					}
					//找到了替换
					cur->_key = r_mid->_key;
					if (p_r_mid->_left == r_mid) p_r_mid->_left = r_mid->_right;
					else p_r_mid->_right = r_mid->_right;
					delete r_mid;
				}
				return true;
			}
			
		}
		return false;
	}



//递归版本
bool EraseR(const K& key)
{
		return _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
		{
			//找到
			Node* del = root;
			if (root -> _left == nullptr) root = root->_right;
			else if (root->_right == nullptr) root = root->_left;
			else
			{
				Node* min = root->_right;
				while (min->_left) min = min->_left;
				std::swap(min->_key, root->_key); //交换
				//递归到右边去删除
				return _EraseR(root->_right, key);
			}
			delete del;
			return true;
		}
		
	}

总体代码

#pragma once
#include<iostream>
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:
	bool erase(const K& key)
	{
		Node* parent = nullptr;
		Node* cur = _root;
		while(cur)
		{
			if (cur->_key > key)
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (cur->_key < key)
			{
				parent = cur;
				cur = cur -> _right;
			}
			//找到了
			else
			{
				//只有右孩子
				if (cur->_left == nullptr)
				{
					
					if (parent == nullptr) _root = cur->_right; //细节
					else
					{
						if (parent->_left == cur)
						{
							parent->_left = cur->_right;
						}
						else
						{
							parent->_right = cur->_right;
						}
					}
					
					delete cur;
				}
				//只有左孩子
				else if (cur->_right == nullptr)
				{
					if (parent == nullptr) _root = cur->_left;
					else
					{
						if (parent->_left == cur)
						{
							parent->_left = cur->_left;
						}
						else
						{
							parent->_right = cur->_left;
						}
					}		
					delete cur;
				}
				//一个孩子都没
				else
				{
					//找到右子树的最左节点
					Node* r_mid = cur->_right;
					Node* p_r_mid = cur;
					while (r_mid->_left)
					{
						p_r_mid = r_mid;
						r_mid = r_mid->_left;
					}
					//找到了替换
					cur->_key = r_mid->_key;
					if (p_r_mid->_left == r_mid) p_r_mid->_left = r_mid->_right;
					else p_r_mid->_right = r_mid->_right;
					delete r_mid;
				}
				return true;
			}
			
		}
		return false;
	}
	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->_left;
			}
			else if (cur->_key < key)
			{
				parent = cur;
				cur = cur->_right;
			}
			else return false;
		}
		//开始插入新节点
		cur = new Node(key);
		if (parent->_key > cur->_key) parent->_left = cur;
		else parent->_right = cur;
		return true;
	}

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

	bool InsertR(const K& key)
	{
		return _InsertR(_root, key);
	}
	bool EraseR(const K& key)
	{
		return _EraseR(_root, key);
	}
	//Node* &root 加了&就不需要再增加一个父节点
	bool _InsertR(Node* &root, const K& key)
	{
		if (root == nullptr)
		{
			root = new Node(key);
			return true;
		}
		if (root->_key < key)
		{
			return _InsertR(root->_right, key);
		}
		else if(root->_key > key)
		{
			return _InsertR(root->_left, key);
		}
		else 
			return false;
	}
	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
		{
			//找到
			Node* del = root;
			if (root -> _left == nullptr) root = root->_right;
			else if (root->_right == nullptr) root = root->_left;
			else
			{
				Node* min = root->_right;
				while (min->_left) min = min->_left;
				std::swap(min->_key, root->_key); //交换
				//递归到右边去删除
				return _EraseR(root->_right, key);
			}
			delete del;
			return true;
		}
		
	}
public:
	BSTree()
		:_root(nullptr)
	{}

private:
	Node*  _root;
};