数据结构【二叉搜索树】C++实现

最新推荐文章于 2024-06-27 15:06:49 发布
最新推荐文章于 2024-06-27 15:06:49 发布
阅读量357 收藏 9
点赞数 8
分类专栏： 数据结构 文章标签： 数据结构 c++ 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/aqlll_/article/details/136761711
版权

搜索二叉树

1. 什么是搜索二叉树？

搜索二叉树是一个特殊的二叉树，它的特点是：
若左子树不为空，则左子树所有节点小于根，
若右子树不为空，则右子树所有节点大于根。

正因如此，当我们以中序的方式遍历它，就能得到一个从小到大排序的序列

2. 模拟实现搜索二叉树

此次模拟实现，为KV模型，即通过key的值，可以找到value的值。听起来挺抽象，举个例子。

学校放假，该回家了，我在铁路12306上购买了回家的高铁票。在检票时，我们被要求刷身份证并且扫脸来检票。这就是典型的KV模型，身份证号码就是key值，通过这个key值，可以在系统中找到我的购票信息——value值，核对成功，即检票成功了。

我们来看看代码，看似很长，其实很简单。

#pragma once

#include<iostream>
#include<vector>
#include<stack>
using namespace std;

// 实现K/V模型
template<class K, class V>
struct BSNode
{
	BSNode(const K& key = K(), const V& value = V())
		: _left(nullptr)
		, _right(nullptr)
		, _key(key)
		, _value(value)
	{ }

	BSNode<K, V>* _left;
	BSNode<K, V>* _right;
	K _key;
	V _value;
};


template<class K, class V>
class BSTree
{
public:
	typedef BSNode<K, V> Node;

	BSTree()
		: _root(nullptr)
	{}

	Node* Find(const K& key)
	{
		// 查找值为key的节点
		Node* cur = _root;
		while (cur)
		{
			if (key < cur->_key)
			{
				cur = cur->_left;
			}
			else if (key > cur->_key)
			{
				cur = cur->_right;
			}
			else
			{
				return cur;
			}
		}
		return nullptr;
	}

	bool Insert(const K& key, const V& value)
	{
		// 1. 根为空
		if (!_root)
		{
			_root = new Node(key, value);
		}

		// 2. 根不为空
		// 疑问：参数有两个，是根据key来定位，还是根据value来定位呢？
		// 假设先以key来定位吧！
		Node* parent = nullptr;
		Node* cur = _root;
		while (cur)
		{
			// 应该插入到cur的左子树
			if (key < cur->_key)
			{
				parent = cur;
				cur = cur->_left;
			}
			// 应该插入到cur的右子树
			else if (key > cur->_key)
			{
				parent = cur;
				cur = cur->_right;
			}
			// 搜索二叉树中存在_key值为key的节点，不再插入重复。
			else
			{
				return false;
			}
		}
		// 到这里，就已经找到了该插入的位置（cur为叶子节点的空孩子，注意要区分是叶子的左孩子还是右孩子）
		if (key < parent->_key) // 说明cur是叶子的左孩子，新节点是叶子(parent)的左孩子
		{
			parent->_left = new Node(key, value);
		}
		else // 说明cur是叶子的右孩子，新节点是叶子(parent)的右孩子
		{
			parent->_right = new Node(key, value);
		}

		// 插入成功
		return true;
	}

	bool Erase(const K& key)
	{
		if (!_root)
			return false;

		Node* cur = _root;
		Node* parent = cur;
		while (cur)
		{
			if (key < cur->_key)
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (key > cur->_key)
			{
				parent = cur;
				cur = cur->_right;
			}
			else // 找到了
			{
				// 1. 左孩子为空
				if (!cur->_left)
				{
					// cur是根节点
					if (cur == _root)
					{
						_root = cur->_right;
					}
					else
					{
						if (parent->_right == cur)
						{
							parent->_right = cur->_right;
						}
						else
						{
							parent->_left = cur->_left;
						}
					}
				}
				// 2. 右孩子为空
				else if (!cur->_right)
				{
					if (cur == _root)
					{
						_root = cur->_left;
					}
					else
					{
						if (cur == parent->_left)
						{
							parent->_left = cur->_left;
						}
						else
						{
							parent->_right = cur->_left;
						}
					}
				}
				// 3. 左右孩子都不为空
				else
				{
					// 找到右子树的最左节点
					parent = cur;
					Node* rightMax = cur->_right;
					while (rightMax->_left)
					{
						parent = rightMax;
						rightMax = rightMax->_left;
					}
					swap(cur->_key, rightMax->_key);

					// 删除rightMax
					if (rightMax == parent->_right)
					{
						parent->_right = rightMax->_right;
					}
					else
					{
						parent->_left = rightMax->_right;
					}
					cur = rightMax;
				}
				delete cur;
				return true;
			}
		}

		// 没找到
		return false;
	}


	// 前序/中序/后序，这三者自身又分为循环/递归，一共写6种实现方法（实际上还有层序和morris遍历，应该有12种方法）

	void InOrder()
	{
		// 1. 前序递归
		cout << "前序递归：";
		_InOrder_F_R(_root);
		cout << endl;
		// 2. 前序循环
		cout << "前序循环：";
		_InOrder_F_C();
		cout << endl;

		// 3. 中序递归
		cout << "中序递归：";
		_InOrder_M_R(_root);
		cout << endl;
		// 4. 中序循环
		cout << "中序循环：";
		_InOrder_M_C();
		cout << endl;

		// 5. 后序递归
		cout << "后序递归：";
		_InOrder_B_R(_root);
		cout << endl;
		// 6. 后序循环
		cout << "后序循环：";
		_InOrder_B_C();
		cout << endl;
	}

	bool EraseR(const K& key)
	{
		return _EraseR(_root, key);
	}

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

private:
	// 1. 前序递归
	void _InOrder_F_R(Node* root)
	{
		if (!root)
			return;
		cout << root->_key << "->" << root->_value << " ";
		_InOrder_F_R(root->_left);
		_InOrder_F_R(root->_right);
	}
	// 2. 中序递归
	void _InOrder_M_R(Node* root)
	{
		if (!root)
			return;
		_InOrder_M_R(root->_left);
		cout << root->_key << "->" << root->_value << " ";
		_InOrder_M_R(root->_right);
	}
	// 3. 后序递归
	void _InOrder_B_R(Node* root)
	{
		if (!root)
			return;
		_InOrder_B_R(root->_left);
		_InOrder_B_R(root->_right);
		cout << root->_key << "->" << root->_value << " ";
	}
	// 4. 前序循环
	void _InOrder_F_C()
	{
		stack<Node*> st;
		vector<K> v_k;
		vector<V> v_v;
		Node* cur = _root;
		// 只有当cur为空且栈里没有数据了，所有工作才完成
		while (cur || !st.empty())
		{
			// 如果当前节点cur不为空，就把cur入栈
			while (cur)
			{
				st.push(cur);
				cur = cur->_left;
				v_k.push_back(st.top()->_key);
				v_v.push_back(st.top()->_value);
			}
			if (!cur)
				cur = st.top();	
			// 此时左子节点们已经入栈完成了
			st.pop();
			cur = cur->_right;
		}

		for (size_t i = 0; i < v_v.size(); ++i)
		{
			cout << v_k[i] << "->" << v_v[i] << " ";
		}
	}
	// 5. 中序循环
	void _InOrder_M_C()
	{
		stack<Node*> st;
		vector<K> v_k;
		vector<V> v_v;
		Node* cur = _root;
		// 只有当cur为空且栈里没有数据了，所有工作才完成
		while (cur || !st.empty())
		{
			// 如果当前节点cur不为空，就把cur入栈
			while (cur)
			{
				st.push(cur);
				cur = cur->_left;
			}

			if (!cur)
				cur = st.top();

			// 此时左子节点们已经入栈完成了

			v_k.push_back(st.top()->_key);
			v_v.push_back(st.top()->_value);
			st.pop();
			cur = cur->_right;
		}

		for (size_t i = 0; i < v_v.size(); ++i)
		{
			cout << v_k[i] << "->" << v_v[i] << " ";
		}
	}
	// 6. 后序循环
	void _InOrder_B_C()
	{
		stack<Node*> st;
		vector<K> v_k;
		vector<V> v_v;
		Node* cur = _root;
		Node* prev = nullptr;
		// 只有当cur为空且栈里没有数据了，所有工作才完成
		while (cur || !st.empty())
		{
			// 如果当前节点cur不为空，就把cur入栈
			while (cur)
			{
				st.push(cur);
				cur = cur->_left;
			}
			// 此时左子节点们已经入栈完成了

			// 如果栈顶节点的右子树为空，或者上一个访问的就是栈顶节点的右子树，则说明可以访问根了
			if (!st.top()->_right || st.top()->_right == prev)
			{
				prev = st.top();
				v_k.push_back(st.top()->_key);
				v_v.push_back(st.top()->_value);
				st.pop();
			}
			else
			{
				cur = st.top()->_right;
			}
		}

		for (size_t i = 0; i < v_v.size(); ++i)
		{
			cout << v_k[i] << "->" << v_v[i] << " ";
		}
	}


	bool _InsertR(Node*& root, const K& key, const V& value)
	{
		if (!root)
		{
			root = new Node(key, value);
			return true;
		}
		// 找位置
		if (key < root->_key)
		{
			_InsertR(root->_left, key, value);
		}
		else if (key > root->_key)
		{
			_InsertR(root->_right, key, value);
		}
		else // 存在相等，这是搜索二叉树不允许的
		{
			return false;
		}
	}

	bool _EraseR(Node*& root, const K& key)
	{
		// 如果root为空，说明没有找到
		if (!root)
			return false;
		if (root->_key < key)
		{
			_EraseR(root->_right, key);
		}
		else if (root->_key > key)
		{
			_EraseR(root->_left, key);
		}
		else
		{
			Node* del = root;
			// 找到了！
			if (!root->_left) // 左孩子为空
			{
				root = root->_right;
			}
			else if (!root->_right) // 右孩子为空
			{
				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;
		}
	}
private:
	Node* _root;
};

3. 效率分析

搜索二叉树，它的的查找、排序、插入、删除的效率都很不错，时间复杂度一般为O(logN)，因为它的遍历仅仅是高度次。
但是也有特例：当一个二叉树存在大量的类似链表的结构（也就是大量节点只有一个子节点），那么它的高度就会与N相近，此时的时间复杂度就是O(N)了。

也正因此，前人又在此基础上设计出了很多结构，来压缩搜索二叉树的高度，以避免出现这种特例，那便是AVL树、红黑树等等，这些结构较复杂，参见我后面的博客。

时间书写
关注
  • 8
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉搜索树的实现与应用
11-04
本资源是博文【数据结构】二叉搜索树的完整源代码文件，包含K模型搜索树的递归、非递归实现；KV模型搜索树的递归和非递归实现。以及两种模型的测试和应用，主要体现在单词翻译、统计次数、检查单词拼写。可结合以下...
二叉树-基于C++实现的二叉搜索树.zip
04-26
总之，二叉搜索树是一种重要的数据结构，它在C++中的实现涉及到节点结构的设计和插入、查找、删除等操作的实现。理解并掌握二叉搜索树的原理和操作是提升算法能力的关键，而自平衡二叉搜索树则进一步提高了在大规模...
【数据结构】二叉搜索树/搜索二叉树(C++实现)
Brant_zero的博客
11-05 2152
二叉搜索树的概念、二叉搜索树的实现，二叉搜索树的插入、二叉搜索树的删除、二叉搜索树的查找、二叉搜索树性能分析，二叉搜索树key模型、二叉搜索树key-value模型
【数据结构】二叉搜索树的实现
学了就忘是正常现象
01-23 2092
递归删除：找到节点后，同样需要分三种情况讨论。 1、被删除节点左树为空； 2、被删除节点左树不为空但右树为空； 3、被删除节点左右子树均不为空。
C++ 数据结构--二叉搜索树的实现
凡事都是靠练习
08-19 976
数据结构中二叉搜索树的实现
二叉搜索树实现 C++
juggte的博客
12-19 935
二叉树搜索树（BST） 二叉搜索树是一种二叉树，是应用非常广泛的一种二叉树，英文简称为BST。又称为:二叉查找树、二叉排序树 目录二叉树搜索树（BST）BST的特点SBT的接口C++实现复杂度分析 BST的特点 二叉树搜索树特点 任意一个节点的值都大于其左子树所有节点的值 任意一个节点的值都小于其右子树所有节点的值 SBT的接口 bool add(const T& x) bool remove(const T& x) bool contains(const T& x)
C++实现二叉搜索树
Ly的博客
04-30 1170
二叉搜索树是一种特别有用的数据结构，AVL树，红黑树的原型都是二叉搜索树。本文将会对二叉搜索树进行初步介绍，从而入门二叉搜索树，为以后深入学习AVL树和红黑树打下基础。
数据结构之二叉搜索树（C++实现）
CHAKMING1的博客
01-12 494
介绍了二叉树中的二叉搜索树，从概念到具体实现，是使用C++完成的。最后，对二叉搜索树的效率进行分析已经响应的二叉树的练习题目。
【C++】二叉搜索树
qq_62939852的博客
04-18 922
从根开始比较，查找，比根大则往右边走查找，比根小则往左边走查找。 最多查找高度次，走到到空，还没找到，这个值不存在非空右子树的所有值大于根节点的值 左右子树都是二叉搜索树第一个不满足，因为值为5的节点在值为10的节点的右边，正常来说10的右边都应该比10大分为两种情况 若插入的值在二叉树中不存在，则通过比较进行插入若插入11，因为11比8大，所以跟10比较，而11比10大，所以走10的右子树14，14与11比较，因14>11，所以走14的左子树13，11与13比较，因13>11，故作为13的左子树，遇见NU
二叉搜索树讲解及其C++代码实现
m0_56745306的博客
06-04 1030
文章概述：本文介绍了二叉搜索树的概念、一般操作和其C++代码实现。不是很了解二叉搜索树请先看教材和讲解然后参照代码自己动手试一试；如果只是需要实现代码&测试代码，请直接查看第四节。参考教材：清华大学《数据结构》第2版教材（殷人昆主编）...
[数据结构C++实现]二叉搜索树
Protein_zmm的博客
08-04 768
二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树: 三、二叉搜索树实现 3.1 非递归版本 插入 删除没有孩子的节点 只有一个孩子的节点 有两个孩子的节点 并且最右节点(一定右为空)或者最左节点(一定左为空)删除只有一个孩子节点的情况： 父亲会不会为空？——会，只有根节点父亲会为空 让root指向cur的孩子有两个孩子的节点：要么找右子树最左节点或者是左子树最右节点若删除5： 若删除7：不要给空：，不然min父节点为空，之后又会出错 3.2 递归版本 递归可能会爆栈
数据结构之二叉排序树（C++实现）
cheng_jack_li的博客
09-11 3195
二叉树是数据结构中的一个非常非常重要的板块，俗话说不到长城非好汉，那么不会二叉树就不算了解数据结构。什么是二叉树，在之前我们了解了链表，但是我们在使用的时候就会发现一个问题就是，链表的每一个节点只能在同一方向指向一个节点，也就是不能分叉，可是在实际应用中必须要有分叉的存在，怎么办呢，前辈们就提出了二叉排序树的概念。通过前边的学习我们了解了单链表有两个区域，就是数据域和指针域，双向链表为了实现反向遍历多加了一个区域叫前驱指针域，所以双向链表就有了三个域，前驱指针域，后继指针域和数据域，同理我们就能猜出来，二叉
二叉查找树（二分搜索树）的C++方法实现
01-20
资源内容：完整的二叉查找树C++头文件，包括运算符重载，bst类构造器、bst类析构器、destroy()、size()、insert()，迭代器类的声明与实现，++运算符重载（前置、后置）、--运算符重载、*运算符重载、！=运算符重载、...
二叉搜索树查找算法【实现】.rar_C++_C++ 二叉搜索树_organizationzme
09-23
C++实现二叉搜索树查找算法主要涉及以下几个核心概念： 1. **节点定义**：首先，我们需要定义一个二叉搜索树的节点结构。这个结构通常包括键值、指向左右子节点的指针以及可能的额外信息，如指向父节点的指针等。 ...
数据结构 二叉搜索树
08-06
在C++实现二叉搜索树时，可以使用类封装节点和树的操作，例如： ```cpp class BST { private: TreeNode* root; // 实现插入、查找、删除等方法 public: BST() : root(nullptr) {} // 构造函数、析构函数、插入...
数据结构之B树
zgy_boke的博客
06-26 342
插入操作：如果插入后节点中的关键字数量超过阶数规定的上限，需要进行节点分裂，将中间的关键字提升到父节点，并将节点分裂为两个。B 树的查找操作类似于二叉查找树，但由于是多路查找，需要在节点内部根据关键字进行比较和判断，然后选择合适的子节点继续查找。B 树（B-Tree）是一种平衡的多路查找树，常用于数据库和文件系统中，以实现对大量数据的高效存储和检索。删除操作：如果删除后节点中的关键字数量过少，可能需要进行节点合并或从兄弟节点借关键字。
【408考点之数据结构】二叉树的遍历及线索二叉树
gygkhd的博客
06-26 791
二叉树的遍历是指按照一定的顺序访问二叉树中所有节点。常见的遍历方法有前序遍历（Preorder Traversal）、中序遍历（Inorder Traversal）、后序遍历（Postorder Traversal）和层次遍历（Level Order Traversal）。前序遍历（Preorder Traversal）： 中序遍历（Inorder Traversal）： 后序遍历（Postorder Traversal）： 层次遍历（Level Order Traversal）： 二、线索
顺序表--数据结构第一关
最新发布
Mr_Xuhhh的博客
06-27 640
主要是以C语言的基础上实现顺序表
数据结构——跳表Skip List
qq_50604294的博客
06-26 751
1.定义跳表（Skip List）：是一种概率性数据结构，由William Pugh在1990年提出，主要用于在有序的元素集合上进行快速的搜索、插入和删除操作。跳表的效率与平衡树相当，但实现起来更简单，它通过维护多层链表来提高查找效率。2. 实现原理在原有的有序链表上面增加了多级索引，通过索引进行二分查找从而实现高效率查找，其每种操作(搜索、插入、删除)的平均复杂性均为O(logn)。3.特点特点描述结构多层链表，每层是下层的子集。查找效率。
二叉搜索树 c++怎么实现
03-29
二叉搜索树（Binary Search Tree，BST）可以通过链式存储结构实现。其节点结构体定义如下： ``` typedef struct TreeNode{ int data; struct TreeNode *left; struct TreeNode *right; }TreeNode; ``` 其中，`...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值