当前位置： 首页 > article >正文

C++ 搜索二叉树

article 2024/10/8 11:32:59

大家好呀，我是残念，希望在你看完之后，能对你有所帮助，有什么不足请指正！共同学习交流哦（不能私学，谁私学谁是在这里插入图片描述
）
本文由：残念ing原创CSDN首发，如需要转载请通知
个人主页：残念ing-CSDN博客，欢迎各位→点赞👍 + 收藏⭐️ + 留言📝
📣系列专栏：残念ing 的C++进阶系列专栏——CSDN博客
请添加图片描述

什么是搜索二叉树

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

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

在这里插入图片描述
时间复杂度：增删查改时间复杂度O(N)

二叉搜索树的查找

  1. 从根开始比较，查找比根大则往右边走查找，比根小则往左边走查找。
  2. 最多查找高度次，走到空，还没有找到，说明要找的值不在。

二叉搜索树的插入

  1. 树为空，则直接新增节点，赋值给root指针
  2. 树不为空，按二叉搜索树性质插入位置，插入新的节点

二叉搜索树的删除

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

  1. 要删除的结点无孩子结点
  2. 要删除的结点只有左孩子结点
  3. 要删除的结点只有右孩子结点
  4. 要删除的结点既有左孩子，又有右孩子结点

解决办法：
a. 可以与2或3两个情况结合起来
b. 删除该结点且使被删除结点的双亲结点指向被删除结点的左孩子结点—直接删除
c. 删除该结点且使被删除结点的双亲结点指向被删除结点的右孩子结点—直接删除
d. 在它的右子树中寻找中序下的第一个结点（最小结点）,用它的值填补到被删除结点中，再来处理该结点的删除问题–替换法删除
在这里插入图片描述

二叉搜索树的实现

#pragma once

#include<iostream>
using namespace std;

template<class K>

struct BSTNodes
{
	K _key;
	BSTNodes<K>* _left;
	BSTNodes<K>* _right;

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


template <class K>

class BSTree
{
	typedef BSTNodes<K> NOde;
public:
	
	//添加
	bool Inster(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;
	}

	void Inorder()
	{
		_Inorder(_root);
		cout << endl;
	}
	bool Delete(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
			{
				//delete一个或0个孩子
				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;
				}
				if (cur->_right == nullptr)
				{
					if (parent == nullptr)
					{
						_root = cur->_left;
					}
					else
					{
						if (parent->_right == cur)
						{
							parent->_right = cur->_left;
						}
						else
						{
							parent->_left = cur->_left;
						}
					}
					delete cur;
					return true;
				}

				//两个孩子
				//右子树最小节点作为代替节点
				NOde* rightMinp = cur;
				NOde* rightMin = cur->_right;
				while (rightMin->_left)
				{
					rightMinp = rightMin;
					rightMin = rightMin->_left;
				}
				cur->_key = rightMin->_key;

				if (rightMinp->_left == rightMin)
					rightMinp->_left = rightMin->_right;
				else
					rightMinp->_right = rightMin->_right;

				delete rightMin;
				return true;
			}
		}
		return false;
	}
private:
	void _Inorder(NOde* root)
	{
		if (root == nullptr)
		{
			return;
		}
		_Inorder(root->_left);
		cout << root->_key << " ";
		_Inorder(root->_right);
	}

private:
	NOde* _root=nullptr;
};

上面的实现是一种K模型，那什么是K模型呢？？？

两个模型

1. K模型

K模型：K模型即只有key作为关键码，结构中只需要储存key即可，关键码即为需要搜索到的值。
比如：给一个单词，判断该单词是否拼写正确
~以词库中所有单词集合中的每个单词作为key，构建一课二叉搜索树；
~在二叉搜索树中检查该单词是否存在，存在则拼写正确，不存在则拼写错误；

2. KV模型

KV模型：每一个关键码key，都有与之对应的值value，即<key,value>的键值对。这种模型在生活中很常见：
~比如英汉词典就是英文与中文的对应关系，通过英文可以快速找到与其对应的中文，英文单词与其对应的中文<word, chinese>就构成一种键值对；
~再比如统计单词次数，统计成功后，给定单词就可快速找到其出现的次数，单词与其出现次数就是<word, count>就构成一种键值对；

#pragma once
#pragma once

#include<iostream>
using namespace std;

template<class K , class V>

struct BSTNodes
{
	K _key;
	V _value;
	BSTNodes<K,V>* _left;
	BSTNodes<K, V>* _right;

	BSTNodes(const K& key,const V& value)
		: _key(key)
		, _value(value)
		, _left(nullptr)
		, _right(nullptr)
	{}
};


template <class K,class V>

class KVBSTree
{
	typedef BSTNodes<K,V> NOde;
public:

	//添加
	bool Inster(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;
	}

	void Inorder()
	{
		_Inorder(_root);
		cout << endl;
	}
	bool Delete(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
			{
				//delete一个或0个孩子
				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;
				}
				if (cur->_right == nullptr)
				{
					if (parent == nullptr)
					{
						_root = cur->_left;
					}
					else
					{
						if (parent->_right == cur)
						{
							parent->_right = cur->_left;
						}
						else
						{
							parent->_left = cur->_left;
						}
					}
					delete cur;
					return true;
				}

				//两个孩子
				//右子树最小节点作为代替节点
				NOde* rightMinp = cur;
				NOde* rightMin = cur->_right;
				while (rightMin->_left)
				{
					rightMinp = rightMin;
					rightMin = rightMin->_left;
				}
				cur->_key = rightMin->_key;

				if (rightMinp->_left == rightMin)
					rightMinp->_left = rightMin->_right;
				else
					rightMinp->_right = rightMin->_right;

				delete rightMin;
				return true;
			}
		}
		return false;
	}
private:
	void _Inorder(NOde* root)
	{
		if (root == nullptr)
		{
			return;
		}
		_Inorder(root->_left);
		cout << root->_key <<" " << root->_value << " ";
		_Inorder(root->_right);
	}

private:
	NOde* _root = nullptr;
};

总结

插入和删除操作都必须查找，查找的效率代表了二叉搜索树中各个操作的性能。
对有n个结点的二叉搜索树，若每个元素查找的概率相等，则二叉搜索树平均查找长度是结点在二叉搜索树的深度的函数，即结点越深，则比较次数越多。
最优情况下，二叉搜索树为完全二叉树（或接近），其平均比较次数为：log_2 N
最差情况下，二叉搜索树退化为单支数（或者类似单支），其平均比较次数为：N/2

在这里插入图片描述


http://www.kler.cn/news/337339.html

相关文章：

  • github项目学习——ruoyi-vue-pro
  • UE5 武器IK瞄准系统
  • Python机器学习入门：概念介绍
  • 《自然语言处理NLP》—— 词嵌入（Embedding）及 Word2Vec 词嵌入方法
  • FPGA时序分析和约束学习笔记（1、FPGA基本原理）
  • 如何使用selenium结合最新版chrome爬虫
  • 对比 pandas 与 SQL
  • 0x11 科迈 RAS系统 Cookie验证越权漏洞
  • R中线性回归及其权重和截距的计算
  • Shiro认证(Authentication)
  • 录制真人出镜视频一个简单方法
  • Python和C++混淆矩阵地理学医学物理学视觉语言模型和算法模型评估工具
  • JAVA学习-练习试用Java实现“矩形区域不超过 K 的最大数值和 Ⅲ”
  • 什么是网络安全
  • CSS 鼠标悬停时让父元素和子元素以不同的方式进行变换
  • 达梦8-数据守护集群主备故障实验和脑裂处理
  • JavaScript 与 HTML 的结合
  • 大数据行业应用实训室建设方案
  • 鸿蒙next开启地图服务
  • 【CTF Web】Pikachu 远程文件包含 Writeup（文件包含漏洞+GET请求）