C++实现二叉搜索树

原创 已于 2025-02-26 20:08:00 修改 · 740 阅读 · 16 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c++ #二叉搜索树 #c语言

于 2024-11-21 11:03:39 首次发布

C++教学总目录

二叉搜索树

1、二叉搜索树的概念

二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树:
1、若它的左子树不为空，则左子树上所有结点的值都小于等于根结点的值
2、若它的右子树不为空，则右子树上所有结点的值都大于等于根结点的值
3、它的左右子树也分别为二叉搜索树

二叉搜索树中可以支持插入相等的值，也可以不支持插入相等的值，具体看使用场景定义，后续我们学习map/set/multimap/multiset系列容器底层就是二叉搜索树，其中map/set不支持插入相等值，multimap/multiset支持插入相等值。
如图就是一颗二叉搜索树：
在这里插入图片描述

2、二叉搜索树性能分析

如下两颗二叉搜索树：
在这里插入图片描述
如图，正常情况下的二叉搜索树高度应该为logN，但极端情况下将会退化成链表，高度为N。
因此二叉搜索树的查找效率为O(N)。二分查找也可以实现logN级别的查找，但是二分查找需要数据有序，并且插入和删除数据效率很低。这里就体现出二叉搜索树的价值了。
但是极端情况下可能退化为链表，所以就有了二叉平衡搜索树（AVL树、红黑树等），这个我们后面会讲。另外map和set的底层就是红黑树，后面我们也是要模拟实现map和set的。
所以在一般情况下，使用二叉搜索树来进行插入删除查找效率还是比较可以的，如果退化成链表就需要我们后面的二叉平衡搜索树了。

3、二叉搜索树的实现

二叉搜索树的实现我会提供两个版本：递归和非递归，递归版本会更好写，但是难理解一些。递归版本会在每个函数名字后面加上R，代表这是递归版本。

3.1、结点和成员变量

namespace key
{
	template<class K>
	struct BSTreeNode
	{
		BSTreeNode<K>* _left;
		BSTreeNode<K>* _right;
		K _key;
		BSTreeNode(const K& key = K())
			:_left(nullptr)
			, _right(nullptr)
			, _key(key)
		{}
	};

	template<class K>
	class BSTree
	{
		typedef BSTreeNode<K> Node;
	public:
		BSTree()
		:_root(nullptr)
		{}
	private:
		Node* _root;
	};
}

3.2、二叉搜索树的查找

查找的递归和非递归都很好写。对于递归版本，我们需要多提供一个参数来判断当前结点的值和要查找的值，如果比要查找的值小，就递归到右子树，如果比要查找的值大，就递归到左子树。循环也是如此。代码如下：

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 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);
	return true;
}

由于FindR递归需要一个Node*的指针，所以在FindR中调用_FindR来实现。后面也是如此。

3.3、二叉搜索树的插入

插入的非递归版本还是比较好写的，一直迭代找到空结点，然后new一个新结点，让父节点指向新结点即可。
但是递归版本如果只传当前结点指针的话无法实现，因为找到位置new出新结点后还需要让父节点指向新节点，所以可以在参数中添加一个父节点的参数，或者直接使用指针的引用，这里可以好好理解一下，如果不使用指针的引用也可以使用二级指针。

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

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);
	if (root->_key > key) return _InsertR(root->_left, key);
	return false;
}

在这里插入图片描述

3.4、二叉搜索树的删除

二叉搜索树的删除比较复杂，需要考虑几种情况：
1、当前结点的左孩子或右孩子为空，这时候直接让父节点的孩子指向当前的右孩子或左孩子即可。不过需要特判当当前结点是根节点的情况。
2、当前结点的左右孩子都不为空，这时候需要寻找替代结点，有两种方式：寻找左子树的最大（最右）结点进行替换、寻找右子树的最小（最左）结点进行替换。

bool Erase(const K& key)
{
	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
		{
			if (cur->_left == nullptr)
			{
				if (_root == cur) _root = cur->_right;
				else
				{
					if (parent->_left == cur) parent->_left = cur->_right;
					else parent->_right = cur->_right;
				}
			}
			else if (cur->_right == nullptr)
			{
				if (_root == cur) _root = cur->_left;
				else
				{
					if (parent->_left == cur) parent->_left = cur->_left;
					else parent->_right = cur->_left;
				}
			}
			else
			{
				parent = cur;
				Node* leftMax = cur->_left;
				while (leftMax->_right)
				{
					parent = leftMax;
					leftMax = leftMax->_right;
				}
				swap(cur->_key, leftMax->_key);
				if (parent->_left == leftMax) parent->_left = leftMax->_left;
				else parent->_right = leftMax->_left;
				cur = leftMax;
			}
			delete cur;
			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* leftMax = root->_left;
			while (leftMax->_right)
			{
				leftMax = leftMax->_right;
			}
			swap(root->_key, leftMax->_key);
			return _EraseR(root->_left, key);
		}
		delete del;
		return true;
	}
}

在这里插入图片描述

3.5、二叉搜索树的中序遍历

void InOrder()
{
	_InOrder(_root);
	cout << endl;
}

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

3.6、二叉搜索树的拷贝构造函数

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

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

3.7、二叉搜索树的赋值运算符重载函数

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

3.8、二叉搜索树的析构函数

~BSTree()
{
	Destroy(_root);
}

void Destroy(Node*& root)
{
	if (root == nullptr) return;
	Destroy(root->_left);
	Destroy(root->_right);
	delete root;
	root = nullptr;
}

3.9、二叉搜索树完整代码(包含递归和非递归)

#pragma once

namespace key
{
	template<class K>
	struct BSTreeNode
	{
		BSTreeNode<K>* _left;
		BSTreeNode<K>* _right;
		K _key;
		BSTreeNode(const K& key = K())
			:_left(nullptr)
			, _right(nullptr)
			, _key(key)
		{}
	};

	template<class K>
	class BSTree
	{
		typedef BSTreeNode<K> Node;
	public:
		BSTree()
			:_root(nullptr)
		{}

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

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

		~BSTree()
		{
			Destroy(_root);
		}

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

		bool Erase(const K& key)
		{
			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
				{
					if (cur->_left == nullptr)
					{
						if (_root == cur) _root = cur->_right;
						else
						{
							if (parent->_left == cur) parent->_left = cur->_right;
							else parent->_right = cur->_right;
						}
					}
					else if (cur->_right == nullptr)
					{
						if (_root == cur) _root = cur->_left;
						else
						{
							if (parent->_left == cur) parent->_left = cur->_left;
							else parent->_right = cur->_left;
						}
					}
					else
					{
						parent = cur;
						Node* leftMax = cur->_left;
						while (leftMax->_right)
						{
							parent = leftMax;
							leftMax = leftMax->_right;
						}
						swap(cur->_key, leftMax->_key);
						if (parent->_left == leftMax) parent->_left = leftMax->_left;
						else parent->_right = leftMax->_left;
						cur = leftMax;
					}
					delete cur;
					return true;
				}
			}
			return false;
		}

		void InOrder()
		{
			_InOrder(_root);
			cout << endl;
		}

		bool FindR(const K& key)
		{
			return _FindR(_root, key);
		}

		bool InsertR(const K& key) 
		{
			return _InsertR(_root, key);
		}

		bool EraseR(const K& key)
		{
			return _EraseR(_root, key);
		}
	private:
		void Destroy(Node*& root)
		{
			if (root == nullptr) return;
			Destroy(root->_left);
			Destroy(root->_right);
			delete root;
			root = nullptr;
		}

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

		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* leftMax = root->_left;
					while (leftMax->_right)
					{
						leftMax = leftMax->_right;
					}
					swap(root->_key, leftMax->_key);
					return _EraseR(root->_left, key);
				}
				delete del;
				return true;
			}
		}

		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);
			if (root->_key > key) return _InsertR(root->_left, key);
			return false;
		}

		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);
			return true;
		}

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

	void TestBSTree1()
	{
		int a[] = { 8,3,1,10,6,4,7,14,13 };
		BSTree<int> t;
		for (auto e : a)
		{
			t.Insert(e);
		}

		t.InOrder();

		t.Erase(4);
		t.InOrder();

		t.Erase(6);
		t.InOrder();

		t.Erase(7);
		t.InOrder();

		t.Erase(3);
		t.InOrder();

		for (auto e : a)
		{
			t.Erase(e);
			t.InOrder();
		}
		t.InOrder();
	}

	void TestBSTree2()
	{
		int a[] = { 8,3,1,10,6,4,7,14,13 };
		BSTree<int> t;
		for (auto e : a)
		{
			t.InsertR(e);
		}

		t.InOrder();

		t.EraseR(4);
		t.InOrder();

		t.EraseR(6);
		t.InOrder();

		t.EraseR(7);
		t.InOrder();

		t.EraseR(3);
		t.InOrder();

		for (auto e : a)
		{
			t.EraseR(e);
			t.InOrder();
		}
		t.InOrder();
	}

	void TestBSTree3()
	{
		int a[] = { 8,3,1,10,6,4,7,14,13 };
		BSTree<int> t1, t2;
		for (auto e : a)
		{
			t1.Insert(e);
			t2.InsertR(e);
		}
		BSTree<int> t3 = t1, t4;
		int b[] = { 1, 14, 3, 13, 7, 10, 6, 8, 4 };
		for (auto e : b)
		{
			t4.Insert(e);
			t1.Erase(e);
			t1.InOrder();
			t2.EraseR(e);
			t2.InOrder();
		}
		t3 = t4;
		t3.InOrder();
		t4.InOrder();
	}
}

4、二叉搜索树key和key/value应用场景

4.1、key搜索场景

只有key作为关键码，结构中只需要存储key即可，关键码即为需要搜索到的值，搜索场景只需要判断key在不在。key的搜索场景实现的二叉树搜索树支持增删查，但是不支持修改，修改key破坏搜索树结构了。
场景1：小区无人值守车库，小区车库买了车位的业主车才能进小区，那么物业会把买了车位的业主的车牌号录入后台系统，车辆进入时扫描车牌在不在系统中，在则抬杆，不在则提示非本小区车辆，无法进入。
场景2：检查⼀篇英文文章单词拼写是否正确，将词库中所有单词放入二叉搜索树，读取文章中的单词，查找是否在二叉搜索树中，不在则波浪线标红提示。

4.2、key/value搜索场景

每一个关键码key，都有与之对应的值value，value可以任意类型对象。树的结构中(结点)除了需要存储key还要存储对应的value，增/删/查还是以key为关键字走二叉搜索树的规则进行比较，可以快速查找到key对应的value。key/value的搜索场景实现的二叉树搜索树支持修改，但是不支持修改key，修改key破坏搜索树结构了，可以修改value。
场景1：简单中英互译字典，树的结构中(结点)存储key(英文)和vlaue(中文)，搜索时输入英文，则同时查找到了英文对应的中文。
场景2：商场无人值守车库，入口进场时扫描车牌，记录车牌和入场时间，出口离场时，扫描车牌，查找入场时间，用当前时间-入场时间计算出停车时长，计算出停车费用，缴费后抬杆，车辆离场。
场景3：统计一篇文章中单词出现的次数，读取一个单词，查找单词是否存在，不存在这个说明第一次出现，（单词，1），单词存在，则++单词对应的次数。

4.3、key/value二叉搜索树代码实现

key/value我们多给一个模板参数V即可实现。这里我们定义两个变量，但实际上应该使用pair来实现的（后面的map和set会讲）。
实现代码如下，和上面key二叉搜索树差别不大，就是多了一个变量：

namespace key_value
{
	template<class K, class V>
	struct BSTreeNode
	{
		BSTreeNode<K, V>* _left;
		BSTreeNode<K, V>* _right;
		K _key;
		V _value;
		BSTreeNode(const K& key, const V& value)
			:_left(nullptr)
			, _right(nullptr)
			, _key(key)
			, _value(value)
		{}
	};

	template<class K, class V>
	class BSTree
	{
		typedef BSTreeNode<K, V> Node;
	public:
		BSTree()
			:_root(nullptr)
		{}

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

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

		~BSTree()
		{
			Destroy(_root);
		}

		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 Insert(const K& key, const V& value)
		{
			if (_root == nullptr)
			{
				_root = new Node(key, value);
				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, value);
			if (parent->_key < key) parent->_right = cur;
			else parent->_left = cur;
			return true;
		}

		bool Erase(const K& key)
		{
			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
				{
					if (cur->_left == nullptr)
					{
						if (_root == cur) _root = cur->_right;
						else
						{
							if (parent->_left == cur) parent->_left = cur->_right;
							else parent->_right = cur->_right;
						}
					}
					else if (cur->_right == nullptr)
					{
						if (_root == cur) _root = cur->_left;
						else
						{
							if (parent->_left == cur) parent->_left = cur->_left;
							else parent->_right = cur->_left;
						}
					}
					else
					{
						parent = cur;
						Node* leftMax = cur->_left;
						while (leftMax->_right)
						{
							parent = leftMax;
							leftMax = leftMax->_right;
						}
						swap(cur->_key, leftMax->_key);
						if (parent->_left == leftMax) parent->_left = leftMax->_left;
						else parent->_right = leftMax->_left;
						cur = leftMax;
					}
					delete cur;
					return true;
				}
			}
			return false;
		}

		void InOrder()
		{
			_InOrder(_root);
			cout << endl;
		}

		Node* FindR(const K& key)
		{
			return _FindR(_root, key);
		}

		bool InsertR(const K& key, const V& value)
		{
			return _InsertR(_root, key, value);
		}

		bool EraseR(const K& key)
		{
			return _EraseR(_root, key);
		}
	private:
		void Destroy(Node*& root)
		{
			if (root == nullptr) return;
			Destroy(root->_left);
			Destroy(root->_right);
			delete root;
			root = nullptr;
		}

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

		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* leftMax = root->_left;
					while (leftMax->_right)
					{
						leftMax = leftMax->_right;
					}
					swap(root->_key, leftMax->_key);
					return _EraseR(root->_left, key);
				}
				delete del;
				return true;
			}
		}

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

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

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

	void TestBSTree1()
	{
		//BSTree<string, Date> carTree;

		BSTree<string, string> dict;
		dict.InsertR("insert", "插入");
		dict.InsertR("sort", "排序");
		dict.InsertR("right", "右边");
		dict.InsertR("date", "日期");

		string str;
		while (cin >> str)
		{
			BSTreeNode<string, string>* ret = dict.FindR(str);
			if (ret)
			{
				cout << ret->_value << endl;
			}
			else
			{
				cout << "无此单词" << endl;
			}
		}
	}

	void TestBSTree2()
	{
		// 统计水果出现的次数
		string arr[] = { "西瓜", "西瓜", "苹果", "西瓜", "苹果", "苹果", "西瓜", "苹果", "香蕉", "苹果", "香蕉" };
		BSTree<string, int> countTree;
		for (auto& str : arr)
		{
			auto ret = countTree.FindR(str);
			if (ret == nullptr)
			{
				countTree.InsertR(str, 1);
			}
			else
			{
				ret->_value++;
			}
		}

		countTree.InOrder();
	}
}

5、二叉搜索树OJ题目

持续更新中…

评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值