二叉树进阶——手撕二叉搜索树

最新推荐文章于 2024-07-21 22:27:18 发布
最新推荐文章于 2024-07-21 22:27:18 发布
阅读量793 收藏 20
点赞数 32
分类专栏： C++进阶 文章标签： java 数据库 数据结构 算法 c语言 开发语言 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73802195/article/details/137402184
版权

troop主页：troop

手撕二叉搜索树

1.二叉搜索树的定义

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

  • 若它的左子树不为空，则左子树上的所有节点的值都小于根节点的值
  • 若它的右子树不为空，则右子树上的所有节点的值都大于根节点的值

在这里插入图片描述

2.实现（非递归）

补充结构

//struct BinarySearchTreeNode
template<class K>
struct BSTreeNode
{
	typedef BSTreeNode<K> Node;
	Node* _left;
	Node* _right;
	K _key;

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

/class BinarySearchTree
template<class K>
class BSTree
{
	typedef BSTreeNode<K> Node;
public:
	BSTree() = default;
	BSTree(const BSTree<K>& t)
	{
		_root = copy(t._root);
	}
	Node* copy(Node* root)
	{
		if (root == nullptr)
			return nullptr;
		Node* newroot = new Node(root->_val);
		newroot->_left = copy(root->_left);
		newroot->_right = copy(root->_right);
		return newroot;
	}

	~BSTree()
	{
		Destroy();
	}
	void Destroy()
	{
		return _Destroy(_root);
	}
	void _Destroy(Node* root)
	{
		if (root == nullptr)
			return;
		_Destroy(root->_left);
		_Destroy(root->_right);
		delete root;
	}
private:
	Node* _root;
};

2.1查找

根据它的定义查找就是，跟节点比，比节点大就去它的右子树中寻找，比他小就去它的左子树中寻找。

	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;
	}

2.2插入

在这里插入图片描述
插入也很简单，例如上图我们要插入16，我们就先找到要插入的位置，然后为了方便我们记录整个过程我们需要一个父节点。

	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->_left=cur;
		}
		else
		{
			parent->_right=cur;
		}
		return true;
	}

现在可以进行测试代码的正确性。
在这里插入图片描述
注意，搜索二插入要有序它走的是中序遍历。

2.3删除（重要）

删除比插入麻烦的多，我们删除值原则就是要保证它还是搜索二叉树，它的性质不可以改变。这就挺麻烦的，所以我们在删除这里用替换删除
替换删除：找到一个可以替换的节点，交换值，转换删除它。
可以替换的节点是：左子树的最大or右子树的最小。

下面我们来分析一下删除的各种情况

  1. 删除孩子节点
  2. 删除只有一个孩子的节点
  3. 删除两个孩子的节点
    这里总结下，情况1和2可以归为一类。情况3我们就要用到替换删除法

情况1(无孩子&&一个孩子）

在这里插入图片描述

//找到了开始删除
				//第一种
				if (cur->_left == nullptr)//我的左为空
				{
					if (cur == _root)
					{
						_root = cur->_right;
					}
					else
					{
						if (cur == parent->_left)//我是父亲的左
						{
							parent->_left = cur->_right;
						}
						else//我是父亲的左
						{
							parent->_right = cur->_right;
						}
					}
					delete cur;
					return true;
				}
				else if (cur->_right == nullptr)
				{
					if (cur == _root)
					{
						_root = cur->_left;
					}
					else
					{
						if (cur == parent->_left)
						{
							parent->_left = cur->_left;
						}
						else
						{
							parent->_right = cur->_left;
						}
					}
					delete cur;
					return true;
				}

###情况二（两个孩子）
在这里插入图片描述
找到右子树的最小，把它的值复制给cur，就转换成了删除叶子节点

				else//第二种(俩孩子)替换删除法
				{
					Node* rightMinparent = cur;
					Node* rightMin = cur->_right;
					while (cur->_right)
					{
						rightMinparent = rightMin;
						rightMin = rightMin->_left;
					}
					cur->_key = rightMin->_key;
					if (rightMin == rightMinparent->_left)
					{
						rightMinparent->_left = rightMin->_right;
					}
					else
					{
						rightMinparent->_right = rightMin->_right;
					}
					delete rightMin;
					return true;
				}

3.二叉搜索树的应用

3.1K模型

K模型即只有key作为关键码，结构中只需要存储Key即可，关键码即为需要搜索到
的值。
比如：给一个单词word，判断该单词是否拼写正确。这个就是普通的二叉搜索树

3.2KV模型

KV模型：每一个关键码key，都有与之对应的值Value，即<Key, Value>的键值对。
通过key值快速查找另外一个值在不在。我们用二叉搜索树这个用的是比较多的
生活中的KV模型例如：商场车库，进去都可以进入（记录车牌（key）进入时间（value））
出：付费出（通过车牌（key），查询进入的时间（value））。
还有字典查询，高铁身份证进站等等。

3.2.1KV模型的实现

这个就是多加了一个对象，实现直接CV上面的代码

namespace key_value
{
	template<class K, class V>
	struct BSTreeNode
	{
		typedef BSTreeNode<K, V> Node;
		Node* _left;
		Node* _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 true;
				}
			}

			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(Node* root)
		{
			if (root == nullptr)
				return;
			_InOrder(root->_left);
			std::cout << root->_val << " ";
			_InOrder(root->_right);
		}

		void InOrder()
		{
			_InOrder(_root);
			cout << endl;
		}
		//3.删除
		bool Erase(const K& key)
		{
			Node* parent = nullptr;
			Node* cur = _root;
			while (cur)
			{
				if (cur->_val < key)
				{
					parent = cur;
					cur = cur->_right;
				}
				else if (cur->_val > 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;
						return true;
					}
					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;
						return true;
					}

					else//第二种（有两个孩子）替换删除法
					{
						Node* rightMinparent = cur;
						Node* rightMin = cur->_right;
						while (rightMin->_left)
						{
							rightMinparent = rightMin;
							rightMin = rightMin->_left;
						}
						cur->_val = rightMin->_val;
						if (rightMin == rightMinparent->_left)
							rightMinparent->_left = rightMin->_right;
						else
							rightMinparent->_right = rightMin->_right;
						delete rightMin;
						return true;
					}
				}
			}
			return false;
		}
		//void InOrder()
		//{
		//	_InOrder(_root);
		//	cout << endl;
		//}
	//private:
	//	void _InOrder(Node* root)
	//	{
	//		if (root == nullptr)
	//			return;

	//		_InOrder(root->_left);
	//		cout << root->_key << " ";
	//		_InOrder(root->_right);
	//	}

	private:
		Node* _root = nullptr;
	};
}

我们可以用哥=个例子来玩一玩这个KV模型

void TestBSTree()
{
	key_value::BSTree<string, string> dict;
	dict.Insert("insert", "插入");
	dict.Insert("erase", "删除");
	dict.Insert("left", "左边");
	dict.Insert("string", "字符串");

	string str;
	while (cin >> str)
	{
		auto ret = dict.Find(str);
		if (ret)
		{
			cout << str << ":" << ret->_value << endl;
		}
		else
		{
			cout << "单词拼写错误" << endl;
		}
	}
}

在这里插入图片描述

总结

总的来说二叉搜索树，比较难的地方就是删除部分，多画图多思考。
下篇我们就要深入二叉搜索树。

二叉搜索树源代码

#pragma once
#include<iostream>
using namespace std;
//struct BinarySearchTreeNode
template<class K>
struct BSTreeNode
{
	typedef BSTreeNode<K> Node;
	Node* _left;
	Node* _right;
	K _key;

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

//class BinarySearchTree
template<class K>
class BSTree
{
	typedef BSTreeNode<K> Node;
public:
	BSTree() = default;
	BSTree(const BSTree<K>& t)
	{
		_root = copy(t._root);
	}
	Node* copy(Node* root)
	{
		if (root == nullptr)
			return nullptr;
		Node* newroot = new Node(root->_val);
		newroot->_left = copy(root->_left);
		newroot->_right = copy(root->_right);
		return newroot;
	}

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

	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 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->_left=cur;
		}
		else
		{
			parent->_right=cur;
		}
		return true;
	}
	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 (cur == parent->_left)//我是父亲的左
						{
							parent->_left = cur->_right;
						}
						else//我是父亲的左
						{
							parent->_right = cur->_right;
						}
					}
					delete cur;
					return true;
				}
				else if (cur->_right == nullptr)
				{
					if (cur == _root)
					{
						_root = cur->_left;
					}
					else
					{
						if (cur == parent->_left)
						{
							parent->_left = cur->_left;
						}
						else
						{
							parent->_right = cur->_left;
						}
					}
					delete cur;
					return true;
				}
				else//第二种(俩孩子)替换删除法
				{
					Node* rightMinparent = cur;
					Node* rightMin = cur->_right;
					while (cur->_right)
					{
						rightMinparent = rightMin;
						rightMin = rightMin->_left;
					}
					if (rightMinparent->_left == rightMin)
					{
						rightMinparent->_left = rightMin->_right;
					}
					else
					{
						rightMinparent->_right = rightMin->_right;
					}
				}
			}
		}
		return false;
	}
	void Inorder()
	{
		_Inorder(_root);
		cout << endl;
	}
private:
	void _Inorder(Node* root)
	{
		if (root == nullptr)
			return;
		_Inorder(root->_left);
		cout << root->_key << " ";
		_Inorder(root->_right);
	}
private:
	Node* _root=nullptr;
};
tpoog
关注
  • 32
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 10
    评论
专栏目录
二叉树--二叉搜索树
Hy_2267的博客
04-11 652
编号2的二叉树中，叶子节点全都在最底层，除了叶子节点之外，每个节点都有左右两个子节点，这种二叉树就叫做满二叉树。 叶子节点都在最底下两层，最后一层的叶子节点都靠左排列，并且除了最后一层，其他层的节点个数都要达到最大，这种二叉树叫做完全二叉树。 如何表示（或者存储）一棵二叉树？ 链式存储法：一种是基于指针或者引用的二叉链式存储法 基于数组的顺序存储法：一种是基于数组的顺序存储法 把根节点存储在下标i = 1的位置，那左子节点存储在下标2 * i = 2的位置，右子节点存储在2 * i + 1..
二叉搜索树—平衡二叉树
Hansry的博客
10-11 913
1. 二叉搜索树的基本概念一棵二叉搜索树是以一棵二叉树来组织的，如下图所示，这样一棵可以使用一个链表数据结构来表示，其中每个结点就是一个对象。key、left、right、p分别指向结点的键值、左孩子、右孩子和双亲。如果某个孩子节点或者父节点不存在，则相应属性值为NIL。根节点是树中唯一父指针为NIL的节点。（1）遍历关键字 通过递归算法来按序输出二叉树中的所有关键字，这种算法称为中序遍历(ino
【二叉树进阶】搜索二叉树（递归+非递归两种版本详解）
m0_70980326的博客
07-30 1242
搜索二叉树详解：递归+非递归两种版本实现，画图讲解+完整代码
kiner算法刷题记（四）：你真的了解二叉树吗（手撕算法篇）
u010651383的专栏
04-04 182
你真的了解二叉树吗（手撕算法篇） 前言 本文属于系列文章《你真的了解二叉树吗》的第二部分——手撕算法篇。如果你还没有看过第一部分你真的了解二叉树吗（树形结构基础篇）的话，强烈建议先看一下第一部分的内容，这样你在解题时会更加如虎添翼。很多第一篇里面已经讲过的内容，在这里将不再赘述。 二叉树基础刷题部分 LeetCode 144 二叉树的前序遍历 解题思路 如果你有看过我上一篇文章你真的了解二叉树吗（树形结构基础篇）的话，应该已经知道了，我们树的遍历天生就适合使用递归实现，此外，还讲了如何设计和实现一个递归函数
数据结构二叉树实验——构造二叉搜索树
06-05
本实验——“数据结构二叉树实验——构造二叉搜索树”，旨在深入理解并实践二叉搜索树的构建过程和特性。 二叉搜索树是一种特殊的二叉树，每个节点都满足以下性质：左子树上的所有节点的键值小于父节点的键值；右子...
二叉树-基于C++实现的二叉搜索树.zip
04-26
二叉搜索树（Binary Search Tree，BST）是二叉树的一个特例，它具有以下特性：对于任意节点，其左子树中的所有节点的值都小于该节点的值，而右子树中的所有节点的值都大于该节点的值。这种特性使得二叉搜索树非常...
C语言判定一棵二叉树是否为二叉搜索树的方法分析
12-31
本文实例讲述了C语言判定一棵二叉树是否为二叉搜索树的方法。分享给大家供大家参考，具体如下： 问题 给定一棵二叉树，判定该二叉树是否是二叉搜索树（Binary Search Tree）？ 解法1:暴力搜索 首先说明一下二叉树和...
二叉树的二叉搜索表示.rar_二叉搜索树_二叉树的二叉搜索
09-22
二叉搜索树（Binary Search Tree，BST）是一种特殊类型的二叉树，它的每个节点都具有以下特性： 1. **左子树性质**：左子树上所有节点的值都小于当前节点的值。 2. **右子树性质**：右子树上所有节点的值都大于当前...
二叉树的应用：二叉排序树BST和平衡二叉树AVL的构造 课设作业 完整代码
02-10
二叉排序树(Binary Sort Tree)又称二叉查找(搜索)树(Binary Search Tree)。其定义为：二叉排序树或者是空树，或者是满足如下性质的二叉树：1.若它的左子树非空，则左子树上所有结点的值均小于根结点的值；2.若它的右...
redis+spring面试题
github_36510643的博客
07-21 147
redis+spring面试题
Java-Lambda
最新发布
lizhiwei21的博客
07-21 137
lambda表达式可以理解为对匿名内部类的一种简化 , 但是本质是有区别的面向对象思想 :强调的是用对象去完成某些功能函数式编程思想 :强调的是结果 , 而不是怎么去做。
Promise 详解（原理篇）
山重水复疑无路，柳暗花明又一村。
07-20 486
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
接口防刷！利用redisson快速实现自定义限流注解
架构师小吴的博客
07-18 1123
如登录接口，当用户使用手机号+验证码登录时，一般我们会生成6位数的随机验证码，并将验证码有效期设置为1-3分钟，如果对登录接口不加以限制，理论上，通过技术手段，快速重试100000次，即可将验证码穷举出来。解决思路：对登录接口加上限流操作，如限制一分钟内最多登录5次，登录次数过多，就返回失败提示，或者将账号锁定一段时间。在日常开发中，一些重要的对外接口，需要加上访问频率限制，以免造成资��损失。ok，通过以上两步，即可完成我们的限流注解了，下面通过一个接口验证下效果。
JVM-垃圾回收与内存分配
m0_50846237的博客
07-19 1121
JVM-垃圾回收与内存分配
java算法day19
TOMOT77的博客
07-20 174
我第一时间想到的方法是遍历二叉树+哈希。哈希用来统计数字出现的次数。之后遍历map收集结果。利用了BST的性质，即BST的中序序列是有序序列。
【Java算法】前缀和 下
2302_79806056的博客
07-18 1047
这段代码实现了一个寻找数组中具有相等数量的0和1的最长子数组长度的算法。具体来说，它使用了前缀和（prefix sum）的概念以及哈希映射（HashMap）来优化查找过程。初始化哈希映射：计算前缀和：检查相等数量的0和1：更新哈希映射：返回结果：这种方法的时间复杂度为O(n)，因为我们只遍历数组一次，并且对每个元素执行常数时间的操作。空间复杂度也是O(n)，最坏情况下需要存储n个前缀和值。 初始化阶段:开始遍历数组:继续
华为OD机试 - 分披萨 - 递归（Java 2024 D卷 200分）
学Java，找哪吒
07-21 499
递归算法通过函数调用自身解决问题，每次递归调用都处理问题的一个子部分，直到达到基准条件，从而构建最终解。
【Java并发编程之美 | 第三篇】Java 并发包中锁原理剖析之AQS、ReentrantLock独占可重入锁
踢桃的成长之路
07-21 536
Java 并发包中锁原理剖析之AQS、ReentrantLock独占可重入锁
算法学习9——二叉搜索树
05-19
二叉搜索树，也叫二叉查找树（BST，Binary Search Tree），是一种特殊的二叉树。相对于普通的二叉树，它有一个特点：所有左子树的节点都比根节点小，所有右子树的节点都比根节点大。因此，它可以快速地进行查找、...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

tpoog

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

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

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

打赏作者

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

抵扣说明：

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

余额充值