数据结构--二叉搜索树

news2024/9/19 21:21:05

目录

二叉搜索树的概念

二叉树的实现

结点类 

函数接口总览

实现二叉树

二叉搜索树的应用

K模型

KV模型

二叉搜索树的性能分析

二叉搜索树的概念

    二叉搜索树（Binary Search Tree，简称BST）是一种特殊的二叉树，其具有以下几个性质：

  1. 每个节点至多有两个子节点：分别称为左子节点和右子节点。
  2. 左子树上的所有节点的值都小于根节点的值。
  3. 右子树上的所有节点的值都大于根节点的值。
  4. 每个节点的左右子树也都是二叉搜索树。

这些性质确保了在二叉搜索树中进行查找、插入和删除操作具有良好的性能。具体地，这些操作在平均情况下的时间复杂度为 O(logn)，其中 n 是树中节点的数量。不过，在最坏情况下（树退化成链表），时间复杂度可能会降为 O(n)。

下面是一个二叉搜索树的示例：

在这个二叉搜索树中：

  • 根节点是 8。
  • 根节点的左子树包含节点 3、1、6、4 和 7，这些节点的值都小于 8。
  • 根节点的右子树包含节点 10、14 和 13，这些节点的值都大于 8。

二叉树的实现

结点类 

要实现二叉搜索树，我们首先需要实现一个结点类：

  • 结点类当中包含三个成员变量：结点值、左指针、右指针。
  • 结点类当中只需实现一个构造函数即可，用于构造指定结点值的结点。
template<class K>
struct BSTreeNode
{
	K _key;                 // 结点值
	BSTreeNode<K>* _left;   // 左指针
	BSTreeNode<K>* _right;  // 右指针

	// 构造函数
	BSTreeNode(const K& key = K())
		: _key(key)
		, _left(nullptr)
		, _right(nullptr)
	{}
};

函数接口总览

//二叉搜索树
template<class K>
class BSTree
{
	typedef BSTreeNode<K> Node;
public:
	//构造函数
	BSTree();

	//拷贝构造函数
	BSTree(const BSTree<K>& t);

	//赋值运算符重载函数
	BSTree<K>& operator=(BSTree<K> t);

	//析构函数
	~BSTree();

	//插入函数
	bool Insert(const K& key);

	//删除函数
	bool Erase(const K& key);

	//查找函数
	Node* Find(const K& key);

	//中序遍历
	void InOrder();
private:
	Node* _root; //指向二叉搜索树的根结点
};

    为了在实现其他接口的过程中方便随时检查，最好实现一个二叉搜索树的中序遍历接口，当我们对二叉搜索树进行一次操作后，可以调用中序遍历接口对二叉搜索树进行遍历，若二叉搜索树进行操作后的遍历结果仍为升序，则可以初步判断所实现的接口是正确。

//中序遍历的子函数
void _InOrder(Node* root)
{
	if (root == nullptr)
		return;
	_InOrder(root->_left); //遍历左子树
	cout << root->_key << " "; //遍历根结点
	_InOrder(root->_right); //遍历右子树
}
//中序遍历
void InOrder()
{
	_InOrder(_root);
	cout << endl;
}

实现二叉树

代码如下:

// 定义二叉搜索树模板类
template<class K>
class BSTree
{
private:
	BSTreeNode<K>* _root;  // 树的根结点

	// 辅助函数：递归拷贝树
	BSTreeNode<K>* CopyTree(BSTreeNode<K>* root)
	{
		if (root == nullptr)
			return nullptr;

		BSTreeNode<K>* newNode = new BSTreeNode<K>(root->_key);
		newNode->_left = CopyTree(root->_left);
		newNode->_right = CopyTree(root->_right);
		return newNode;
	}

	// 辅助函数：递归销毁树
	void DestroyTree(BSTreeNode<K>* root)
	{
		if (root != nullptr)
		{
			DestroyTree(root->_left);   // 递归销毁左子树
			DestroyTree(root->_right);  // 递归销毁右子树
			delete root;                // 删除当前结点
		}
	}

	// 辅助函数：递归插入
	BSTreeNode<K>* InsertRecursive(BSTreeNode<K>* root, const K& key)
	{
		if (root == nullptr)
		{
			return new BSTreeNode<K>(key);  // 找到插入位置后创建新结点
		}
		if (key < root->_key)
		{
			root->_left = InsertRecursive(root->_left, key);  // 递归插入左子树
		}
		else if (key > root->_key)
		{
			root->_right = InsertRecursive(root->_right, key); // 递归插入右子树
		}
		return root;
	}

	// 辅助函数：递归删除
	BSTreeNode<K>* DeleteRecursive(BSTreeNode<K>* root, const K& key)
	{
		if (root == nullptr)
			return root;

		if (key < root->_key)
		{
			root->_left = DeleteRecursive(root->_left, key);  // 在左子树中删除
		}
		else if (key > root->_key)
		{
			root->_right = DeleteRecursive(root->_right, key); // 在右子树中删除
		}
		else
		{
			if (root->_left == nullptr)
			{
				BSTreeNode<K>* temp = root->_right;
				delete root;  // 删除当前结点
				return temp;
			}
			else if (root->_right == nullptr)
			{
				BSTreeNode<K>* temp = root->_left;
				delete root;  // 删除当前结点
				return temp;
			}
			BSTreeNode<K>* temp = MinValueNode(root->_right);  // 找到右子树中最小值结点
			root->_key = temp->_key;  // 用右子树中最小值替换当前结点
			root->_right = DeleteRecursive(root->_right, temp->_key);  // 删除右子树中的最小值结点
		}
		return root;
	}

	// 辅助函数：找到最小值结点
	BSTreeNode<K>* MinValueNode(BSTreeNode<K>* node)
	{
		BSTreeNode<K>* current = node;
		while (current && current->_left != nullptr)
		{
			current = current->_left;  // 找到最左端的结点即为最小值结点
		}
		return current;
	}

	// 辅助函数：递归查找
	BSTreeNode<K>* SearchRecursive(BSTreeNode<K>* root, const K& key) const
	{
		if (root == nullptr || root->_key == key)
			return root;

		if (key < root->_key)
			return SearchRecursive(root->_left, key);  // 在左子树中查找

		return SearchRecursive(root->_right, key); // 在右子树中查找
	}

public:
	// 构造函数，初始化空树
	BSTree()
		: _root(nullptr)
	{}

	// 拷贝构造函数
	BSTree(const BSTree<K>& other)
		: _root(nullptr)
	{
		_root = CopyTree(other._root);  // 深拷贝另一棵树
	}

	// 赋值运算符重载函数
	BSTree<K>& operator=(const BSTree<K>& other)
	{
		if (this != &other)
		{
			DestroyTree(_root);  // 销毁当前树
			_root = CopyTree(other._root);  // 深拷贝另一棵树
		}
		return *this;
	}

	// 析构函数，销毁树
	~BSTree()
	{
		DestroyTree(_root);  // 递归销毁树中所有结点
	}

	// 插入函数（非递归）
	void InsertIterative(const K& key)
	{
		if (_root == nullptr)
		{
			_root = new BSTreeNode<K>(key);  // 插入根结点
			return;
		}
		BSTreeNode<K>* parent = nullptr;
		BSTreeNode<K>* current = _root;
		while (current != nullptr)
		{
			parent = current;
			if (key < current->_key)
			{
				current = current->_left;  // 移动到左子结点
			}
			else if (key > current->_key)
			{
				current = current->_right; // 移动到右子结点
			}
			else
			{
				return;  // 不插入重复值
			}
		}
		if (key < parent->_key)
		{
			parent->_left = new BSTreeNode<K>(key);  // 插入左子结点
		}
		else
		{
			parent->_right = new BSTreeNode<K>(key); // 插入右子结点
		}
	}

	// 插入函数（递归）
	void Insert(const K& key)
	{
		_root = InsertRecursive(_root, key);  // 调用递归插入函数
	}

	// 删除函数（非递归）
	void DeleteIterative(const K& key)
	{
		BSTreeNode<K>* parent = nullptr;
		BSTreeNode<K>* current = _root;
		while (current != nullptr && current->_key != key)
		{
			parent = current;
			if (key < current->_key)
			{
				current = current->_left;  // 移动到左子结点
			}
			else
			{
				current = current->_right; // 移动到右子结点
			}
		}
		if (current == nullptr)
			return;

		if (current->_left == nullptr || current->_right == nullptr)
		{
			BSTreeNode<K>* newCurrent;
			if (current->_left == nullptr)
			{
				newCurrent = current->_right;
			}
			else
			{
				newCurrent = current->_left;
			}

			if (parent == nullptr)
			{
				_root = newCurrent;  // 删除根结点
			}
			else if (current == parent->_left)
			{
				parent->_left = newCurrent;  // 删除左子结点
			}
			else
			{
				parent->_right = newCurrent; // 删除右子结点
			}
			delete current;
		}
		else
		{
			BSTreeNode<K>* p = nullptr;
			BSTreeNode<K>* temp;
			temp = current->_right;
			while (temp->_left != nullptr)
			{
				p = temp;
				temp = temp->_left;
			}
			if (p != nullptr)
			{
				p->_left = temp->_right;
			}
			else
			{
				current->_right = temp->_right;
			}
			current->_key = temp->_key;
			delete temp;
		}
	}

	// 删除函数（递归）
	void Delete(const K& key)
	{
		_root = DeleteRecursive(_root, key);  // 调用递归删除函数
	}

	// 查找函数（非递归）
	BSTreeNode<K>* SearchIterative(const K& key) const
	{
		BSTreeNode<K>* current = _root;
		while (current != nullptr && current->_key != key)
		{
			if (key < current->_key)
			{
				current = current->_left;  // 移动到左子结点
			}
			else
			{
				current = current->_right; // 移动到右子结点
			}
		}
		return current;  // 返回找到的结点或 nullptr
	}

	// 查找函数（递归）
	BSTreeNode<K>* Search(const K& key) const
	{
		return SearchRecursive(_root, key);  // 调用递归查找函数
	}
};

用法和预期效果:

  1. 构造函数

    • 用法：BSTree<int> tree;
    • 预期效果：创建一个空的二叉搜索树。

  2. 拷贝构造函数

    • 用法：BSTree<int> tree2 = tree1;
    • 预期效果：深拷贝tree1，创建一个新的二叉搜索树tree2，其结构和tree1相同。

  3. 赋值运算符重载函数

    • 用法：tree2 = tree1;
    • 预期效果：深拷贝tree1到tree2，覆盖tree2原来的内容。

  4. 析构函数

    • 用法：当树对象生命周期结束时自动调用。
    • 预期效果：递归销毁树中所有结点，释放内存。

  5. 插入函数（非递归）

    • 用法：tree.InsertIterative(10);
    • 预期效果：在树中插入值为10的结点。

  6. 插入函数（递归）

    • 用法：tree.Insert(10);
    • 预期效果：在树中插入值为10的结点。

  7. 删除函数（非递归）

    • 用法：tree.DeleteIterative(10);
    • 预期效果：在树中删除值为10的结点。

  8. 删除函数（递归）

    • 用法：tree.Delete(10);
    • 预期效果：在树中删除值为10的结点。

  9. 查找函数（非递归）

    • 用法：BSTreeNode<int>* node = tree.SearchIterative(10);
    • 预期效果：在树中查找值为10的结点，返回指向该结点的指针，如果未找到则返回nullptr。

  10. 查找函数（递归）

    • 用法：BSTreeNode<int>* node = tree.Search(10);
    • 预期效果：在树中查找值为10的结点，返回指向该结点的指针，如果未找到则返回nullptr。

二叉搜索树的应用

二叉搜索树（BST）是一种重要的数据结构，广泛应用于各种算法和系统中。以下是一些常见的应用：

  1. 符号表：在编译器中，二叉搜索树可以用来实现符号表，用于存储变量和函数的名称及其属性。
  2. 字典：二叉搜索树可以用来实现字典（例如键值对存储），支持高效的插入、删除和查找操作。
  3. 优先队列：可以使用二叉搜索树来实现优先队列，其中元素按照优先级排列，支持快速的插入和删除操作。
  4. 数据库索引：在数据库系统中，二叉搜索树可以用作索引结构，以加速查询操作。
  5. 排序和搜索：二叉搜索树天然地支持中序遍历，从而可以对元素进行排序和高效搜索。

K模型

    K模型是基于二叉搜索树的一种简化形式，主要用于处理单个键（key）的存储和查询。每个结点只包含一个键，不涉及值（value）。 

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

  1. 以单词集合中的每个单词作为key，构建一棵二叉搜索树。
  2. 在二叉搜索树中检索该单词是否存在，存在则拼写正确，不存在则拼写错误。

KV模型

    KV模型是二叉搜索树的扩展形式，用于处理键值对（key-value）的存储和查询。每个结点包含一个键和一个值。 

比如：英汉词典就是英文与中文的对应关系，即<word, Chinese>就构成一种键值对。具体方式如下：

以<单词, 中文含义>为键值对，构建一棵二叉搜索树。注意：二叉搜索树需要进行比较，键值对比较时只比较key。
查询英文单词时，只需给出英文单词就可以快速找到与其对应的中文含义。

二叉搜索树的性能分析

时间复杂度

  1. 查找、插入和删除

    • 最优情况：当树是平衡的（完全平衡二叉树），时间复杂度为O(log n)。
    • 最坏情况：当树退化成链表（每个结点只有一个子结点），时间复杂度为O(n)。

  2. 遍历

    • 中序遍历、先序遍历、后序遍历的时间复杂度均为O(n)，因为需要访问每个结点。

空间复杂度

  1. 空间使用

    • 空间复杂度为O(n)，n为树中的结点数。

  2. 递归调用栈

    • 在最坏情况下（树退化成链表），递归调用栈的空间复杂度为O(n)。

平衡性

  1. 平衡二叉树：如AVL树、红黑树等，保证在最坏情况下也能达到O(log n)的时间复杂度。
  2. 普通二叉搜索树：如果输入数据是随机的，树大概率接近平衡。但如果输入数据是有序的（或接近有序），树可能退化为链表，导致性能下降。

性能优化

  1. 自平衡二叉搜索树：如AVL树、红黑树、Splay树等，通过自动调整树的结构，保证树的平衡，从而提升性能。
  2. B树和B+树：特别适用于数据库索引，支持高效的磁盘存取操作。
  3. 散列：对于一些应用，哈希表（Hash Table）可以提供更快的查找、插入和删除操作，但不适用于需要排序的场景。

总结

二叉搜索树（BST）是一种基础而重要的数据结构，广泛应用于符号表、字典、优先队列和数据库索引等场景。K模型和KV模型分别处理集合和字典的需求。BST的性能在很大程度上取决于树的平衡性，使用自平衡树可以保证最坏情况下的性能。此外，对于特定应用场景，选择合适的数据结构（如B树或哈希表）也非常重要。

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

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

相关文章

CSP俄罗斯方块（简单易懂）

CSP俄罗斯方块（简单易懂）

开始将题目理解成了&#xff0c;开始的列应该是从输入图案的最左端开始计算&#xff0c;将前面所有的空列都删掉&#xff0c;代码如下&#xff1a; #include<bits/stdc.h> using namespace std; const int N 1e410; const int M 1e510; int a[20][20]; int b[5][5];int…
阅读更多...
【yolov10】使用自己的数据集训练目标检测模型

【yolov10】使用自己的数据集训练目标检测模型

【yolov10】使用自己的数据集训练目标检测模型 一、anaconda安装二、环境配置三、数据集制作1、labelimg的安装2、使用labelimg 四、正片1、下载yolov10源码2、数据集目录3、训练4、推理 一、anaconda安装 直接参考前一篇博客&#xff1a; https://blog.csdn.net/m0_71523511/…
阅读更多...
八国多语言微盘微交易所系统源码 单控点控 K线完好

八国多语言微盘微交易所系统源码 单控点控 K线完好

安装环境linux NGMySQL5.6PHP7.2&#xff08;函数全删&#xff09;pm2管理器&#xff08;node版本选择v12.20.0&#xff09; config/ database.php 修改数据库链接 设置运行目录 public 伪静态thinkphp
阅读更多...
【图解IO与Netty系列】IO的同步与异步、阻塞与非阻塞，Linux五种IO模型

【图解IO与Netty系列】IO的同步与异步、阻塞与非阻塞，Linux五种IO模型

IO的同步与异步、阻塞与非阻塞&#xff0c;Linux五种IO模型 IO的同步与异步&#xff0c;阻塞与非阻塞阻塞IO与非阻塞IO同步IO与异步IO Linux五种IO模型BIONIOIO多路复用信号驱动IOAIO IO的同步与异步&#xff0c;阻塞与非阻塞 我们有时会看到类似于同步阻塞式IO、同步非阻塞式…
阅读更多...
【python】python 全国5A级景区数据采集与pyecharts可视化（源码+数据+论文）【独一无二】

【python】python 全国5A级景区数据采集与pyecharts可视化（源码+数据+论文）【独一无二】

&#x1f449;博__主&#x1f448;&#xff1a;米码收割机 &#x1f449;技__能&#x1f448;&#xff1a;C/Python语言 &#x1f449;公众号&#x1f448;&#xff1a;测试开发自动化【获取源码商业合作】 &#x1f449;荣__誉&#x1f448;&#xff1a;阿里云博客专家博主、5…
阅读更多...
C++ prime 第五版 第14章 重载运算与类型转换

C++ prime 第五版 第14章 重载运算与类型转换

一、基本概念 重载的运算符是具有特殊名字的函数&#xff1a;它们的名字由关键字operator和其后要定义的运算符号共同组成。和其他函数一样&#xff0c;重载的运算符也包含返回类型、参数列表以及函数体。 我们不能为内置类型的运算对象重定义运算符。对于一个运算符函数来说&…
阅读更多...
美甲店会员预约系统管理小程序的作用是什么

美甲店会员预约系统管理小程序的作用是什么

女性爱美体现在方方面面&#xff0c;美丽好看的指甲也不能少&#xff0c;市场中美甲店、小摊不少&#xff0c;也跑出了不少连锁品牌&#xff0c;70后到00后&#xff0c;每个层级都有不少潜在客户&#xff0c;商家需要获取和完善转化路径&#xff0c;不断提高品牌影响力与自身内…
阅读更多...
Python学习---利用Python操作数据库

Python学习---利用Python操作数据库

如何理解连接connection和游标 cursor&#xff1f; connection就像是连接出发地和目的地的高速公路cursor就像是在高速公路上的货车-拉货我们使用游标就可以完成对数据的操作当我们完成操作完成后就可以停下货车&#xff0c;然后公路再停止使用。 pysql实现查询 ""…
阅读更多...
Linux基础（七）：Linux 系统上的库文件生成与使用

Linux基础（七）：Linux 系统上的库文件生成与使用

学过C语言我们知道&#xff0c;C语言有标准库和自定义库&#xff0c;这些方便了我们的实际开发&#xff0c;提供了已经实现好的函数接口&#xff0c;我们使用的时候&#xff0c;只需要引入头文件即可&#xff0c;那具体的实现过程又是怎么样的呢&#xff1f;我们又该如何实现我…
阅读更多...
[7] CUDA之常量内存与纹理内存

[7] CUDA之常量内存与纹理内存

CUDA之常量内存与纹理内存 1. 常量内存 NVIDIA GPU卡从逻辑上对用户提供了 64KB 的常量内存空间&#xff0c;可以用来存储内核执行期间所需要的恒定数据常量内存对一些特定情况下的小数据量的访问具有相比全局内存的额外优势&#xff0c;使用常量内存也一定程序上减少了对全局…
阅读更多...
Java进阶学习笔记24——Object类

Java进阶学习笔记24——Object类

Object类: Object类是Java中所有类的祖宗类&#xff0c;因此&#xff0c;Java中所有类的对象都可以直接使用Object类中提供的一些方法。 所有类都是Object类的子孙类。 API文档&#xff1a; Object类的成员方法&#xff1a; Object类的常见方法&#xff1a; Student类&…
阅读更多...
python冰雹序列的探索与编程实现

python冰雹序列的探索与编程实现

新书上架~&#x1f447;全国包邮奥~ python实用小工具开发教程http://pythontoolsteach.com/3 欢迎关注我&#x1f446;&#xff0c;收藏下次不迷路┗|&#xff40;O′|┛ 嗷~~ 目录 一、冰雹序列的奥秘 二、编程实现冰雹序列 三、测试与验证 四、总结与展望 一、冰雹序列的…
阅读更多...
pycharm配置python开发环境—miniconda+black+gitlab

pycharm配置python开发环境—miniconda+black+gitlab

下载miniconda管理python开发环境 miniconda下载地址&#xff1a;https://docs.anaconda.com/free/miniconda/ miniconda最新版本的python版本是python3.12.2&#xff0c;下载这个miniconda最新版本后&#xff0c;会导致执行conda create -n py31013 python3.10.13指令配置py…
阅读更多...
网络240523

网络240523

阅读更多...
基于STM32实现智能水族箱控制系统

基于STM32实现智能水族箱控制系统

目录 引言环境准备智能水族箱控制系统基础代码示例&#xff1a;实现智能水族箱控制系统 水温传感器数据读取水泵与加热器控制水位传感器数据读取用户界面与显示应用场景&#xff1a;水族箱管理与环境控制问题解决方案与优化收尾与总结 1. 引言 本教程将详细介绍如何在STM32嵌…
阅读更多...
力扣刷题---2283. 判断一个数的数字计数是否等于数位的值【简单】

力扣刷题---2283. 判断一个数的数字计数是否等于数位的值【简单】

题目描述 给你一个下标从 0 开始长度为 n 的字符串 num &#xff0c;它只包含数字。 如果对于 每个 0 < i < n 的下标 i &#xff0c;都满足数位 i 在 num 中出现了 num[i]次&#xff0c;那么请你返回 true &#xff0c;否则返回 false 。 示例 1&#xff1a; 输入&a…
阅读更多...
C++面向对象程序设计 - 输入和输出

C++面向对象程序设计 - 输入和输出

程序的输入指的是文件将数据传送给程序&#xff0c;程序的输出指的是从程序将数据传送输出文件。 C的输入和和输出包括以下三个方面&#xff1a; 对系统指定的标准设备的输入和输出&#xff0c;即从键盘输入数据&#xff0c;输出到显示器屏幕。以外存磁盘&#xff08;或光盘、…
阅读更多...
消费者相关高效读写ZK作用

消费者相关高效读写ZK作用

消费者分区分配策略 目录概述需求&#xff1a; 设计思路1.消费者分区分配策略2. 消费者offset的存储3. kafka消费者组案例4. kafka高效读写&Zk作用5. Ranger分区再分析 实现思路分析 参考资料和推荐阅读 Survive by day and develop by night. talk for import biz , show …
阅读更多...
618部分手机参数对比

618部分手机参数对比

阅读更多...
学习存储协议的利器，聊聊tcpdump和Wireshark

学习存储协议的利器，聊聊tcpdump和Wireshark

数据存储技术分为多个方面，包括数据持久化、数据映射、数据压缩和通信协议等等。其中通信协议是数据存储技术中非常重要的一部分，正是通信协议使得计算节点可以访问存储设备。同时，也正是不同的协议让存储系统呈现不同的形态。 如下图所示，通过iSCSI协议，可以将存储端的存…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023