c++二插搜索树

最新推荐文章于 2024-10-01 05:07:35 发布
最新推荐文章于 2024-10-01 05:07:35 发布
阅读量552 收藏
点赞数
分类专栏： c++逆天改命 文章标签： c++ 算法 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/btzxlin/article/details/128759065
版权

1二插搜索树的概念

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

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

image-20220513124614728

2二插搜索树的实现

#pragma once
#include <iostream>
using std::cout;
template <class K>
struct BSTreeNode
{
	K _key;
	BSTreeNode<K>* _left;
	BSTreeNode<K>* _right;

	BSTreeNode(const K& key)
		:_key(key)
		, _left(nullptr)
		, _right(nullptr)
	{}
};

template <class K>
class BSTree
{
public:
	typedef BSTreeNode<K> Node;
	BSTree()
		:_root(nullptr)
	{}
	~BSTree()
	{
		Destroy(_root);
		_root = nullptr;
	}
	BSTree(const BSTree<K>& t)
	{
		_root = CopyTree(t._root);
	}
	BSTree<K>& operator=(BSTree<K> t)
	{
		std::swap(_root, t._root);
		return *this;
	}

	bool Insert(const K& key) 
	{
		//今天我们实现的二叉搜索树不允许插入同一个值
		if (_root == nullptr)
		{
			//第一次插入数据
			_root = new Node(key);
			return true;
		}
		Node* cur = _root;
		Node* parent = nullptr;
		while (cur)
		{
			parent = cur;
			if (cur->_key > key) 
			{
				cur = cur->_left;
			}
			else if (cur->_key < key) 
			{
				cur = cur->_right;
			}
			else//树中存在相同的值
				return false;
		}
		cur = new Node(key);
		//判断我们插入的节点是在parent的左还是右
		if (parent->_key > key)
		{
			parent->_left = cur;
		}
		else
		{
			parent->_right = cur;
		}
		return true;
	}
	bool Find(const K& key)
	{
		Node* cur = _root;
		while (cur)
		{
			if (cur->_key > key)
			{
				cur = cur->_left;
			}
			else if (cur->_key < key)
			{
				cur = cur->_right;
			}
			else
			{
				return true;
			}
		}
		return false;
	}

	bool Erase(const K& key)
	{
		Node* cur = _root;
		Node* parent = nullptr;
		while (cur)
		{
			
			if (cur->_key > key)
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (cur->_key < key)
			{
				parent = cur;
				cur = cur->_right;
			}
			else
			{
				//找到了 处理删除的细节
				//被删除的节点右四种情况
				//1.左右孩子都为空（叶子节点） 2. 左为空右不为空  3.右为空左不为空  4.左右都不为空
				if (cur->_left == nullptr)
				{
					//这里我们可以处理情况1和2，让父亲指向cur的右
					if (parent->_left == cur)
					{
						parent->_left = cur->_right;
					}
					else
					{
						parent->_right = cur->_right;
					}
					delete cur;
					return true;
				}
				else if (cur->_right == nullptr)
				{
					//这里我们可以处理情况3，让父亲指向cur的左
					if (parent->_left == cur)
					{
						parent->_left = cur->_left;
					}
					else
					{
						parent->_right = cur->_left;
					}
					delete cur;
					return true;
				}
				else
				{
					//情况4，左右都不为空，这种情况我们可以将被删节点和其右子树的最左节点（或左子树的最右节点互换位置）
					//互换之后删除节点，不会破坏搜索树的结构
					//这里我们以右子树的最左节点互换为例
					Node* minRight = cur->_right;
					Node* minParent = cur;
					while (minRight->_left)
					{
						minParent = minRight;
						minRight = minRight->_left;
					}
					std::swap(cur->_key, minRight->_key);

					//当然我们也可以选择直接覆盖被删节点
					//cur->_key = minRight->_key;

					//然后删除minRight节点即可
					//注意这里一定不能再次递归调用Erase(key),因为互换位置之后搜索树结构已经被破坏
					if (minParent->_left == minRight)
					{
						minParent->_left = minRight->_right;
					}
					else
					{
						minParent->_right = minRight->_right;
					}
					delete minRight;
					return true;
				}
			}

		}
		//没找到
		return false;
	}

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

	void InOrder()
	{
		_InOrder(_root);
	}
private:
	void Destroy(Node* root)
	{
		if (root == nullptr)
			return;
		Destroy(root->_left);
		Destroy(root->_right);
		delete root;
	}
	Node* CopyTree(Node* root)
	{
		if (root == nullptr)
		{
			return nullptr;
		}
		Node* copyNode = new Node(root->_key);
		copyNode->_left = CopyTree(root->_left);
		copyNode->_right = CopyTree(root->_right);
		return copyNode;
	}
	bool _EraseR(Node*& root, const K& key)
	{
		if (root == nullptr)//不存在
			return false;
		if (root->_key > key)
		{
			_EraseR(root->_left, key);
		}
		else if (root->_key < key)
		{
			_EraseR(root->_right, key);
		}
		else
		{
			//找到了该被删除的值
			Node* del = root;
			if (root->_left == nullptr)
			{
				//我们传参的时候传的是Node*& root，因此root不仅指向被删除的值
				//root还恰好是root的父亲节点指向root的那个指针
				//我们只需改变root的指向即可
				root = root->_right;
			}
			else if (root->_right == nullptr)
			{
				root = root->_left;
			}
			else
			{
				Node* minRight = root->_right;
				while (minRight->_left)
				{
					minRight = minRight->_left;
				}
				std::swap(minRight->_key, root->_key);
				return _EraseR(root->_right, key);//这次递归调用最终一定会走到左为空的情况
			}
			delete del;
			return true;
		}

	}
	bool _FindR(Node* root, const K& key)
	{
		if (root == nullptr)
			return false;
		if (root->_key > key)
		{
			_FindR(root->_left, key);
		}
		else if (root->_key < key)
		{
			_FindR(root->_right, key);
		}
		else
			return true;
	}
	void _InOrder(Node* root)
	{
		if (root == nullptr)
			return;
		_InOrder(root->_left);
		cout << root->_key << " ";
		_InOrder(root->_right);
	}


private:
	Node* _root;
};

3.二插搜索树的应用

  1. K模型：K模型即只有key作为关键码，结构中只需要存储Key即可，关键码即为需要搜索到的值。
    比如：给一个单词word，判断该单词是否拼写正确，具体方式如下：
    以单词集合中的每个单词作为key，构建一棵二叉搜索树
    在二叉搜索树中检索该单词是否存在，存在则拼写正确，不存在则拼写错误。
  2. KV模型：每一个关键码key，都有与之对应的值Value，即<Key, Value>的键值对。该种方式在现实生活中非常常见：比如英汉词典就是英文与中文的对应关系，通过英文可以快速找到与其对应的中文，英文单词与其对应的中文<word, chinese>就构成一种键值对；再比如统计单词次数，统计成功后，给定单词就可快速找到其出现的次数，单词与其出现次数就是<word,count>就构成一种键值对。
    比如：实现一个简单的英汉词典dict，可以通过英文找到与其对应的中文，具体实现方式如下：
    <单词，中文含义>为键值对构造二叉搜索树，注意：二叉搜索树需要比较，键值对比较时只比较Key查询英文单词时，只需给出英文单词，就可快速找到与其对应的key

现在我们将上面的搜索二叉树改成kv模型

#pragma once
#include <iostream>
using std::cout;
template <class K, class V>
struct BSTreeNode
{
	K _key;
	V _val;
	BSTreeNode<K, V>* _left;
	BSTreeNode<K, V>* _right;

	BSTreeNode(const K& key, const V& val)
		:_key(key)
		,_val(val)
		, _left(nullptr)
		, _right(nullptr)
	{}
};

template <class K, class V>
class BSTree
{
public:
	typedef BSTreeNode<K, V> Node;
	BSTree()
		:_root(nullptr)
	{}
	~BSTree()
	{
		Destroy(_root);
		_root = nullptr;
	}
	BSTree(const BSTree<K, V>& t)
	{
		_root = CopyTree(t._root);
	}
	BSTree<K, V>& operator=(BSTree<K, V> t)
	{
		std::swap(_root, t._root);
		return *this;
	}

	bool Insert(const K& key, const V& val)
	{
		//今天我们实现的二叉搜索树不允许插入同一个值
		if (_root == nullptr)
		{
			//第一次插入数据
			_root = new Node(key, val);
			return true;
		}
		Node* cur = _root;
		Node* parent = nullptr;
		while (cur)
		{
			parent = cur;
			if (cur->_key > key)
			{
				cur = cur->_left;
			}
			else if (cur->_key < key)
			{
				cur = cur->_right;
			}
			else//树中存在相同的值
				return false;
		}
		cur = new Node(key, val);
		//判断我们插入的节点是在parent的左还是右
		if (parent->_key > key)
		{
			parent->_left = cur;
		}
		else
		{
			parent->_right = cur;
		}
		return true;
	}
	Node* Find(const K& key)
	{
		Node* cur = _root;
		while (cur)
		{
			if (cur->_key > key)
			{
				cur = cur->_left;
			}
			else if (cur->_key < key)
			{
				cur = cur->_right;
			}
			else
			{
				return cur;
			}
		}
		return nullptr;
	}

	bool Erase(const K& key)
	{
		Node* cur = _root;
		Node* parent = nullptr;
		while (cur)
		{

			if (cur->_key > key)
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (cur->_key < key)
			{
				parent = cur;
				cur = cur->_right;
			}
			else
			{
				//找到了 处理删除的细节
				//被删除的节点右四种情况
				//1.左右孩子都为空（叶子节点） 2. 左为空右不为空  3.右为空左不为空  4.左右都不为空
				if (cur->_left == nullptr)
				{
					//这里我们可以处理情况1和2，让父亲指向cur的右
					if (parent->_left == cur)
					{
						parent->_left = cur->_right;
					}
					else
					{
						parent->_right = cur->_right;
					}
					delete cur;
					return true;
				}
				else if (cur->_right == nullptr)
				{
					//这里我们可以处理情况3，让父亲指向cur的左
					if (parent->_left == cur)
					{
						parent->_left = cur->_left;
					}
					else
					{
						parent->_right = cur->_left;
					}
					delete cur;
					return true;
				}
				else
				{
					//情况4，左右都不为空，这种情况我们可以将被删节点和其右子树的最左节点（或左子树的最右节点互换位置）
					//互换之后删除节点，不会破坏搜索树的结构
					//这里我们以右子树的最左节点互换为例
					Node* minRight = cur->_right;
					Node* minParent = cur;
					while (minRight->_left)
					{
						minParent = minRight;
						minRight = minRight->_left;
					}
					std::swap(cur->_key, minRight->_key);

					//当然我们也可以选择直接覆盖被删节点
					//cur->_key = minRight->_key;

					//然后删除minRight节点即可
					//注意这里一定不能再次递归调用Erase(key),因为互换位置之后搜索树结构已经被破坏
					if (minParent->_left == minRight)
					{
						minParent->_left = minRight->_right;
					}
					else
					{
						minParent->_right = minRight->_right;
					}
					delete minRight;
					return true;
				}
			}

		}
		//没找到
		return false;
	}

	bool EraseR(const K& key)
	{
		return _EraseR(_root, key);
	}
	Node* FindR(const K& key)
	{
		return _FindR(_root, key);
	}

	void InOrder()
	{
		_InOrder(_root);
	}
private:
	void Destroy(Node* root)
	{
		if (root == nullptr)
			return;
		Destroy(root->_left);
		Destroy(root->_right);
		delete root;
	}
	Node* CopyTree(Node* root)
	{
		if (root == nullptr)
		{
			return nullptr;
		}
		Node* copyNode = new Node(root->_key, root->_val);
		copyNode->_left = CopyTree(root->_left);
		copyNode->_right = CopyTree(root->_right);
		return copyNode;
	}
	bool _EraseR(Node*& root, const K& key)
	{
		if (root == nullptr)//不存在
			return false;
		if (root->_key > key)
		{
			_EraseR(root->_left, key);
		}
		else if (root->_key < key)
		{
			_EraseR(root->_right, key);
		}
		else
		{
			//找到了该被删除的值
			Node* del = root;
			if (root->_left == nullptr)
			{
				//我们传参的时候传的是Node*& root，因此root不仅指向被删除的值
				//root还恰好是root的父亲节点指向root的那个指针
				//我们只需改变root的指向即可
				root = root->_right;
			}
			else if (root->_right == nullptr)
			{
				root = root->_left;
			}
			else
			{
				Node* minRight = root->_right;
				while (minRight->_left)
				{
					minRight = minRight->_left;
				}
				std::swap(minRight->_key, root->_key);
				return _EraseR(root->_right, key);//这次递归调用最终一定会走到左为空的情况
			}
			delete del;
			return true;
		}

	}
	Node* _FindR(Node* root, const K& key)
	{
		if (root == nullptr)
			return nullptr;
		if (root->_key > key)
		{
			_FindR(root->_left, key);
		}
		else if (root->_key < key)
		{
			_FindR(root->_right, key);
		}
		else
			return root;
	}
	void _InOrder(Node* root)
	{
		if (root == nullptr)
			return;
		_InOrder(root->_left);
		cout << root->_key << " ";
		_InOrder(root->_right);
	}


private:
	Node* _root;
};

现在我们实现一个简易字典试试

#include "BinarySearchTree of KV.hpp"
#include <string>
using namespace std;
int main()
{
	BSTree<string, string> dict;
	dict.Insert("hello", "你好");
	dict.Insert("apple", "苹果");
	dict.Insert("Chinese", "中文");
	dict.Insert("insert", "插入");
	
	string str;
	while (cin >> str)
	{
		auto ret = dict.FindR(str);
		if (ret)
		{
			cout << "对应的中文" << ":" << ret->_val << endl;
		}
		else
			cout << "不存在，请重新输入" << endl;
	}

	return 0;
}

下面我们在利用kv模型实现一下统计字符串出现的次数

#include "KVBinarySearchTree.h"

int main()
{
	string arr[] = { "苹果", "香蕉", "橘子", "苹果", "香蕉", "苹果" };
	BSTree<string, int> cnt;
	for (const auto& str : arr)
	{

		auto ret = cnt.Find(str);
		if (ret == nullptr)
		{
			cnt.Insert(str, 1);
		}
		else
		{
			ret->_val++;
		}
	}
	cnt.InOrder();
	return 0;
}

image-20220518005632616

逃跑的机械工
关注
专栏目录
C++实现二叉树搜索树
12-18
功能：插入、查找、删除、清除整个树、返回最大值、返回最小值、前序遍历、中序遍历、后序遍历。 注：此二叉树允许插入相同的值
二叉搜索树的c++实现
07-05
使用二叉链表和c++来实现二叉搜索树，提供插入、删除、遍历、求最小节点、最大最节点等操作。
二叉树-基于C++实现的二叉搜索树.zip
04-26
在C++中实现二叉搜索树，我们需要定义一个节点结构，包含节点的值、左子节点和右子节点的指针。例如： ```cpp struct TreeNode { int val; TreeNode* left; TreeNode* right; TreeNode(int x) : val(x), left...
C++ 二叉搜索树(BST)的实现方法
08-30
C++ 二叉搜索树(BST)的实现方法 C++ 二叉搜索树(BST)是一种特殊的二叉树，它具有以下特征： 1. 二叉搜索树的每个节点都包含一个键值（key）和一个值（value）。 2. 对于任意一个节点，左子树中的键值都小于该节点...
数据结构C++二分搜索树
05-11
### 数据结构：C++ 实现二分搜索树 #### 概述 本篇文章将详细介绍如何在C++中实现一个二分搜索树（Binary Search Tree，BST），并具体讲解其查找、删除以及输出功能的实现方法。此外，我们还将探讨如何通过构造...
c++ 使用 Graham 扫描的凸包（Convex Hull using Graham Scan）
csdn_aspnet的专栏
09-26 1102
对于剩余的点，我们跟踪最近的三个点，并找到它们形成的角度。如果这些点的方向（按相同顺序考虑它们）不是逆时针的，我们丢弃 c，否则我们保留它。因此，第六步逐个处理点需要 O(n) 时间，假设堆栈操作需要 O(1) 时间。总体复杂度为 O(n) + O(nLogn) + O(n) + O(n)，即 O(nLogn)。在每个步骤中，算法都会检查添加到凸包中的最后两个点是否形成右转。格雷厄姆扫描算法是一种简单而有效的算法，用于计算一组点的凸包。凸包用于各种计算几何算法，例如查找最近的点对和计算一组点的直径。
【C++】红黑树的封装——同时实现map和set
Mesar的博客
09-27 644
学习map和set，深入了解底层，通过模拟实现，学习高效数据结构与容器的关系，也帮助我们更好了解和使用容器
求n的阶乘的相反数（c语言）
scy2429828663的博客
09-26 410
【代码】求n的阶乘的相反数（c语言）
简易STL实现 | Set 的实现
AsherGu的博客
09-26 442
如何使用；代码实现及其他（包括之前红黑树可以运行实现）
【C++】stack和queue的使用及注意事项
wangnaisheng的专栏
09-28 642
【C++】stack和queue的使用及注意事项
C语言 | Leetcode C语言题解之第448题找到所有数组中消失的数字
m0_59237910的博客
10-01 297
C语言 | Leetcode C语言题解之第448题找到所有数组中消失的数字
C/C++语言基础--C++运算符重载以及其重载限制
weixin_74085818的博客
09-27 986
运算符重载，就是赋予运算符新的含义。它是重载系统内部运算符的函数，是实现类静态多态性的方式之一。它本质上是函数重载。// 假设都属于学生类// 想要对比谁的年龄大，试想一下，能不能像正常比较大小那样直接比较呢？答案当然是可以的，这个就是我们这节课要学习的**“运算符重载”**，这样进行重载后，类更像是一种自定义数据类型。实际上，我们已经在不知不觉之中使用了运算符重载。列如：我们习惯使用的对整数，浮点数运用+、-、*、/，其实计算机对整数和浮点数的操作过程是不一样的，这个主要是整数和浮点数的。
C++ | Leetcode C++题解之第448题找到所有数组中消失的数字
最新发布
Ddddddd_158的博客
10-01 251
C++ | Leetcode C++题解之第448题找到所有数组中消失的数字
06.C/C++内存管理
2402_82670467的博客
09-29 1053
在这里C++的内存管理相较于C作出了许多升级，下面我们就来了解一下。我们先来看一下下面的问题，温习一下C的内存分布 在 C/C++中，内存主要分为以下几个部分： 一、栈（Stack） 1. 存储内容： - 局部变量：函数内部声明的非静态变量。 - 函数参数：传递给函数的参数。 - 函数调用信息：如返回地址等。 2. 特点： - 先进后出（LIFO）的数据结构。 - 内存由编译器自动管理，当函数被调用时分配空间，函数返回时自动释放。 - 空间相对较小，通常几兆字节。 二、堆（Heap）
【C++打怪之路Lv5】-- 类和对象（下）
Sweeney_001的博客
09-29 785
类和对象(下)：初始化列表，explicit关键字、static成员、友元、内部类、匿名对象
C--结构体和位段的使用方法
一年，我很需要这一年
09-26 1475
C--结构体和位段的使用方法
C++：STL（四）之vector的基本介绍与使用方式|容器接口
白乐天_ξ( ✿＞◡❛)的博客
09-28 1168
本文主要是介绍vector容器以及接口的使用方式，和string类的那一节相似！
c++ day06
yangh1231的博客
09-25 353
【代码】c++ day06。
set和map
2302_79795489的博客
09-26 215
在 C++ 中，set和map是两个常用的容器，它们分别在<set>和<map>头文件中定义。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

逃跑的机械工

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

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

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

打赏作者

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

抵扣说明：

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

余额充值