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

最新推荐文章于 2024-11-13 19:36:04 发布
最新推荐文章于 2024-11-13 19:36:04 发布
阅读量330 收藏
点赞数
分类专栏： 遣返回家的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;
}
阿猿收手吧！
关注
专栏目录
二叉查找树
shibai906的博客
11-13 551
二叉查找树有这几个规则 1、若左子树不为空，那么左子树所有节点的值小于均小于他的根节点的值。 2、若右子树不为空，那么右子树的所有节点的值大于根节点的值。 3、左右子树也分别为二叉树排序树。 4、没有键值相等的节点。 注意：每个值都不能一样，如果有一样的，我们不需做考虑。 添加挺简单的，看下面的代码。 首先做准备 // 主要用来保存节点private Node<T> r...
leetcode 109. 有序链表转换二叉搜索树(注意看题，每个节点的左右子树都要满足二叉搜索树 算出链表长度后,递归像线段树一样创建)
m0_43602209的博客
11-18 202
题目 没什么好说的，看代码吧！ 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
二叉搜索树；二叉查找树；二叉排序树；Binary Search Tree
winbobob的专栏
07-12 970
binary search tree，中文翻译为二叉搜索树、二叉查找树或者二叉排序树。简称为BST 一：二叉搜索树的定义 他的定义与树的定义是类似的，也是一个递归的定义： 1、要么是一棵空树 2、如果不为空，那么其左子树节点的值都小于根节点的值；右子树节点的值都大于根节点的值 3、其左右子树也是二叉搜索树 在算法导论中的定义： 下图中是BST的两个
二叉排序树
loserbai的博客
07-23 546
定义 一棵空树，或者是具有下列性质的二叉树： （1）若左子树不空，则左子树上所有结点的值均小于它的根结点的值； （2）若右子树不空，则右子树上所有结点的值均大于或等于它的根结点的值； （3）左、右子树也分别为二叉排序树； 特点 树的结构通常不是一次生成的，而是在查找过程中，当树中不存在 关键字 等于给定值的 结点 时再进行插入。 新插入的结点一定是一个新添加的 叶子结点 ，并且是查找不成功时查找路径上访问的最后一个结点的左孩子或右孩子结点。 首先执行查找算法，找出被插结点的父亲结点。 判断被插结点是其父亲.
求二叉排序树中小于x且最近x的值a，大于x且最近x的值b
05-31
求二叉排序树中小于x且最近x的值a，大于x且最近x的值b
二叉查找树/二叉平衡树/红黑树
m0_46977298的博客
07-16 2130
二叉查找树、二叉平衡树以及红黑树。
数据结构-二叉搜索树/二叉排序树/二叉查找树
pre_tender的博客
10-29 2567
文章目录二叉搜索树/二叉排序树/二叉查找树.1 定义.2 性质二叉搜索树创建二叉搜索树查找.1 查找步骤.2 查找性能分析二叉树插入与删除 二叉搜索树/二叉排序树/二叉查找树 .1 定义 二叉排序树（Binary Sort Tree），又称二叉查找树（Binary Search Tree），亦称二叉搜索树。。设x为二叉查找树中的一个节点，x节点包含关键字key，节点x的key值记为key[x]。如...
数据结构与算法：二叉查找树/排序树/搜索树
天亮了的博客
10-26 1297
二叉树的前序遍历，中序遍历，后续遍历的思想，对其应分别对应的介绍了快速排序、汉诺塔、归并排序。二叉树的增删查操作很普通，时间复杂度与链表并没有太多差别。但当二叉树具备一些特性的时候，则可以利用这些特性实现时间复杂度的降低。 二叉查找树/排序树/搜索树 二叉查找树（也称作二叉排序树，二叉搜索树）具备以下几个的特性： 若左子树不为空，那么左子树上面的所有节点的关键字值都比根节点的关键字值小 若右子树不为空，那么右子树上面的所有节点的关键字值都比根节点的关键字值大 左右子树都为二叉树 没有重复值（
【数据结构】查找：动态查找表(二叉排序树/BST/二叉搜索树，平衡二叉树/AVL)
自律带来自由
08-20 3162
#笔记整理 动态查找表——基于树表的查找法 动态查找表的特点： 表结构本身在查找过程中动态生成，即对于给定值 key，若表中存在关键字等于 key 的记录，则查找成功，否则插入关键字等于 key 的记录。 动态查找表的主要运算 - 创建、销毁 - 查找、插入和删除 - 遍历 二叉排序树（二叉搜素树、二叉查找树）BST (Binary Sort Tree)/(Binary Search Tree)...
二叉搜索树实例练习
09-05
在中序遍历二叉搜索树时，节点将按照升序（默认）顺序访问，这也是它被称为“排序树”的原因。 在给定的实例练习中，我们看到一个具体的问题：判断两个序列是否能构建出相同的二叉搜索树。这个问题可以通过构建二叉...
二叉排序树/平衡二叉树/哈夫曼树
chengxuyuanlee的博客
12-10 2268
本人将树相关知识总结为初、中、高三篇，本文属于树结构的中篇，主要阐述几种经典的树形结构，是继承树的基础知识之后，进行相关拓展那么本文将以三种典型的树形结构进行总结，从查找的角度来进行分析各个树型结构的区别与优势。 基础篇在：数据结构——树基础 （主要总结树、二叉树、线索二叉树、森林等基础相关知识） 二叉排序树 树表相关概念 二叉排序树定义 查找操作 插入操作 删除操作 查找效率分析 平衡二叉树 相关概念 平衡二叉树定义 平衡二叉树调整方法 创建、插入、删除 查找效率分析 ...
二叉搜索树（简介）
m0_73020012的博客
06-29 260
二叉查找树或是空树，或是满足如下三个性质的二叉树：1.若其左子树非空，则左子树上所有节点的值都小于根节点的值 若其右子树非空，则右子树上所有节点的值都大于根节点的值2.其左右子树都是一棵二叉查找树3.二叉查找树的特性：左子树
查找-第9章-《数据结构题集》习题解析-严蔚敏吴伟民版
热门推荐
weixin_34228387的博客
06-22 1万+
习题集解析部分 第9章 查找 ——《数据结构题集》-严蔚敏.吴伟民版        源码使用说明  链接☛☛☛ 《数据结构-C语言版》（严蔚敏,吴伟民版）课本源码+习题集解析使用说明        课本源码合辑  链接☛☛☛ 《数据结构》课本源码合辑        习题集全解析  链接☛☛☛ 《数据结构题集》习题解析合辑         相关测试数据下载  链接☛ 数据包    ...
STL set
hls0611的博客
11-09 254
练习题：P1059 [NOIP2006 普及组] 明明的随机数。
C++_用 using 语句继承基类的构造函数
学海无涯
11-09 260
**默认情况下**，派生类会继承基类的所有成员，包括数据成员和函数成员，但不会继承基类的**构造函数和析构函数**，因为构造函数和析构函数的作用是创建和销毁对象，派生类通常需要有自己的构造和析构的逻辑。C++11 引入了using语句，使得派生类可以通过 using 关键字使用基类的构造函数，更方便地复用基类的构造逻辑。
2411C++,C++26反射示例
最新发布
个人进步之路
11-13 660
2411C++,C++26反射示例
C++——智能指针
Wangx_wang的博客
11-12 761
介绍了几种智能指针的不同和实现思路以及循环引用的问题
C++高效二叉搜索树查找算法实现探讨
二叉搜索树（Binary Search Tree，BST），又称为二叉查找树或二叉排序树，是一种特殊的二叉树结构，它具有以下性质： 1. 若任意节点的左子树不为空，则左子树上所有节点的值均小于它的根节点的值。 2. 若任意节点的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

阿猿收手吧！

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

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

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

打赏作者

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

抵扣说明：

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

余额充值