【STL】二叉搜索树的讲解与全面实现

于 2024-08-20 19:41:14 发布
阅读量1k 收藏 28
点赞数 11
文章标签： 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79582015/article/details/141326307
版权

1.二叉搜索树的概念

二叉搜索树(BST,Binary Search Tree)又称二叉排序树，是一种特殊的二叉树，它或者是一棵空树，或者是具有以下性质的二叉树:

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

二叉搜索树（Binary Search Tree）的每个节点的左子树中的所有节点都比该节点小，右子树中的所有节点都比该节点大。这个特性使得二叉搜索树可以用来实现非常高效的查找、插入和删除操作。

2.二叉搜索树的功能

首先，在二叉搜索树的操作中只支持插入，查找，删除，遍历，并不支持修改操作，因为在修改后谁也不能保证它依然是一棵二叉搜索树，二叉搜索树的时间复杂度范围在(O(logN)~O(N))

在二叉搜索树的遍历中一般采用中序遍历： 先遍历左子树，然后访问根节点，最后遍历右子树。在BST中，中序遍历会按照升序访问所有节点

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

3.二叉搜索树的实现

二叉搜索树结构的和树形结构差不多，这意味着每个元素（通常称为节点）都有两个指针：一个指向前一个左子树，另一个指向右子树，因此我们需要单独再定义一个类来表示节点结构，每个节点再串联起来构成BST

3.1  节点的定义

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

3.2 . BST的定义

template<class K>
class BSTree
{
	typedef BSTreeNode<K> Node;
public:
	// 构造函数等可能的其他成员函数... 
private:
	Node* _root = nullptr;
};

3.3 二叉搜索树的操作

1.查找（find）

a、从根开始比较，查找，比根大则往右边走查找，比根小则往左边走查找。
b、最多查找高度次，走到到空，还没找到，这个值不存在。

bool Find(const K& key) 
{
	Node* cur = _root;
	while (cur) {
		if (cur->_key < key) { //查找的值比cur小，往左走
			cur = cur->_right;
		}
		else if (cur->_key > key) { //查找的值比cur大，往右走
			cur = cur->_left;
		}
		else  return true;//找到就返回true
	}
	return false; //找不到
}

2.插入（insert）

a、树为空，则直接新增节点，赋值给root指针
b、树不空，按二叉搜索树性质查找插入位置，插入新节点

bool Insert(const K&key) //需要找个节点保留插入节点的父节点，先找到要插入位置
{
	if (_root == nullptr) { //根为空时直接插入
		_root = new Node(key); 
		return true;
	}
	// 定义parent是因为，在最后找到插入位置时，需要parent将节点进行连接
	Node* parent = nullptr;
	Node* cur = _root;
	while (cur) {
		if (cur->_key < key) {// 插入的值比cur位置大，cur往右走
			parent = cur;
			cur = cur->_right;
		}
		else if (cur->_key > key) {// 插入的值比cur位置小，cur往左走
			parent = cur;
			cur = cur->_left;
		}
        // 当插入的值和cur位置相等时，直接退出，因为二叉搜索树不允许有相同的元素
		else  return false;
	}
	//新插入节点与二叉搜索树连接
	cur = new Node(key);
	if (parent->_key < key) parent->_right = cur;
	else parent->_left = cur;
	
	return true;
}

3.删除（erase）

首先查找元素是否在二叉搜索树中，如果不存在，则返回, 否则要删除的结点可能分下面四种情况：
a. 要删除的结点无孩子结点
b. 要删除的结点只有左孩子结点
c. 要删除的结点只有右孩子结点
d. 要删除的结点有左、右孩子结点


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

除过程如下：
 

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

// 从二叉搜索树中删除指定的键值对应的节点
bool Erase(const K& key)
{
    Node* parent = nullptr; // 父节点指针，初始化为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 (parent == nullptr)
                    _root = cur->_right; // 将根节点指向当前节点的右子节点
                else 
                {
                    // 根据当前节点在父节点中的位置，更新父节点的相应子节点指针
                    if (parent->_left == cur)
                        parent->_left = cur->_right;
                    else
                        parent->_right = cur->_right;
                }

                delete cur; // 删除当前节点
                return true;
            }
            // 如果当前节点的右子节点为空，即当前节点最多有一个左子节点
            else if (cur->_right == nullptr) 
            {
                // 如果没有父节点，则当前节点是根节点
                if (parent == nullptr)
                    _root = cur->_left; // 将根节点指向当前节点的左子节点
                else 
                {
                    // 根据当前节点在父节点中的位置，更新父节点的相应子节点指针
                    if (parent->_left == cur)
                        parent->_left = cur->_left;
                    else
                        parent->_right = cur->_left;
                }

                delete cur; // 删除当前节点
                return true;
            }
            else 
            { // 当前节点有两个子节点
                // 找到当前节点右子树中的最小节点（即右子树的最左节点）
                Node* rightMinParent = cur;
                Node* rightMin = cur->_right;
                while (rightMin->_left) 
                {
                    rightMinParent = rightMin;
                    rightMin = rightMin->_left;
                }
                // 用右子树中最小节点的值替换当前节点的值
                cur->_key = rightMin->_key;

                // 从右子树中删除最小节点
                if (rightMinParent->_left == rightMin) // 如果 rightMin 是 rightMinParent 的左子节点
                    rightMinParent->_left = rightMin->_right; // 更新 rightMinParent 的左子节点指针为 rightMin 的右子节点
                else // 如果 rightMin 是 rightMinParent 的右子节点
                    rightMinParent->_right = rightMin->_right; // 更新 rightMinParent 的右子节点指针为 rightMin 的右子节点

                delete rightMin; // 删除最小节点
                return true;
            }
        }
    }
    return false; // 如果没有找到要删除的节点
}

4.搜索树的遍历（中序遍历）

	void Inorder() //避免_root私有，无法提供的问题
	{
		_Inorder(_root);
	}
private:
	void _Inorder(Node* root)
	{
		if (root == nullptr) return; //递归截止
		_Inorder(root->_left);
		printf("%d ", root->_key);
		_Inorder(root->_right);
	}

5.二叉搜索树默认成员函数

5.1构造

BSTree() = default; // 显式地定义默认构造函数

5.2拷贝构造

BSTree(const BSTree<K>& t)
{
	_root = Copy(t._root);
}
private:
	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;
	}

5.3赋值重载

BSTree<K>& operator=(BSTree<K> t)
{
    // 现代写法-> 直接调用swap
    swap(_root, t._root);
    return *this;
}

5.4析构

~BSTree()
{
	Destory(_root);
}
private:
	void Destroy(Node* root)
    {
	    if (root == nullptr) return;
	    Destroy(root->_left);
	    Destroy(root->_right);
	    delete root;
    }

4.二叉搜索树的KV模型

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

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

和上面二叉搜索树建立类似，在成员函数中，我们只需要在Insert中加入value元素即可，

如： BSTNode<K> Node 变成  BSTNode<K, V> Node ， 

如new Node(key); 变成  new Node(key, value);  

还有就是find不再是返回bool值，而是返回的节点值

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

4.2KV模型的实现

namespace keyValue  // 避免与之前k模型冲突
{
	template<class K, class V>
	struct BSTreeNode
	{
		BSTreeNode<K>* _left;
		BSTreeNode<K>* _right;
		K _key;
		V _value;
		
		BSTreeNode(const K& key = K(), const V& value = V())
			: _left(nullptr)
			, _right(nullptr)
			, _key(key)
			, _value(value)
		{}
	};
	template<class K, class V>
	class BSTree
	{
		typedef BSTreeNode<K, V> Node;
	public:
		// 构造函数等可能的其他成员函数... 
		// 在成员函数中，我们只需要在insert中加入value元素即可
	private:
		Node* _root = nullptr;
	};
}

代码测试

void test2()
{
	// 输入单词，查找单词对应的中文翻译
	keyValue::BSTree<string, string> dict;
	dict.Insert("string", "字符串");
	dict.Insert("tree", "树");
	dict.Insert("left", "左边、剩余");
	dict.Insert("right", "右边");
	dict.Insert("sort", "排序");
	// 插入词库中所有单词
	string str;
	while (cin >> str)
	{
		auto ret = dict.Find(str);
		if (ret == nullptr)
		{
			cout << "单词拼写错误，词库中没有这个单词:" << str << endl;
		}
		else
		{
			cout << str << "中文翻译:" << ret->_value << endl;
		}
	}
}

2.计数

void test3()
{
	// 统计水果出现的次数
	string arr[] = { "苹果", "西瓜", "苹果", "西瓜", "苹果", "苹果", "西瓜",
	"苹果", "香蕉", "苹果", "香蕉" };
	keyValue::BSTree<string, int> countTree;
	for (const auto& str : arr)
	{
		// 先查找水果在不在搜索树中
		// 1、不在，说明水果第一次出现，则插入<水果, 1>
		// 2、在，则查找到的节点中水果对应的次数++
		//BSTreeNode<string, int>* ret = countTree.Find(str);
		auto ret = countTree.Find(str);
		if (ret == NULL)
		{
			countTree.Insert(str, 1);
		}
		else
		{
			ret->_value++;
		}
	}
	countTree.InOrder();
}

5.二叉搜索树的性能分析

插入和删除操作都必须先查找，查找效率代表了二叉搜索树中各个操作的性能。
  对有n个结点的二叉搜索树，若每个元素查找的概率相等，则二叉搜索树平均查找长度是结点在二叉搜索树的深度的函数，即结点越深，则比较次数越多。
  但对于同一个关键码集合，如果各关键码插入的次序不同，可能得到不同结构的二叉搜索树：

最优情况下，二叉搜索树为完全二叉树(或者接近完全二叉树)，其平均比较次数为：\log N
​
最差情况下，二叉搜索树退化为单支树(或者类似单支)，其平均比较次数为：\frac{N}{2}
 

北海有初拥
关注
第十五章：map和set
m0_63027727的博客
04-02 729
第十五章：map和set 序列式容器：vector / list / deque / ··· 【底层为线性序列的数据结构，里面存储的是元素本身 】 关联式容器：map / set / unordered_map / underored_set / ··· 【里面存储的是<key, value>结构的键值对，在数据检索时比序列式容器效率更高】 1.树形结构的关联式容器 根据应用场景的不桶，STL总共实现了两种不同结构的管理式容器：树型结构与哈希结构。**树型结构的关联式容器主要有四种：map
初识STL模版|c++基础--详细讲解
最新发布
署髫
08-04 655
STL（Standard Template Library）是C++的一部分，它是一个库，包含了几个组件，如向量、列表、映射、集合等。这些组件都是通用的，可以用于不同类型的数据，是一套非常好用且强大的C++模板。在C++中，你可以通过模板（templates）来创建自己的STL样式的数据结构。模板是C++中的一个特性，它允许你编写可以用于多种数据类型的代码。
[C/C++]详解STL容器5--二叉搜索树的介绍及模拟实现
RMA515T的博客
11-18 4308
本文对二叉搜索树进行介绍，并对其核心功能进行了模拟实现。
数据结构 C++ STL 二叉树
01-21
二叉树 二叉树的递归遍历和非递归遍历 二叉树的迭代器 线索二叉树（中序）
stl的二叉排序树_算法笔记：二叉排序树
weixin_35242523的博客
01-29 411
二叉排序树，也叫二叉查找树，这是一种基本的二叉树结构。概述二叉排序树，是指一种二叉树，这是一种树形的数据结构，这种数据结构中，存储数据的基本单位叫做节点，对于二叉树，一个节点可以链接到最多两个其他节点，就像树的两个树杈，所以叫做二叉树。树的第一个节点，所有分支顶部的那个，就是根节点，而树的下方，没有左右节点的节点，被称作叶子节点。我们说，如果一个二叉树符合如下规则，他就可以被称为二叉排序树：二叉树...
【C++ STL】-- 二叉搜索树
weixin_64609308的博客
11-25 2494
详细配图讲解：搜索二叉树的构建与函数接口实现
【C++高阶】二叉搜索树的全面解析与高效实现
island1314的博客
07-18 1477
二叉搜索树的深度解析
【二叉搜索树进阶】：平衡增长的优雅实现技巧
二叉搜索树（BST）是一种特殊的二叉树，它不仅能够存储数据，还能高效地执行数据的插入、查找和删除操作。其核心是每个节点都遵循这样的规则：对于任意节点N，其左子树上的所有节点的值都小于等于N的值，而其右子树...
红黑树的插入操作实现与代码分析
红黑树（Red-Black Tree）是一种自平衡的二叉查找树，它是在计算机科学中用来存储有序的数据集合的一种数据结构。红黑树的特点在于它能够保持良好的平衡，确保插入、删除等操作的最坏情况时间复杂度为O(log n)，从而...
STL tutorial and reference Code
02-09
例如，`vector`是动态数组，`list`是双向链表，`set`和`map`则是自平衡的二叉搜索树。容器可以存储元素，支持各种操作，如插入、删除、遍历等。 2. 迭代器（Iterators）：迭代器是访问容器中元素的一种机制，类似于...
C++ STL和平衡二叉树红黑树
无敌秋
03-31 2072
在实际使用过程中，到底选择这几种容器中的哪一个，应该根据遵循以下原则： １、如果需要高效的随机存取，不在乎插入和删除的效率，使用vector； 2、如果需要大量的插入和删除元素，不关心随机存取的效率，使用list； 3、如果需要随机存取，并且关心两端数据的插入和删除效率，使用deque； 4、如果打算存储数据字典，并且要求方便地根据key找到value，一对一的情况使用map，一对多的情况使用multimap； 5、如果打算查找一个元素是否存在于某集合中，唯一存在的情况使用set，不唯一存在的情况使用mul
【算法】STL的平衡二叉树数据结构
m0_65431212的博客
08-30 537
cg
二叉树 STL 图 哈希 详解
Meikesibondwell的博客
08-04 677
Ubuntu Pastebin Paste from QWbin at Wed, 26 Jul 2017 10:36:33 +0000 Download as text 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
【STL】平衡二叉树
qq_73575817的博客
10-17 513
而进行何种旋转本质是取决于 parent cur 和 cur_left （或cur_right）之间的关系，若他们三个所连成的是直线，那么进行单旋操作，如果为折线，那就进行双旋操作；而这里的平衡因子刚好可以体现他们之间的关系，所以上图中根据平衡因子来决定单双旋和左右旋转AVL树构造和插入函数，测试函数：这里的节点值类型简化为了int类型，原为 pairpublic:int _val;int _bf;
[STL与数据结构]搜索二叉树
Legwhite的博客
02-18 1127
大家好呀！今天带来的文章是平衡二叉树，你是否在写题的时候遇到需要容器存储，且是否效率低下，没事搜索二叉(map,set的底层)树帮你解决问题 文章目录搜索二叉树的底层结构造轮子理解底层 搜索二叉树的底层结构 定义 搜索二叉树的左子树永远比根小，右子树永远比根大，且树中值唯一确定(目前是)，如图所示: 你仔细看发现每一棵子树都是按照那个规则的，你在仔细看如果按照中序遍历（左，根，右）打印的话能会发现，竟然是一个升序的序列 问 那么这个用这个结构差找效率是多少呢？到底有多快呢？ 答 搜索
STL中的平衡二叉树（multiset set）
最爱晴天和自己的博客
08-04 2718
multiset set multimap map#include &lt;set&gt; //使用multiset和set需要此头文件  可在增加和删除数据的基础上查找数据。 multiset用法 multiset&lt;T&gt; st;   定义了一个multiset变量st，st里面可以存放T类型的数据，并且能自 动排序。开始st为空    size()  返回容器中元素的数...
C++使用STL实现二叉树 前、中、后序遍历（非递归)
weixin_44161513的博客
06-09 1314
最近刚学到数据结构的二叉树部分,想用C++实现二叉树的前序、中序、后序遍历 一般二叉树的遍历有两种方法，递归和非递归，递归这里就不说了，网上各个版本都差不多，非递归一般是用栈来实现的，这里主要说一下非递归。 先简单说明一下这 3 种遍历方式有什么不同 —— 对于每种遍历，树中每个结点都需要经过 3 次（对于叶结点，其左右子树视为空子树），但前序遍历在第一次遇到结点时就立即访问，中序遍历是在第二次遇到结点时访问，后序遍历则是第三次访问。 所谓的前序、中序、后序都是以根节点为标准，前序就是先遍历根节点，中序就是
STL学习笔记之容器--二叉查找树
wei.zhou的专栏
06-16 958
SGI STL的关联容器（map、set、multimap、multiset）底层都是基于红黑树（Red Black Tree，RBT）来实现的，红黑树是一种被广泛使用的二叉查找树（Binary Search Tree，BST），有比较良好的操作效率。 1. 二叉查找树 二叉查找树可提供对数时间的元素插入和访问，其遵循以下规则：任何节点的键值一定大于其左子树中每一个节点的键值，并小于其右子
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

北海有初拥

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值