【C++】二叉搜索树的概念与实现

二叉搜索树

概念

key类型

概念

代码实现

key_value类型

概念

代码实现

二叉搜索树

概念

⼆叉搜索树⼜称⼆叉排序树，它或者是⼀棵空树，或者是具有以下性质的⼆叉树: 左子树的值默认小于根节点，右子树的值默认大于根节点。

⼆叉搜索树中可以⽀持插⼊相等的值，也可以不⽀持插⼊相等的值，具体看使⽤场景定义：map/set/multimap/multiset系列容器底层就是⼆叉搜索树，其中map/set不⽀持插⼊相等值，multimap/multiset⽀持插⼊相等值。

二叉搜索树的查找时间复杂度在O(logN)~O(N)

key类型

概念

我们购买了一个停车场的位置，每次开车入库时安保会检测我们的车牌号释放存入后台，如果存在抬杆放行。

Key用于标识，不可以修改，否则会破坏树的性质！

代码实现

单个节点的定义

template<class K>
class BTNode
{
public:
	K _key;
	// 左右节点
	BTNode<K>* _left;
	BTNode<K>* _right;
	BTNode(const K& data)
		:_key(data)
		,_left(nullptr)
		,_right(nullptr)
	{}
};

构造

默认构造：使用默认的即可
拷贝构造：注意需要深拷贝

Node* Copy(Node* root)
{
	if (root == nullptr)
		return nullptr;
	Node* newRoot = new Node(root->_key, root->_value);
	newRoot->_left = Copy(root->_left);
	newRoot->_right = Copy(root->_right);

	return newRoot;
}

赋值重载

BSTree<K, V>& operator=(BSTree<K, V> tmp)
{
	swap(_root, tmp._root);
	return *this;
}

析构

走后序遍历进行析构delete

void Destory(Node* _root)
{
	if (_root == nullptr)
		return;
	Destory(_root->_left);
	Destory(_root->_right);
	delete _root;
}

Insert

bool Insert(const K& key)
{
	// 空树
	if (_root == nullptr)
	{
		_root = new Node(key);
		return true;
	}
	Node* cur = _root;
	Node* parent = cur;
	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;
}

Find

与Insert同理，大往右，小往左，相等返回true，找到结束没有返回false

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;
}

Erase

【1】先找到要删除的数据

存在：执行第二步【2】
不存在返回false

【2】删除数据的多种情况

【1】情况一：0/1个孩子

左节点为nullptr

右节点为nullptr

【2】情况二：2个孩子

bool Erase(const K& key)
{
	Node* cur = _root;
	Node* parent = cur;
	while (cur)
	{
		if (cur->_key < key)
		{
			parent = cur;
			cur = cur->_right;
		}
		else if (cur->_key > key)
		{
			parent = cur;
			cur = cur->_left;
		}
		else {
			// 删除
			// 情况1: 删除0/1个孩子的节点
			if (cur->_left == nullptr)
			{
				// 特殊情况
				if (cur == _root)
				{
					_root = cur->_right;
				}
				// 左孩子为空
				if (parent->_left == cur)
				{
					parent->_left = cur->_right;
				}
				else {
					parent->_right = cur->_right;
				}
				delete cur;
				return true;
			}
			else if (cur->_right == nullptr)
			{
				// 特殊情况
				if (cur == _root)
				{
					_root = cur->_left;
				}
				// 右孩子为空
				if (parent->_left == cur)
				{
					parent->_left = cur->_left;
				}
				else {
					parent->_right = cur->_left;
				}
				delete cur;
				return true;
			}
			else {
				// 左右都存在孩子
				Node* replace_parent = cur;
				Node* replace = cur->_right;
				// 右子树的最左节点
				while (replace->_left)
				{
					replace_parent = replace;
					replace = replace->_left;
				}
				cur->_key = replace->_key;
				if (replace_parent->_left == replace)
					replace_parent->_left = replace->_right;
				else
					replace_parent->_right = replace->_right;
				delete replace;
				return true;
			}
		}
	}
	return false;
}

整体代码实现：

namespace Key
{
	// 二叉搜索树
	// 只存在增删查,没有改,改会破坏二叉搜索树的性质
	// 每个节点结构
	template<class K>
	class BTNode
	{
	public:
		K _key;
		// 左右节点
		BTNode<K>* _left;
		BTNode<K>* _right;
		BTNode(const K& data)
			:_key(data)
			,_left(nullptr)
			,_right(nullptr)
		{}
	};

	template<class K>
	class BSTree
	{
		using Node = BTNode<K>;
	public:
		BSTree() = default;

		BSTree(const BSTree<K>& t)
		{
			_root = Copy(t._root);
		}

		BSTree<K>& operator=(BSTree<K> tmp)
		{
			swap(_root, tmp._root);
			return *this;
		}

		~BSTree()
		{
			Destory(_root);
			_root = nullptr;
		}

		bool Insert(const K& key)
		{
			// 空树
			if (_root == nullptr)
			{
				_root = new Node(key);
				return true;
			}
			Node* cur = _root;
			Node* parent = cur;
			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* cur = _root;
			Node* parent = cur;
			while (cur)
			{
				if (cur->_key < key)
				{
					parent = cur;
					cur = cur->_right;
				}
				else if (cur->_key > key)
				{
					parent = cur;
					cur = cur->_left;
				}
				else {
					// 删除
					// 情况1: 删除0/1个孩子的节点
					if (cur->_left == nullptr)
					{
						// 特殊情况
						if (cur == _root)
						{
							_root = cur->_right;
						}
						// 左孩子为空
						if (parent->_left == cur)
						{
							parent->_left = cur->_right;
						}
						else {
							parent->_right = cur->_right;
						}
						delete cur;
						return true;
					}
					else if (cur->_right == nullptr)
					{
						// 特殊情况
						if (cur == _root)
						{
							_root = cur->_left;
						}
						// 右孩子为空
						if (parent->_left == cur)
						{
							parent->_left = cur->_left;
						}
						else {
							parent->_right = cur->_left;
						}
						delete cur;
						return true;
					}
					else {
						// 左右都存在孩子
						Node* replace_parent = cur;
						Node* replace = cur->_right;
						// 右子树的最左节点
						while (replace->_left)
						{
							replace_parent = replace;
							replace = replace->_left;
						}
						cur->_key = replace->_key;
						if (replace_parent->_left == replace)
							replace_parent->_left = replace->_right;
						else
							replace_parent->_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);
		}

		void Destory(Node* _root)
		{
			if (_root == nullptr)
				return;
			Destory(_root->_left);
			Destory(_root->_right);
			delete _root;
		}

		Node* Copy(Node* root)
		{
			if (root == nullptr)
				return nullptr;
			Node* newRoot = new Node(root->_key);
			newRoot->_left = Copy(root->_left);
			newRoot->_right = Copy(root->_right);

			return newRoot;
		}

		Node* _root = nullptr;
	};
}

key_value类型

概念

我们统计一个书中相同单词的个数，Key就是这个单词，而value表示单词的个数。

Key用于标识不可以修改，但是我们可以修改value。

代码实现

单个节点的定义

template<class K, class V>
class BTNode
{
public:
	K _key;
	V _value;
	// 左右节点
	BTNode<K, V>* _left;
	BTNode<K, V>* _right;
	BTNode(const K& key, const V& value)
		:_key(key)
		,_value(value)
		, _left(nullptr)
		, _right(nullptr)
	{}
};

整体代码实现：

namespace Key_value
{
	// 二叉搜索树
	// 只存在增删查,没有改,改会破坏二叉搜索树的性质
	// 每个节点结构
	template<class K, class V>
	class BTNode
	{
	public:
		K _key;
		V _value;
		// 左右节点
		BTNode<K, V>* _left;
		BTNode<K, V>* _right;
		BTNode(const K& key, const V& value)
			:_key(key)
			,_value(value)
			, _left(nullptr)
			, _right(nullptr)
		{}
	};

	template<class K, class V>
	class BSTree
	{
		using Node = BTNode<K, V>;
	public:
		BSTree() = default;

		BSTree(const BSTree<K, V>& t)
		{
			_root = Copy(t._root);
		}

		BSTree<K, V>& operator=(BSTree<K, V> tmp)
		{
			swap(_root, tmp._root);
			return *this;
		}

		~BSTree()
		{
			Destory(_root);
			_root = nullptr;
		}

		bool Insert(const K& key, const V& value)
		{
			// 空树
			if (_root == nullptr)
			{
				_root = new Node(key, value);
				return true;
			}
			Node* cur = _root;
			Node* parent = cur;
			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, value);
			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 = cur;
			while (cur)
			{
				if (cur->_key < key)
				{
					parent = cur;
					cur = cur->_right;
				}
				else if (cur->_key > key)
				{
					parent = cur;
					cur = cur->_left;
				}
				else {
					// 删除
					// 情况1: 删除0/1个孩子的节点
					if (cur->_left == nullptr)
					{
						// 特殊情况
						if (cur == _root)
						{
							_root = cur->_right;
						}
						// 左孩子为空
						if (parent->_left == cur)
						{
							parent->_left = cur->_right;
						}
						else {
							parent->_right = cur->_right;
						}
						delete cur;
						return true;
					}
					else if (cur->_right == nullptr)
					{
						// 特殊情况
						if (cur == _root)
						{
							_root = cur->_left;
						}
						// 右孩子为空
						if (parent->_left == cur)
						{
							parent->_left = cur->_left;
						}
						else {
							parent->_right = cur->_left;
						}
						delete cur;
						return true;
					}
					else {
						// 左右都存在孩子
						Node* replace_parent = cur;
						Node* replace = cur->_right;
						// 右子树的最左节点
						while (replace->_left)
						{
							replace_parent = replace;
							replace = replace->_left;
						}
						cur->_key = replace->_key;
						if (replace_parent->_left == replace)
							replace_parent->_left = replace->_right;
						else
							replace_parent->_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 << ":" << _root->_value << endl;
			_InOrder(_root->_right);
		}

		void Destory(Node* _root)
		{
			if (_root == nullptr)
				return;
			Destory(_root->_left);
			Destory(_root->_right);
			delete _root;
		}

		Node* Copy(Node* root)
		{
			if (root == nullptr)
				return nullptr;
			Node* newRoot = new Node(root->_key, root->_value);
			newRoot->_left = Copy(root->_left);
			newRoot->_right = Copy(root->_right);

			return newRoot;
		}

		Node* _root = nullptr;
	};
}