【C++进阶之路】第三篇：二叉搜索树 kv模型

news2025/4/17 3:52:59

文章目录

  • 一、二叉搜索树
    • 1.二叉搜索树概念
    • 2.二叉搜索树操作
    • 3.二叉搜索树的实现
  • 二、二叉搜索树的应用
    • 1.kv模型
    • 2.kv模型的实现
  • 三、 二叉搜索树的性能分析

一、二叉搜索树

1.二叉搜索树概念

二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树:

  • 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值
  • 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值
  • 它的左右子树也分别为二叉搜索树

在这里插入图片描述

2.二叉搜索树操作

在这里插入图片描述

int a[] = {8, 3, 1, 10, 6, 4, 7, 14, 13};

（1）二叉搜索树的查找

a、从根开始比较，查找，比根大则往右边走查找，比根小则往左边走查找。

b、最多查找高度次，走到到空，还没找到，这个值不存在。

（2）二叉搜索树的插入

插入的具体过程如下：

a. 树为空，则直接新增节点，赋值给root指针

b. 树不空，按二叉搜索树性质查找插入位置，插入新节点

在这里插入图片描述

（3）二叉搜索树的删除

首先查找元素是否在二叉搜索树中，如果不存在，则返回，否则要删除的结点可能分下面四种情况：

a. 要删除的结点无孩子结点

b. 要删除的结点只有左孩子结点

c. 要删除的结点只有右孩子结点

d. 要删除的结点有左、右孩子结点

看起来有待删除节点有4中情况，实际情况a可以与情况b或者c合并起来，因此真正的删除过程如下：

  • 情况b：删除该结点且使被删除节点的双亲结点指向被删除节点的左孩子结点–直接删除
  • 情况c：删除该结点且使被删除节点的双亲结点指向被删除结点的右孩子结点–直接删除
  • 情况d：在它的右子树中寻找中序下的第一个结点(关键码最小)，用它的值填补到被删除节点中，再来处理该结点的删除问题–替换法删除

注意：

  • 使用替换法删除，我们通常替换所需删除节点右树中的最小节点，即所需删除节点右树区域的最左节点。需要与被删除节点替换的节点可能左为空，所以我们不能直接删除它，我们还要多做一些工作–要考虑情况c发生的可能性，做情况c一样的工作。

  • 使用替换法删除，还要考虑根节点的删除问题（根节点就是所需删除节点右树区域的最左节点）
    在这里插入图片描述

3.二叉搜索树的实现

  • BSTree.h
namespace key
{
	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:
		/*BSTree()
			:_root(nullptr)
			{}*/

		BSTree() = default; // 制定强制生成默认构造

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

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

		~BSTree()
		{
			Destroy(_root);
			//_root = nullptr;
		}

		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 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* 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
				{
					// 删除
					// 1、左为空
					if (cur->_left == nullptr)
					{
						if (cur == _root)
						{
							_root = cur->_right;
						}
						else
						{
							if (parent->_left == cur)
							{
								parent->_left = cur->_right;
							}
							else
							{
								parent->_right = cur->_right;
							}
						}

						delete cur;

					} // 2、右为空
					else if (cur->_right == nullptr)
					{
						if (cur == _root)
						{
							_root = cur->_left;
						}
						else
						{
							if (parent->_left == cur)
							{
								parent->_left = cur->_left;
							}
							else
							{
								parent->_right = cur->_left;
							}
						}

						delete cur;
					}
					else
					{
						// 找右树最小节点替代，也可以是左树最大节点替代
						Node* pminRight = cur;
						Node* minRight = cur->_right;
						while (minRight->_left)
						{
							pminRight = minRight;
							minRight = minRight->_left;
						}

						cur->_key = minRight->_key;

						if (pminRight->_left == minRight) //考虑根节点，做判断
						{
							pminRight->_left = minRight->_right; //正常节点
						}
						else
						{
							pminRight->_right = minRight->_right; //根节点
						}

						delete minRight;
					}

					return true;
				}
			}

			return false;
		}



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

		void Destroy(Node*& root)
		{
			if (root == nullptr)
				return;

			Destroy(root->_left);
			Destroy(root->_right);

			delete root;
			root = nullptr;
		}



	private:
		Node* _root = nullptr;
	};
}
  • Test.cpp
void TestBSTree1()
{
	int a[] = { 8, 3, 1, 10, 6, 4, 7, 14, 13 };
	key::BSTree<int> t1;

	for (auto e : a)
	{
		t1.Insert(e);
	}

	//t1.InOrder(t1.GetRoot());
	t1.InOrder();

	/*t1.Erase(7);
	t1.InOrder();

	t1.Erase(14);
	t1.InOrder();

	t1.Erase(3);
	t1.InOrder();*/

	t1.Erase(8);
	t1.InOrder();


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

	t1.InOrder();
}


int main()
{
	TestBSTree1();

	return 0;
}

二、二叉搜索树的应用

1.kv模型

  1. K模型：K模型即只有key作为关键码，结构中只需要存储Key即可，关键码即为需要搜索到的值。

    比如：给一个单词word，判断该单词是否拼写正确，具体方式如下：

    • 以词库中所有单词集合中的每个单词作为key，构建一棵二叉搜索树

    • 在二叉搜索树中检索该单词是否存在，存在则拼写正确，不存在则拼写错误

  2. KV模型：每一个关键码key，都有与之对应的值Value，即<Key, Value>的键值对。该种方式在现实生活中非常常见：

    • 比如英汉词典就是英文与中文的对应关系，通过英文可以快速找到与其对应的中文，英文单词与其对应的中文<word, chinese>就构成一种键值对；
    • 再比如统计单词次数，统计成功后，给定单词就可快速找到其出现的次数，单词与其出现次数就是<word, count>就构成一种键值对。

2.kv模型的实现

  • 改造二叉搜索树为KV结构
// 改造二叉搜索树为KV结构
namespace key_value
{
	// BinarySearchTree -- BSTree
	// SearchBinaryTree

	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:

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

		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* 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
				{
					// 删除
					// 1、左为空
					if (cur->_left == nullptr)
					{
						if (cur == _root)
						{
							_root = cur->_right;
						}
						else
						{
							if (parent->_left == cur)
							{
								parent->_left = cur->_right;
							}
							else
							{
								parent->_right = cur->_right;
							}
						}

						delete cur;

					} // 2、右为空
					else if (cur->_right == nullptr)
					{
						if (cur == _root)
						{
							_root = cur->_left;
						}
						else
						{
							if (parent->_left == cur)
							{
								parent->_left = cur->_left;
							}
							else
							{
								parent->_right = cur->_left;
							}
						}

						delete cur;
					}
					else
					{
						// 找右树最小节点替代，也可以是左树最大节点替代
						Node* pminRight = cur;
						Node* minRight = cur->_right;
						while (minRight->_left)
						{
							pminRight = minRight;
							minRight = minRight->_left;
						}

						cur->_key = minRight->_key;

						if (pminRight->_left == minRight)
						{
							pminRight->_left = minRight->_right;
						}
						else
						{
							pminRight->_right = minRight->_right;
						}

						delete minRight;
					}

					return true;
				}
			}

			return false;
		}


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

	protected:
		void _InOrder(Node* root)
		{
			if (root == nullptr)
				return;

			_InOrder(root->_left);
			cout << root->_key << ":" << root->_value << endl;
			_InOrder(root->_right);
		}
	private:
		Node* _root = nullptr;
	};
}
  • 测试用例
// 测试用例
void TestBSTree2()
{
	key_value::BSTree<string, string> dict;
	dict.Insert("sort", "排序");
	dict.Insert("left", "左边");
	dict.Insert("right", "右边");
	dict.Insert("string", "字符串");
	dict.Insert("insert", "插入");
	dict.Insert("erase", "删除");

	string str;
	while (cin >> str)
	{
		auto ret = dict.Find(str);
		if (ret)
		{
			cout << ":" << ret->_value << endl;
		}
		else
		{
			cout << "无此单词" << endl;
		}
	}
}

void TestBSTree3()
{
	string arr[] = { "西瓜", "西瓜", "苹果", "西瓜", "苹果", "苹果", "西瓜", "苹果", "香蕉", "苹果", "香蕉", "梨" };

	key_value::BSTree<string, int> countTree;
	for (auto str : arr)
	{
		//key_value::BSTreeNode<string, int>* ret = countTree.Find(str);
		auto ret = countTree.Find(str);
		if (ret == nullptr)
		{
			countTree.Insert(str, 1);
		}
		else
		{
			ret->_value++;
		}
	}

	countTree.InOrder();
}

int main()
{
	TestBSTree3();

	return 0;
}

三、 二叉搜索树的性能分析

插入和删除操作都必须先查找，查找效率代表了二叉搜索树中各个操作的性能。

对有n个结点的二叉搜索树，若每个元素查找的概率相等，则二叉搜索树平均查找长度是结点在二叉搜索树的深度的函数，即结点越深，则比较次数越多。

但对于同一个关键码集合，如果各关键码插入的次序不同，可能得到不同结构的二叉搜索树：

在这里插入图片描述

  • 最优情况下，二叉搜索树为完全二叉树(或者接近完全二叉树)，其平均比较次数为：log_2 N（以2为底N的对数）
  • 最差情况下，二叉搜索树退化为单支树(或者类似单支)，其平均比较次数为：N

结论：如果退化成单支树，二叉搜索树的性能就失去了。那能否进行改进，不论按照什么次序插入关键码，二叉搜索树的性能都能达到最优？依据AVL树和红黑树的知识可以很好的解决，这两个知识小编会在后续章节讲解，此处先不做深入赘述。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1137466.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

使用 kind 集群实现 all-in-one 在线安装 DCE 5.0 社区版

使用 kind 集群实现 all-in-one 在线安装 DCE 5.0 社区版

文章目录 一、什么是DCE 5.0二、部署先决条件三、创建云服务器实例3.1 实例节点配置[最低配置要求]3.2 远程连接云实例3.3 更新系统 四、安装Docker-CE五、使用 Kind 搭建 Kubernetes 集群六、安装依赖包6.1 helm安装6.2 skopeo安装6.3 kubectl安装6.4 yq安装 七、安装 DCE 5.0…
阅读更多...
软考系列（系统架构师）- 2014年系统架构师软考案例分析考点

软考系列（系统架构师）- 2014年系统架构师软考案例分析考点

试题一 软件架构&#xff08;MYC 架构、扩展接口模式&#xff09; MVC架构风格最初是Smalltalk-80中用来构建用户界面时采用的架构设计风格。其中M代表模型&#xff08;Model)&#xff0c;V代表视图&#xff08;View)&#xff0c;C代表控制器&#xff08;Controller)。在该风格…
阅读更多...
Transformers实战（一）快速入门命名实体识别、多项选择

Transformers实战（一）快速入门命名实体识别、多项选择

Transformers实战&#xff08;一&#xff09;快速入门命名实体识别、多项选择 1、命名实体识别(NER) 1.1 命名实体识别简介 1.1.1 NER数据标注体系 命名实体识别(Named Entity Recognition&#xff0c;简称NER)是指识别文本中具有特定意义的实体&#xff0c;主要包括人名、…
阅读更多...
【管理运筹学】第 10 章 | 排队论（4，系统容量有限制和顾客源有限的情形）

【管理运筹学】第 10 章 | 排队论（4，系统容量有限制和顾客源有限的情形）

文章目录 引言一、系统的容量有限制&#xff08; M / M / 1 / N / ∞ M/M/1/N/\infty M/M/1/N/∞&#xff09;二、顾客源为有限的情形&#xff08; M / M / 1 / ∞ / m M/M/1/\infty/m M/M/1/∞/m&#xff09;写在最后 引言 了解了标准的 M / M / 1 M/M/1 M/M/1 模型后&#…
阅读更多...
[UDS] --- DiagnosticSessionControl 0x10 service

[UDS] --- DiagnosticSessionControl 0x10 service

1 会话 $10包含3个子功能&#xff0c;01 Default默认会话&#xff0c;02 Programming编程会话&#xff0c;03 Extended扩展会话&#xff0c;ECU上电时&#xff0c;进入的是默认会话&#xff08;Default&#xff09;。 为什么设计三个会话模式呢&#xff1f;因为权限问题。默认…
阅读更多...
华为eNSP配置专题-路由策略的配置

华为eNSP配置专题-路由策略的配置

文章目录 华为eNSP配置专题-路由策略的配置0、概要介绍1、前置环境1.1、宿主机1.2、eNSP模拟器 2、基本环境搭建2.1、终端构成和连接2.2、终端的基本配置 3、配置路由策略3.1、目标3.2、配置路由策略 华为eNSP配置专题-路由策略的配置 0、概要介绍 路由策略就是通过一系列工具…
阅读更多...
Java SE 学习笔记（十四）—— IO流（2）

Java SE 学习笔记（十四）—— IO流（2）

目录 1 字节流1.1 字节流写数据1.1.1 创建字节输出流对象1.1.2 字节流写数据 1.2 字节流读数据1.2.1 创建字节输入流对象1.2.2 字节流读数据 1.3 字节流复制文件1.4 流的刷新与关闭1.5 资源释放方式1.5.1 try-catch-finally1.5.2 try-with-resource 2 字符流2.1 字符流概述2.2 …
阅读更多...
Spring中Bean的作用域

Spring中Bean的作用域

目录 一、什么是Bean的作用域 二、Scope注解 三、Bean的6种作用域 3.1 singleton单例模式 3.2 prototype 原型模式 3.3 request 3.4 session 3.5 application 3.6 websocket 一、什么是Bean的作用域 在之前学习的过程中&#xff0c;我们把作用域定义为&#xff1a;限定程序中变…
阅读更多...
关于数字化转型的know how

关于数字化转型的know how

关于定义——到底什么是“数字化转型”&#xff1f; 关于价值——数字化转型对企业到底有多重要&#xff1f; 关于框架——企业数字化转型的框架必备要素有哪些&#xff1f; 关于执行——企业数字化转型到底怎么做&#xff1f; 一、什么是数字化转型&#xff1f; 现在各种…
阅读更多...
Flink将数据写入MySQL(JDBC)

Flink将数据写入MySQL(JDBC)

一、写在前面 在实际的生产环境中&#xff0c;我们经常会把Flink处理的数据写入MySQL、Doris等数据库中&#xff0c;下面以MySQL为例&#xff0c;使用JDBC的方式将Flink的数据实时数据写入MySQL。 二、代码示例 2.1 版本说明 <flink.version>1.14.6</flink.version…
阅读更多...
2000-2021年上市公司内部薪酬差距数据（原始数据+计算代码Stata do文档+计算结果）

2000-2021年上市公司内部薪酬差距数据（原始数据+计算代码Stata do文档+计算结果）

2000-2021年上市公司内部薪酬差距数据&#xff08;原始数据计算代码Stata do文档计算结果&#xff09; 1、时间&#xff1a;2000-2021年 2、来源&#xff1a;上市公司年报 3、指标&#xff1a; 原始数据指标&#xff1a;code、year、证券代码、应付职工薪酬、员工人数、支付…
阅读更多...
美国IP代理如何获取？适用于哪些场景？

美国IP代理如何获取？适用于哪些场景？

美国代理IP可以是静态&#xff08;不会改变&#xff09;或动态&#xff08;周期性更改&#xff09;&#xff0c;并且可以由专业的代理服务提供商提供。不同的代理IP服务提供商可能提供不同类型的代理&#xff0c;包括数据中心代理、住宅代理和移动代理&#xff0c;以满足不同用…
阅读更多...
RT-Thread 7. RT-Thread Studio ENV修改MCU型号

RT-Thread 7. RT-Thread Studio ENV修改MCU型号

1. 修改MCU型号 2.在ENV界面输入 scons -c scons --dist3. dist下为更新后完整源代码 4.导入RT-Thread Studio 发现GD32F330已经生效了。 5. 自己编写startup_gd32f3x0.S&#xff0c;准确性待验证 ;/* ; * Copyright (c) 2006-2021, RT-Thread Development Team ; * ; * SPD…
阅读更多...
Vue组件样式设置，解决样式冲突问题

Vue组件样式设置，解决样式冲突问题

如果我们在不同的组件内&#xff0c;使用相同的类名&#xff0c;就会发生样式的冲突&#xff0c;使用后引入的组件中的样式&#xff1a; 一、scoped属性 在一个组件的style标签上添加scoped属性&#xff0c;该组件的所有样式都是该组件独有的&#xff0c;即使其他组件中有相同…
阅读更多...
详解傅立叶变换，看这一文足矣！

详解傅立叶变换，看这一文足矣！

从听到傅立叶变换这个名词后到现在已经四年了&#xff0c;这次终于对傅立叶变换有了一个基本的初步了解。记录一下&#xff0c;这个傅立叶变换也同时记录了我本科到研究生的四年&#xff0c;一路以来跌跌撞撞&#xff0c;没想到最后还是入了图像的坑 数字图像处理——傅立叶变换…
阅读更多...
freeRTOS内部机制——创建任务的内部细节

freeRTOS内部机制——创建任务的内部细节

创建任务的两个核心&#xff1a;栈和任务结构体 函数运行过程中的局部变量保存在哪里&#xff1f;他自己的栈中 任务被切换过后&#xff0c;在切换的瞬间&#xff0c;哪些寄存器的值保存在哪里&#xff1f;保存在任务结构体中 在任务创建函数中&#xff0c;会malloc动态分配…
阅读更多...
【Javascript】函数隐藏参数ar

【Javascript】函数隐藏参数ar

function test(a,b,c){console.log(abc);}test(1,2,3);这里的形参有三个分别是a&#xff0c;b&#xff0c;c分别对应实参1&#xff0c;2&#xff0c;3 假如在调用函数的时候多传入几个实参会怎么样&#xff1f; function test(a,b,c){console.log(arguments);console.log(a…
阅读更多...
吃瓜教程3|决策树

吃瓜教程3|决策树

ID3算法 假定当前样本集合D中第k类样本所占比例为pk&#xff0c;则样本集合D的信息熵定义为 信息增益 C4.5算法 ID3算法存在一个问题&#xff0c;就是偏向于取值数目较多的属性&#xff0c;因此C4.5算法使用了“增益率”&#xff08;gain ratio&#xff09;来选择划分属性 CA…
阅读更多...
第四章 文件管理 六、文件的基本操作

第四章 文件管理 六、文件的基本操作

目录 一、创建文件(create系统调用) 1、进行Create系统调用时&#xff0c;需要提供的几个主要参数: 2、操作系统在处理Create系统调用时&#xff0c;主要做了两件事: 二、删除文件(delete系统调用) 1、进行Delete系统调用时&#xff0c;需要提供的几个主要参数: 2、操作系…
阅读更多...
【20年VIO梳理】

【20年VIO梳理】

19-20年VIO 梳理 1. 开源代码介绍&#xff1a; DSM2. FMD Stereo SLAM&#xff1a;融合MVG和直接方法&#xff0c;实现准确&#xff0c;快速的双目SLAM3. 基于VINS-Mono开发的SPVIS4. 改进&#xff1a;一种基于光流的动态环境移动机器人定位方案5. PVIO:基于先验平面约束的高效…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023