【cpp---＞二叉搜索树】

已于 2023-04-22 17:55:28 修改
阅读量112 收藏 1
点赞数
文章标签： c++ 数据结构
于 2023-04-22 17:45:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kk1125778230/article/details/130301641
版权

文章目录

一、二叉搜索树的实现

（一）二叉搜索树的中心思想

二叉搜索树又称为二叉排序树或者二叉查找树，如果它的左子树不为空，那么它的左子树的值都小于根节点的值，如果它的右子树不为空，那么它的右子树的值都大于根节点的值，它的左右子树也都是二叉搜索树
它中序遍历出来的val集合是有序的
在这里插入图片描述
中序遍历:1,3,4,6,7,8,10,13,14

（二）二叉搜索树的具体构造

1.节点结构

与普通二叉树没区别，一左一右一key

//二叉树的节点结构
template <class K>
struct BinarySearchTreeNode
{
	BinarySearchTreeNode(K key)
		:_left(nullptr)
		,_right(nullptr)
		,_key(key)
		{}
	BinarySearchTreeNode<K>* _left;
	BinarySearchTreeNode<K>* _right;
	K _key;
}
//二叉搜索树结构
class BSTree
{
	typedef BinarySearchTreeNode Node;
public:
	//默认构造
	BSTree()
		:_root(nullptr)
	{}
	//针对默认构造函数不处理内置类型此操作是强制生成默认构造函数
	BSTree()=default;
	
	//析构
	~BSTree()
	{
		Destroy(_root);
	}
	//拷贝构造
	BSTree(const BSTree<K>& t)
	{
		_root=Copy(t._root);
	}
	//赋值重载
	BSTree<K>& operator=(BSTree<k> t)
	{
		swap(_root,t._root);
	}
	//非递归插入
	bool Insert(K key);
	//非递归查找
	bool Find(K key);
	//非递归删除
	bool Erase(K key);
	
	//插入递归版本
	bool Insert(K key)
	{
		_Insert(_root,key);
	}
	//查找递归版本
	bool Find(K key)
	{
		_Find(_root,key);
	}
	//删除递归版本
	bool Erase(K key)
	{
		_Erase(_root,key);
	}
	//中序遍历
	bool InOrder()
	{
		_InOrder(_root);
	}
	//保护内部实现接口
protected:
	//插入递归实现
	bool _Insert(Node* root,K key);
	//查找递归实现
	bool _Find(Node* root,K key);
	//删除递归实现
	bool _Erase(Node* root,K key);
	//中序递归遍历
	void _InOrder(Node* root);
	//析构递归实现
	void Destroy(Node* root);
	//拷贝构造递归实现
	Node* Copy(Node* root);
private:
	Node* _root;	
};

2.插入

非递归实现
1.如果树为空就直接插件新节点赋值个root指针，返回true

2.不为空就利用变量cur指针（初始值_root）找位置，要插入的值小于当前节点的key就往左走，大于往右走，如果等于就返回false，表示插入失败，因为二叉搜索树不允许key冗余；走到nullptr了就创建节点插入，并返回true

3.需要注意的是cur走到nullptr的时候不知道cur是上一个节点的左还是右，cur只是一个变量，将新节点赋值给cur，只是改变了cur变量的值，而没有改变上一个节点的左或者是右，如果cur是上一个节点的左或者右的引用就可以不用parent了；所以还需要用parent来记录cur的父节点，插入的时候还要判断一下左右。
在这里插入图片描述

bool insert(const T& key)
{
	//判空
	if(_root==nullptr)
	{
		_root=new Node(keyl);
	}
	//找插入位置
	Node* cur=_root;
	Node* parent=nullptr;
	while(cur)
	{
		if(val<cur->_key)
		{
			parent=cur;
			cur=cur->_left;
		}
		else if(key>cur->_key)
		{
			parent=cur;
			cur=cur->_right;
		}
		else
		{
			return false;
		}
	}
	//判断左右
	if(val<parent->_key)
	{
		parent->_left=new Node(key);
	}
	else
	{
		parent->_right=new Node(key);
	}
	return true;
}

递归实现
1.思想与非递归大致相同，小于就往左递归，大于就往右递归，等于就返回false，为空就插入并返回true；

bool _Insert(Node*& root,K key)
{
	if(root==nullptr)
	{
		root=new Node(key);
		return true;
	}
	if(key<root->_key)
	{
		return _Insert(root->_left,key);
	}
	else if(key<root->_key)
	{
		return _Insert(root->_left,key);
	}
	else 
	{
		return false;
	}
}

3.删除

非递归实现
1.如果是空就返回false，删除失败

2.如果不是空，就找用cur找key的位置，还是按照小于往左走，反之往右走的原则查找，等于就跳出循环，找的同时用parent记录cur的父节点；

3.如果cur是nullptr就返回false；如果不是，那么就可以分为三种情况删除:

第一种是当前节点有一个孩子（或左或右），删除之后孩子要被parent领养，既然要cur的父节点领养cur的孩子，那么可定也需要判断cur是parent的左还是右。需要注意的是，当删除root的时候，root没有parent，需要直接更新root的位置,如果不处理这个情况，会发生parent的空指针的引用，因为parent初始化为nullptr。
在这里插入图片描述

第二种是当前节点没有孩子可以直接删除，这种情况可以融合到第一种情况中处理。
在这里插入图片描述

第三种是当前节点有左右两个孩子，那么久需要找一个节点来替代它之后，才能将它删除，这个替代节点可以是当前节点的左子树的最大节点,也就是最右节点，也可以是右子树的最小节点，也就是最左节点；删除后返回true删除成功。
在这里插入图片描述

bool Erase(T key)
{
	//判空
	if(_root==nullptr)
	{
		return false;
	}
	//找要删除的元素
	Node* cur=_root;
	Node* parent=nullptr;
	while(cur)
	{
		if(key<cur->_key)
		{
			parent=cur;
			cur=cur->_left;
		}
		else if(key>cur->_key)
		{
			parent=cur;
			cur=cur->_right;
		}
		else
		{
			break;
		}
	}
	//处理没找的情况
	if(cur==nullptr)
	{
		return false;
	}
	//处理当前节点没有孩子或者只有一个右孩子的情况
	if(cur->_left==nullptr)
	{
		//处理删除root的情况
		if(cur==_root)
		{
			_root=_root->_right;
		{
		//判断cur是parent的左还是右
		else if(parent->_left==cur)
		{
			parent->_left=cur->_right;
		}
		else
		{
			parent->_right=cur->_right;
		}
		delete cur;
	}
	//处理当前节点没有孩子或者只有一个左孩子的情况
	else if(cur->_right==nullptr)
	{
		//处理删除root的情况
		if(cur==_root)
		{
			_root=_root->_left;
		{
		//判断cur是parent的左还是右
		else if(parent->_left==cur) 
		{
			parent->_left=cur->_left;
		}
		else
		{
			parent->_right=cur->_left;
		}
		delete cur;
	}
	//处理当前节点有两个孩子的情况
	else
	{
		//找当前节点的右树的最小节点
		Node* rightMin=cur->_right;
		Node* pRightMin=cur;
		while(rightMin->_left)
		{
			pRightMin=rightMin;
			rightMin=rightMin->_left;
		}
		//替换
		cur->_key=rightMin->_key;
		//右树的最小节点的父节点领养右树的最小节点的右孩子
		if(pRightMin->_left==rightMin)
		{
			pRightMin->_left=rightMin->_right;
		}
		else
		{
			pRightMin->_right=rightMin->_right;
		}
		//删除右树的最小节点
		delete rightMin;
	}
	return true;
}

递归实现
1.判空，空就返回false

2.找key,小于就往左递归，大于就往右递归。

3.删除也是分三种情况，没孩子，有一个孩子，有两个孩子

4.没孩子可以与有一个孩子的情况合并处理，这里与非递归不同的是，不需要当前节点是父节点的左还是右，因为当前节点实参的引用，不是单纯地比指针变量，可以直接赋值。

5.两个孩子的情况也省略了父节点的环节，不同的是，这次节点的值不是赋值，而是交换，交换后要删除的节点就是左子树的最右节点，或者是右子树的最左节点，这两个节点都是只有一个孩子或者是没有孩子，因此可以将问题转化为前两种情况进行处理，找的是左子树就往左递归一步，右子树就往右递归一步即可。

bool _Erase(Node*& root,K key)
{
	if(root==nullptr)
	{
		return false;
	}
	if(key<root->_key)
	{
		return _Erase(root->_left,key);
	}
	else if(key>root->_key)
	{
		return _Erase(root->_right,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(leftMax->_key,root->_key);
			return _Erase(root->_left,key);
		}
		delete del;
		return true;
	}
	
}

3.查找

非递归实现

1.查找很简单了，其实已经包含在插入和删除中了，找到val就返回true反之返回false

bool Find(K key)
{
	if(_root==nullptr)
	{
		return false;
	}
	Node* cur=_root;
	while(cur)
	{
		if(key<cur->_key)
		{
			cur=cur->_left;
		}
		else if(key>cur->_key)
		{
			cur=cur->_right;
		}
		//相等就返回true
		else
		{
			return true;
		}
	}
	//找完了还没有找到就返回false
	return false;
}

递归实现

bool _Find(Node* root,K key)
{
	if(root==nullptr)
	{
		return false;
	}
	if(key<root->_key)
	{
		return _Find(root->_left,key);
	}
	if(key>root->_key)
	{
		return _Find(root->_right,key);
	}
	else
	{
		return true;
	}
}

4.析构

1.这里用递归实现析构，用递归就必须使用后序遍历的方式实现，因为节点的左右节点不先释放，会造成内存泄漏。

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

5.拷贝构造

1.拷贝构造也是用递归实现，创建新的节点，然后分贝递归创建左节点和右节点，最后返回root

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

6. 中序遍历

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

二、 二叉搜索树的应用

（一）k模型

k模型即只有可以作为关键吗，结构中只需要存储可以即可，关键码即为需要搜索到值；
比如检查一个单词的拼写是否正确，其原理就是构建一个二叉搜索树，将一个单词集合存放到这个结构中，单词也可以按照ascll码值排序，然后检查这个单词是否存在，存在即正确，不存即不正确；
其次就是排序

（二）kv模型

kv模型每一个关键码key，都有一个对应的值value，即<key,value>的键值对；
可以应用于单词翻译，比如英汉互译，也可以查找一个单词出现的次数；
key 和value可以是同类型的，例如<string,string>；
我们将上面的代码小小的改造一下就可以是kv模型，可以试验一下英汉互译；

思想
1.模板参数要变成来两个模型，一个key一个value
2.node节点需要改变，再加一个value
3.插入需改变，传参要传一个key一个value，插入的时候要插入两个值
4.查找需改变的是返回值，不在是返回bool而是返回node节点
5.删除不改变

代码实现

#pragma once
#include<iostream>
#include<cassert>
#include<string>
using namespace std;
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:
		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
				{
					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;
					}
					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;
	};
}

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

1.因为不管是插入还是删除都需要先查找，所以查找代表了二叉搜索树性能;
2.二叉搜索树其实是不稳定的，相同的关键码集合，根值不同就会产生不一样的树结构
最右好情况查找平均次数下是在它是完全二叉树或者近似完全二叉树的情况下是log2N
在这里插入图片描述
3.最差情况下是N/2
在这里插入图片描述

kk1125778230
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
二叉树-基于C++实现的二叉搜索树.zip
04-26
二叉搜索树（Binary Search Tree，BST）是二叉树的一个特例，它具有以下特性：对于任意节点，其左子树中的所有节点的值都小于该节点的值，而右子树中的所有节点的值都大于该节点的值。这种特性使得二叉搜索树非常...
cpp-AVL树能一直保持平衡的二叉搜索树
08-16
AVL树,能一直保持平衡的二叉搜索树
二叉搜索树（CPP实现简单易懂）
CODER-GODV的博客
10-23 107
当要删除的结点左右结点都不为空时，首先将该结点的数据和它中序遍历右边的第一个结点互换数据，然后必定会转换为第一种情况，它的右边第一个结点的左节点必定为空。，如果根结点大于目标结点，递归调用根结点的左子树为根结点；如果根结点小于目标结点， 递归调用根结点的右子树为根结点；如果根结点等于目标结点，返回该结点。当要删除的结点的左右结点至少有一个为空的情况，就将当前结点的指针改为左右结点中的一个并将自身开辟的空间的空间释放。其实就是查找的过程，一直找到空指针，就把空指针赋值为要插入的数据并返回。
关于无法搜索文件中包含指定字符的问题的解决方法
04-23 418
当您使用“文件中的一个字或词组”搜索条件搜索包含文本的文件时，搜索结果中可能没有那些包含您所指定的文本的文件。例如，.log、.dll、.js、.asp、.xml、.xsl、.hta、.css、.wsh、.cpp、.c 或 .h 文件或没有文件扩展名的文件即使含有您所指定的文本，也可能不会出现在搜索结果中。即使您在“全部或部分文件名”框中指定了文件名或文件类型，也可能会发生该问题。原因对于包含您所
【C++】二叉搜索树
qq_62939852的博客
04-18 934
从根开始比较，查找，比根大则往右边走查找，比根小则往左边走查找。 最多查找高度次，走到到空，还没找到，这个值不存在非空右子树的所有值大于根节点的值 左右子树都是二叉搜索树第一个不满足，因为值为5的节点在值为10的节点的右边，正常来说10的右边都应该比10大分为两种情况 若插入的值在二叉树中不存在，则通过比较进行插入若插入11，因为11比8大，所以跟10比较，而11比10大，所以走10的右子树14，14与11比较，因14>11，所以走14的左子树13，11与13比较，因13>11，故作为13的左子树，遇见NU
数据结构篇八：二叉搜索树
忘忧.
03-02 967
前面我们已经学习过了二叉树，二叉搜索树是在二叉树的基础上增添了一些规则，使其能完成快速查找的功能，同时它也帮助我们更好的理解后续将要学习的map和set。此部分的学习主要是为了后续的AVL树和红黑树打基础，因此需要熟练理解，希望能与大家共同进步。如果大家发现有什么错误的地方，可以私信或者评论区指出喔。我会继续深入学习C++，希望能与大家共同进步，那么本期就到此结束，让我们下期再见！！！
Cpp8 — 二叉搜索树
weixin_60320290的博客
08-02 85
C++
eagleeye05#cpp-note#33-二叉搜索树的后序遍历序列1
07-25
假设输入的数组的任意两个数字都互不相同扩展：判断数组是不是某BST的前序遍历结果使用递归，利用后序遍历的性质bool dfs(int left, int rig
cpp-常用算法的C实现
08-16
本资源“cpp-常用算法的C实现”显然聚焦于利用C++语言实现一些经典的算法，这对于学习和理解算法原理及其应用至关重要。以下是这些算法的详细说明： 1. **二叉树和遍历**： - 二叉树是一种数据结构，每个节点最多...
cpp-OpenAT开源算法交易库
08-16
例如，二叉搜索树（BST）可用于快速查找特定的金融产品，而哈希表（hash table）则可以提供常数时间的查找和插入操作。 ### 5. 低延迟通信协议 OpenAT可能需要连接到交易所或数据供应商，因此熟悉低延迟通信协议，...
二叉检索树.cpp 数据结构二叉检索树
12-02
二叉检索树 c++数据结构 对应于数据机构与算法分析（c++版）第三版或第二版 Clifford A.Shaffer 重庆大学使用教材
算法导论第十二章-二叉搜索树-Cpp代码实现
YY的博客
06-12 338
算法导论第十二章-二叉搜索树-Cpp代码实现。 实现了BST（二叉搜索树）的一些基本操作，比如插入，删除，查找元素，查找前驱后继等。
二叉查找树（二）- C++实现
生活需要深度
06-30 379
上一章介绍了"二叉查找树的相关理论知识，并通过C语言实现了二叉查找树"。这一章给出二叉查找树的C++版本。这里不再对树的相关概念进行介绍，若遇到不明白的概念，可以在上一章查找。目录 1. 二叉树查找树 2. 二叉查找树的C++实现 3. 二叉查找树的C++实现(完整源码) 4. 二叉查找树的C++测试程序转载请注明出处：二叉查找树(二)之 C++的实现 - 如果天空不死 - 博客园更多内容: 数据结构与算法系列 目录 (01) 二叉查找树(一)之 图文解析 和 C语言的实现 (02) 二叉查找树(二)之 C
Cpp||二叉搜索树的学习与实现
Template Code
08-15 260
神奇的二叉搜索树
二叉搜索树的实现（C++）
TANGY的博客
04-19 2388
二叉搜索树又称为二叉排序树，它可能是一棵空树，亦或是一棵具有以下性质的二叉树： 若它的左子树不为空，则左子树上所有结点的值都小于根结点的值。 若它的右子树不为空，则右子树上所有结点的值都大于根结点的值。 它的左右子树也分别为二叉搜索树。 二叉搜索树的操作 1.二叉搜索树的查找 实现思路： 若结点不为空： 如果结点的值key == 查找的key，返回该结点； 如果结点的值key ...
C语言 之 理解指针（1）
fallzzzzz的博客
07-20 1268
就是先获取该数组的首元素的地址，从前面我们知道，指针的类型的作用是指针+1 所跳过的字节数，int为整形，大小为4个字节，所以p+1就跳过4个字节，p+2就跳过8个字节，计算机的CPU（中央处理器）在处理数据的时候，需要的数据是在内存中读取的，处理后数据也会放回内存中，如果想对这些空间进行高效的管理，就可以。并且我们知道，数组的元素存放是随着下标增长，内存地址变大的。上面的代码创建了一个整型变量n，因为一个整形的大小是4个字节，所以内存中申请了4个字节，⽤于存放整数10，其中每个字节都有地址。
【C语言】分支与循环（下）
weixin_74076508的博客
07-24 863
我们怎么想这个问题呢？1. 要从100~200之间找出素数，⾸先得有100~200之间的数，这⾥可以使⽤循环产生100~200的数字2. 怎么判断i是否为素数呢？我们可以使用试除法，也就是可以用 2 ~ i-1 之间的数字去试除i，那首先需要产⽣2~i-1之间的数字，也可以使⽤循环解决。3. 如果2~i-1之间有数字能整除i，则i不是素数，如果都不能整除，则i是素数。
【C++】C++中的find方法介绍
qq_35902025的博客
07-25 316
find 函数是 std::string 类中非常有用的成员函数之一，它提供了灵活的方式来查找子字符串或字符。使用 npos 可以检查查找操作是否成功。
《Cross-Modal Dynamic Transfer Learning for Multimodal Emotion Recognition》
最新发布
buyaotutou的博客
07-25 1105
例如：第一章 Python 机器学习入门之pandas的使用文章链接Multimodal Emotion Recognition is an important research area for developing human-centric applications, especially in the context of video platforms. Most existing models have attempted to develop sophisticated fusion tech
二叉搜索树：查找后继与前驱结点
"二叉搜索树(二叉排序树)是一种特殊的二叉树，其每个节点的左子树上的所有节点值都小于该节点值，而右子树上的所有节点值都大于该节点值。中序遍历二叉搜索树会得到一个递增序列。在二叉搜索树中查找后继和前驱结点...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值