二叉搜索树/二叉排序树/二叉查找树

最新推荐文章于 2024-06-02 16:01:20 发布
最新推荐文章于 2024-06-02 16:01:20 发布
阅读量228 收藏
点赞数
分类专栏： 遣返回家的C家家 文章标签： c++ 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LHRan_ran_/article/details/132803664
版权

文章目录


在这里插入图片描述

1.概念

二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树:
若它的左子树不为空，则左子树上所有节点的值都小于根节点的值
若它的右子树不为空，则右子树上所有节点的值都大于根节点的值
它的左右子树也分别为二叉搜索树

2.操作

  1. 二叉搜索树的查找
    a、从根开始，查找，比根大往右查，比根小往左查。
    b、最多查找高度次，走到空还没找到，这个值不存在。
  2. 二叉搜索树的插入
    插入的具体过程如下：
    a. 树为空，新增节点，赋值给root指针
    b. 树不空，查找插入位置，插入新节点
    3.二叉搜索树的删除
    查找元素是否在二叉搜索树中，不存在返回false。
    存在：目标结点
    a. 无子结点
    b. 只有左子结点
    c. 只有右子结点
    d. 有左、右子结点
    情况b：删除目标结点且使目标结点的父结点指向目标结点的左子结点–直接删除
    情况c：删除目标结点且使目标结点的父结点指向目标结点的右子结点–直接删除
    情况d：在目标结点的右子树中寻找中序下的第一个最小结点，用它的值填补到被删除节点中，再来处理该结点的删除问题–替换法删除

3.实现

3.1框架

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

3.2BSTree.h

#pragma once

template<class K>
//树结点
struct BSTreeNode
{
	BSTreeNode<K>* _left;
	BSTreeNode<K>* _right;
	K _key;

	BSTreeNode(const K& key)
		:_left(nullptr)
		, _right(nullptr)
		, _key(key)
	{
	
	}
};
//二叉搜索树
//K模型
namespace K 
{
	template<class K>
	class BSTree
	{
		typedef BSTreeNode<K> Node;
	public:
		//构造函数
		/*
		BSTree()
			:_root(nullptr)
		{

		}
		*/
		BSTree() = default; // 制定强制生成默认构造
		//拷贝构造
		BSTree(const BSTree<K>& t)
		{
			_root = Copy(t._root);
		}
		//赋值重载
		BSTree<K>& operator=(BSTree<K> t)
		{
			swap(_root, t._root);
			return *this;
		}
		//析构函数
		~BSTree()
		{
			Destroy(_root);
		}
		//插入 
		bool Insert(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 InsertR(const K& key)
		{
			return _InsertR(_root, key);
		}
		//查找
		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;
		}
		//查找-递归版
		bool FindR(const K& key)
		{
			return _FindR(_root, key);
		}
		//删除
		bool Erase(const K& key)
		{
			Node* cur = _root;
			Node* parent = nullptr;

			while (cur)
			{
				if (cur->_key < key)
				{
					parent = cur;
					cur = cur->_right;
				}
				else if (cur->_key > key)
				{
					parent = cur;
					cur = cur->_left;
				}
				// 找到目标结点--删除
				else
				{
					// 1、左为空
					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;
					}
					// 2、右为空
					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;
					}
					// 3、左右均有子结点
					else
					{
						//找右树最小节点/左树最大节点
						//一、右树最小节点
						//obj只能是 只有右节点或叶子 
						//找obj【右树最小结点】
						//Node* nannyDad = cur;
						//Node* nanny = cur->_right;
						//while (nanny->_left)
						//{
						//	nannyDad = nanny;
						//	nanny = nanny->_left;
						//}
						赋值
						//cur->_key = nanny->_key;
						obj在父左 obj的右给父左
						//if (nannyDad->_left == nanny)
						//{
						//	nannyDad->_left = nanny->_right;
						//}
						obj在父右 obj的右给父右
						//else
						//{
						//	nannyDad->_right = nanny->_right;
						//}
						//delete nanny;
						//二、左树最大结点
						//obj只能是 只有左节点或叶子 
						//找obj【左树最大结点】
						Node* nannyDad = cur;
						Node* nanny = cur->_left;
						while (nanny->_right)
						{
							nannyDad = nanny;
							nanny = nanny->_right;
						}
						//赋值
						cur->_key = nanny->_key;
						//obj在父左 obj的右给父左
						if (nannyDad->_left == nanny)
						{
							nannyDad->_left = nanny->_right;
						}
						//obj在父右 obj的右给父右
						else
						{
							nannyDad->_right = nanny->_right;
						}
						delete nanny;
					}

					return true;
				}
			}

			return false;
		}
		//删除-递归版
		bool EraseR(const K& key)
		{
			return _EraseR(_root, key);
		}
		//中序遍历
		//1.直接写调用时传_root传不过去 _root是private [可以用GetRoot()]
		//2._root又无法做缺省值：条件是全局变量 常量 静态变量 且无this指针【this->_root】
		void InOrder()
		{
			_InOrder(_root);
			cout << endl;
		}
	protected:

		//拷贝函数
		Node* Copy(Node* root)
		{
			if (root == nullptr)
				return nullptr;

			Node* newRoot = new Node(root->_key);
			newRoot->_left = Copy(root->_left);
			newRoot->_right = Copy(root->_right);
			return newRoot;
		}
		//销毁函数
		void Destroy(Node*& root)
		{
			if (root == nullptr)
				return;

			Destroy(root->_left);
			Destroy(root->_right);

			delete root;
			root = nullptr;
		}
		//查找-递归版
		bool _FindR(Node* root, const K& key)
		{
			if (root == nullptr)
				return false;

			if (root->_key == key)
				return true;

			if (root->_key < key)
				return _FindR(root->_right, key);
			else
				return _FindR(root->_left, key);
		}
		//插入-递归版
		bool _InsertR(Node*& root, const K& key)
		{
			if (root == nullptr)
			{
				//引用传参 root是上层root的left或right 直接链接 yyds
				root = new Node(key);
				return true;
			}

			if (root->_key < key)
			{
				return _InsertR(root->_right, key);
			}
			else if (root->_key > key)
			{
				return _InsertR(root->_left, key);
			}
			else
			{
				return false;
			}
		}
		//删除-递归版
		bool _EraseR(Node*& root, const K& key)
		{
			if (root == nullptr)
				return false;

			if (root->_key < key)
			{
				return _EraseR(root->_right, key);
			}
			else if (root->_key > key)
			{
				return _EraseR(root->_left, key);
			}
			//相等--删除
			else
			{
				//记录root 
				Node* obj = root;
				//右为空
				if (root->_right == nullptr)
				{
					root = root->_left; //实际是上层的root与当前层的root左链接 下同
				}
				//左为空
				else if (root->_left == nullptr)
				{
					root = root->_right;
				}
				//左右都不空
				else
				{
					Node* nanny = root->_left;
					while (nanny->_right)
					{
						nanny = nanny->_right;
					}
					swap(root->_key, nanny->_key);
					//将找到的nanny与obj交换 然后传新树递归删除obj
					//【此时obj定为叶子节点-利用递归将删除一个有左右子结点的结点转换为删除一个叶子节点】
					return _EraseR(root->_left, key);
				}
				delete obj;
				return true;
			}
		}
		//中序遍历 
		void _InOrder(Node* root)
		{
			if (root == nullptr)
				return;

			_InOrder(root->_left);
			cout << root->_key << " ";
			_InOrder(root->_right);
		}
	private:
		Node* _root = nullptr;
	};
}
//KV模型
namespace KV
{
	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* cur = _root;
			Node* parent = nullptr;

			while (cur)
			{
				if (cur->_key < key)
				{
					parent = cur;
					cur = cur->_right;
				}
				else if (cur->_key > key)
				{
					parent = cur;
					cur = cur->_left;
				}
				// 找到目标结点--删除
				else
				{
					// 1、左为空
					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;
					}
					// 2、右为空
					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;
					}
					// 3、左右均有子结点
					else
					{
						//找右树最小节点/左树最大节点
						//一、右树最小节点
						//obj只能是 只有右节点或叶子 
						//找obj【右树最小结点】
						//Node* nannyDad = cur;
						//Node* nanny = cur->_right;
						//while (nanny->_left)
						//{
						//	nannyDad = nanny;
						//	nanny = nanny->_left;
						//}
						赋值
						//cur->_key = nanny->_key;
						obj在父左 obj的右给父左
						//if (nannyDad->_left == nanny)
						//{
						//	nannyDad->_left = nanny->_right;
						//}
						obj在父右 obj的右给父右
						//else
						//{
						//	nannyDad->_right = nanny->_right;
						//}
						//delete nanny;
						//二、左树最大结点
						//obj只能是 只有左节点或叶子 
						//找obj【左树最大结点】
						Node* nannyDad = cur;
						Node* nanny = cur->_left;
						while (nanny->_right)
						{
							nannyDad = nanny;
							nanny = nanny->_right;
						}
						//赋值
						cur->_key = nanny->_key;
						//obj在父左 obj的右给父左
						if (nannyDad->_left == nanny)
						{
							nannyDad->_left = nanny->_right;
						}
						//obj在父右 obj的右给父右
						else
						{
							nannyDad->_right = nanny->_right;
						}
						delete nanny;
					}
					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;
	};
}

3.3test.cpp

#define _CRT_SECURE_NO_WARNINGS 
#include <iostream>
#include <list>
#include <vector>
#include <algorithm>
#include <array>
#include <time.h>
#include <queue>
using namespace std;

#include "BSTree.h"

//插入、遍历、删除
void TestBSTree()
{
	int a[] = { 8, 3, 1, 10, 6, 4, 7, 14, 13 };
	K::BSTree<int> t1;
	//插入建树
	for (auto e : a)
	{
		t1.Insert(e);
	}

	t1.InOrder();

	t1.Erase(4);
	t1.InOrder();

	t1.Erase(14);
	t1.InOrder();

	t1.Erase(3);
	t1.InOrder();

	t1.Erase(8);
	t1.InOrder();
}
//KV模型--简易字典
void TestBSTree2()
{
	KV::BSTree<string, string> Dictionary;
	Dictionary.Insert("sort", "排序");
	Dictionary.Insert("left", "左边");
	Dictionary.Insert("right", "右边");
	Dictionary.Insert("string", "字符串");
	Dictionary.Insert("insert", "插入");
	Dictionary.Insert("erase", "删除");

	string str;
	while (cin >> str)
	{
		auto ret = Dictionary.Find(str);
		if (ret)
		{
			cout <<str << ":" << ret->_value << endl;
		}
		else
		{
			cout << "无此单词" << endl;
		}
	}
}
//KV模型--水果统计树
void TestBSTree3()
{
	string arr[] = { "西瓜", "西瓜", "苹果", "西瓜", "苹果", "苹果", "西瓜", "苹果", "香蕉", "苹果", "香蕉", "梨" };

	KV::BSTree<string, int> countTree;
	for (auto str : arr)
	{
		//KV::BSTreeNode<string, int>* 
		auto ret = countTree.Find(str);
		if (ret == nullptr)
		{
			countTree.Insert(str, 1);
		}
		else
		{
			ret->_value++;
		}
	}

	countTree.InOrder();
}

int main()
{
	TestBSTree3();
	return 0;
}
阿猿收手吧！
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
求二叉排序树中小于x且最近x的值a，大于x且最近x的值b
05-31
求二叉排序树中小于x且最近x的值a，大于x且最近x的值b
二叉排序树
loserbai的博客
07-23 479
定义 一棵空树，或者是具有下列性质的二叉树： （1）若左子树不空，则左子树上所有结点的值均小于它的根结点的值； （2）若右子树不空，则右子树上所有结点的值均大于或等于它的根结点的值； （3）左、右子树也分别为二叉排序树； 特点 树的结构通常不是一次生成的，而是在查找过程中，当树中不存在 关键字 等于给定值的 结点 时再进行插入。 新插入的结点一定是一个新添加的 叶子结点 ，并且是查找不成功时查找路径上访问的最后一个结点的左孩子或右孩子结点。 首先执行查找算法，找出被插结点的父亲结点。 判断被插结点是其父亲.
二叉搜索树；二叉查找树；二叉排序树；Binary Search Tree
winbobob的专栏
07-12 931
binary search tree，中文翻译为二叉搜索树、二叉查找树或者二叉排序树。简称为BST 一：二叉搜索树的定义 他的定义与树的定义是类似的，也是一个递归的定义： 1、要么是一棵空树 2、如果不为空，那么其左子树节点的值都小于根节点的值；右子树节点的值都大于根节点的值 3、其左右子树也是二叉搜索树 在算法导论中的定义： 下图中是BST的两个
二叉搜索树（简介）
m0_73020012的博客
06-29 208
二叉查找树或是空树，或是满足如下三个性质的二叉树：1.若其左子树非空，则左子树上所有节点的值都小于根节点的值 若其右子树非空，则右子树上所有节点的值都大于根节点的值2.其左右子树都是一棵二叉查找树3.二叉查找树的特性：左子树
Java基于二叉查找树实现排序功能示例
08-29
主要介绍了Java基于二叉查找树实现排序功能,结合实例形式分析了Java二叉查找树的定义、遍历及排序等相关操作技巧,需要的朋友可以参考下
Python实现二叉搜索树BST的方法示例
09-18
主要介绍了Python实现二叉搜索树BST的方法示例，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
二分搜索树-二叉查找树 .docx
03-13
二分搜索树（英语：Binary Search Tree），也称为 二叉查找树 、二叉搜索树 、有序二叉树或排序二叉树。满足以下几个条件： 若它的左子树不为空，左子树上所有节点的值都小于它的根节点。 若它的右子树不为空，右子...
二叉搜索树实例练习
09-05
一棵二叉查找树是按二叉树结构来组织的。这样的树可以用链表结构表示，其中每一个结点都是一个对象
leetcode 109. 有序链表转换二叉搜索树(注意看题，每个节点的左右子树都要满足二叉搜索树 算出链表长度后,递归像线段树一样创建)
m0_43602209的博客
11-18 129
题目 没什么好说的，看代码吧！ class Solution { public: int getlen(ListNode *head){ int cnt; for(cnt=0;head;head=head->next) ++cnt; return cnt; } TreeNode* build(ListNode*&head,int l,int r){ if(!head||l>r) return NUL
查找-第9章-《数据结构题集》习题解析-严蔚敏吴伟民版
weixin_34228387的博客
06-22 1万+
习题集解析部分 第9章 查找 ——《数据结构题集》-严蔚敏.吴伟民版        源码使用说明  链接☛☛☛ 《数据结构-C语言版》（严蔚敏,吴伟民版）课本源码+习题集解析使用说明        课本源码合辑  链接☛☛☛ 《数据结构》课本源码合辑        习题集全解析  链接☛☛☛ 《数据结构题集》习题解析合辑         相关测试数据下载  链接☛ 数据包    ...
二叉查找树
shibai906的博客
11-13 509
二叉查找树有这几个规则 1、若左子树不为空，那么左子树所有节点的值小于均小于他的根节点的值。 2、若右子树不为空，那么右子树的所有节点的值大于根节点的值。 3、左右子树也分别为二叉树排序树。 4、没有键值相等的节点。 注意：每个值都不能一样，如果有一样的，我们不需做考虑。 添加挺简单的，看下面的代码。 首先做准备 // 主要用来保存节点private Node<T> r...
二叉查找树与平衡二叉树
热门推荐
金发只是水一下的博客
08-29 8万+
二叉查找树 　　二叉查找树，也称二叉搜索树，或二叉排序树。其定义也比较简单，要么是一颗空树，要么就是具有如下性质的二叉树： （1）若任意节点的左子树不空，则左子树上所有结点的值均小于它的根结点的值； （2） 若任意节点的右子树不空，则右子树上所有结点的值均大于它的根结点的值； （3） 任意节点的左、右子树也分别为二叉查找树； （4） 没有键值相等的节点。 　　如上图所示，是不同形态...
C++：round函数用法
Solititude的博客
05-28 443
C++：round函数用法
【C++】list的使用（下）
2303_79329831的博客
06-01 1160
本篇博客主要内容：STL库中list用法的讲解。让我们接着上一篇博文的内容继续，进入list最后一个模块，操作list对象的接口函数。本篇文章所讲到的list内容出自于同一个模块，由于其排序和合并的方式涉及到了仿函数的传递，所以内容和篇幅稍微会大一些。相信学完本篇内容之后，能对list的使用和C++有更充分的了解。♥STLC++
【如何在Qt C++中使用SSL和TLS加密传输数据？】
m0_45463480的博客
05-28 327
在这个示例中，我们创建了一个简单的Qt应用程序，向指定的HTTPS地址发送请求，并显示响应。信号来处理响应数据。您可以从响应中读取数据并进行进一步处理。来配置SSL/TLS连接，包括对证书进行验证和加密要求等。为您要访问的实际URL，并根据需要进一步配置SSL策略。在发送请求之前，可设置SSL配置。确保您的Qt项目已经链接了网络模块（对象发送网络请求，并接收响应。对象指定要访问的URL。
C++核心编程类的总结封装案例
最新发布
weixin_73497355的博客
06-02 881
在C++中，类是面向对象编程（OOP）的核心概念之一。类是一种用户定义的数据类型，它允许我们将数据（成员变量）和操作这些数据的方法（成员函数）组合在一起。类的定义使用class关键字定义类。类可以包含私有（private）、保护（protected）和公有（public）成员。私有成员只能被类内部的成员函数访问，而公有和保护成员可以在类外部被访问（对于保护成员，派生类也可以访问）。成员变量（也称为属性或字段）：成员变量是类的数据部分，用于存储类的状态。
关于C++的特殊类定制
m0_62126248的博客
05-28 386
C++的一些特殊性质的类如何进行设计
【如何利用c++RAII技术实现自动加解锁】
逆风飞翔的博客
05-28 361
使用C++中的 RAII（资源获取即初始化）技术来实现自动加锁解锁
二叉查找树和二叉排序树
10-30
二叉查找树和二叉排序树是同一种数据结构，也称为二叉搜索树。它是一种特殊的二叉树，具有以下性质：若左子树不为空，则左子树上所有节点的值均小于它的根节点的值；若右子树不为空，则右子树上所有节点的值均大于它的根节点的值；左、右子树也分别为二叉排序树；没有键值相等的节点。二叉搜索树可以用于快速查找、插入和删除数据，其平均时间复杂度为 O(log2n)。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

阿猿收手吧！

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

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

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

打赏作者

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

抵扣说明：

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

余额充值