【数据结构】二叉搜索树

已于 2024-05-19 22:16:47 修改
阅读量513 收藏 7
点赞数 8
分类专栏： C++ 文章标签： 数据结构 算法 c++
于 2024-05-19 16:36:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_78636079/article/details/139036506
版权

二叉搜索树是一棵很有启发意义的树，AVL树红黑树都是由他来的。

目录

二叉搜索树的概念：

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

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

在这里插入图片描述

BSTree的实现：

其实他的实现真的很简单，我们先来看节点的定义与私有变量：
节点：

template<class K>
struct BinarySearchTreeNode
{
	BinarySearchTreeNode(int key)
		:_left(nullptr)
		,_right(nullptr)
		,_key(key)
	{}
	typedef BinarySearchTreeNode<K> BSTNode;
	BSTNode* _left;
	BSTNode* _right;
	K _key;
};

BSTree的私有变量：

private:
	Node* _root = nullptr;

插入：

注意：我们不允许插入相同的数字！

整体逻辑是先找到插入的位置，但要注意一下要记录父亲的位置，否则找到时cur为空，没法链接了~

	bool Insert(const K& key)
	{
		Node* newnode = new Node(key);
		if (_root == nullptr)
		{
			_root = newnode;
		}
		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
			{
				return false;
			}
		}
		// 插入操作
		if (parent->_key < key)
		{
			parent->_right = newnode;
		}
		else
		{
			parent->_left = newnode;
		}
		return true;
	}

删除：

删除有一点繁琐，需要将各种情况考虑到位。

  • a. 要删除的结点无孩子结点
  • b. 要删除的结点只有左孩子结点
  • c. 要删除的结点只有右孩子结点
  • d. 要删除的结点有左、右孩子结点

那我们针对这几种情况各需要进行怎样的处理呢？
首先a情况是可以归类为b与c，因为叶子节点也符合嘛

那我们现在看看如何处理~

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
	{
		// erase
		// ...删除操作
}

情况a：
在这里插入图片描述
情况b与c（因为都只有一个孩子，所以放在一起讨论了）：
在这里插入图片描述

情况a，b，c的代码

注意：有可能出现单边树的情况，此时需要更新一下root节点的值。

if (cur->_left == nullptr)
{
	if (parent == nullptr)
	{
		_root = cur->_right;
	}
	else
	{
		if (parent->_left == cur)
			parent->_left = cur->_right;
		else
			parent->_right = cur->_right;
	}
}
else if(cur->_right == nullptr)
{
	if (parent == nullptr)
	{
		_root = cur->_left;
	}
	else
	{
		if (parent->_left == cur)
			parent->_left = cur->_left;
		else
			parent->_right = cur->_left;
	}
}

情况d：
在这里插入图片描述

我们选择左子树最大节点作为替换节点
由于我们还要进行情况b与c（在这里我们不需要进行_root的更新，因为删除的节点肯定不会是_root），所以需要一个父指针指向左子树最大节点的父亲进行链接。
但是要注意，这里的FMaxLeft要自己灵活控制，下面只是一种方式之一，（比如父指针还是给空，但是我们要进行判断一下。）在这里插入图片描述

else
{
	Node* MaxLeft = cur->_left;
	Node* FMaxLeft = cur->_left;
	while (MaxLeft->_right)
	{
		FMaxLeft = MaxLeft;
		MaxLeft = MaxLeft->_right;
	}
	cur->_key = MaxLeft->_key;
	del = MaxLeft;
	if (FMaxLeft == MaxLeft)
	{
		cur->_left = nullptr;
	}
	else if (FMaxLeft->_left == MaxLeft)
	{
		FMaxLeft->_left = MaxLeft->_left;
	}
	else
	{
		FMaxLeft->_right = MaxLeft->_left;
	}
}

递归版的插入与删除：

注意这里的引用用的很妙，不需要在记录parent指针了

	bool _InsertR(Node*& root, const K& key)
	{
		if (root == nullptr)
		{
			root = new Node(key);
			return true;
		}
		if (root->_key > key)
		{
			return _InsertR(root->_left, key);
		}
		else if(root->_key < key)
		{
			return _InsertR(root->_right, key);
		}
		else
		{
			return false;
		}
	}

	bool _eraseR(Node*& root, const K& key)
	{
		if (root == nullptr)
		{
			return false;
		}
		if (root->_key > key)
		{
			return _eraseR(root->_left, key);
		}
		else if (root->_key < key)
		{
			return _eraseR(root->_right, key);
		}
		else
		{
			if (root->_left == nullptr)
			{
				Node* del = root;
				root = root->_right;
				delete del;
			}
			else if (root->_right == nullptr)
			{
				Node* del = root;
				root = root->_left;
				delete del;
			}
			else
			{
				Node*& MaxLeft = root->_left;
				while (MaxLeft->_right)
				{
					MaxLeft = MaxLeft->_right;
				}
				swap(root->_key, MaxLeft->_key);
				_eraseR(MaxLeft, key);
			}
			return true;
		}
		return false;
	}

从递归这里我们可以看到很好的利用的引用的特性，不需要额外使用多余的对象去进行记录。

完整源码：

源码附带了析构，拷贝等函数（比较简单就没有写在上边），更加完整

#pragma once
#include <iostream>
using namespace std;

template<class K>
struct BinarySearchTreeNode
{
	BinarySearchTreeNode(int key)
		:_left(nullptr)
		,_right(nullptr)
		,_key(key)
	{}
	typedef BinarySearchTreeNode<K> BSTNode;
	BSTNode* _left;
	BSTNode* _right;
	K _key;
};

template<class K>
class BinarySearchTree
{
private:
	typedef BinarySearchTreeNode<K> Node;
public:
	BinarySearchTree()
	{}

	~BinarySearchTree()
	{
		destory(_root);
	}
	BinarySearchTree(const BinarySearchTree<K>& BSTree)
	{
		_root = copy(BSTree._root);
	}
	bool Insert(const K& key)
	{
		Node* newnode = new Node(key);
		if (_root == nullptr)
		{
			_root = newnode;
		}
		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
			{
				return false;
			}
		}
		// 插入操作
		if (parent->_key < key)
		{
			parent->_right = newnode;
		}
		else
		{
			parent->_left = newnode;
		}
		return true;
	}

	bool InsertR(const K& key)
	{
		return _InsertR(_root, key);
	}

	void InOrder()
	{
		_InOrder(_root);
	}

	bool eraseR(const K& key)
	{
		return _eraseR(_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
			{
				// erase
				Node* del = cur;
				if (cur->_left == nullptr)
				{
					if (parent == nullptr)
					{
						_root = cur->_right;
					}
					else
					{
						if (parent->_left == cur)
							parent->_left = cur->_right;
						else
							parent->_right = cur->_right;
					}
				}
				else if(cur->_right == nullptr)
				{
					if (parent == nullptr)
					{
						_root = cur->_left;
					}
					else
					{
						if (parent->_left == cur)
							parent->_left = cur->_left;
						else
							parent->_right = cur->_left;
					}
				}
				else
				{
					Node* MaxLeft = cur->_left;
					Node* FMaxLeft = nullptr;
					while (MaxLeft->_right)
					{
						FMaxLeft = MaxLeft;
						MaxLeft = MaxLeft->_right;
					}
					cur->_key = MaxLeft->_key;
					del = MaxLeft;
					if (FMaxLeft == nullptr)
					{
						cur->_left = nullptr;
					}
					else if (FMaxLeft->_left == MaxLeft)
					{
						FMaxLeft->_left = MaxLeft->_left;
					}
					else
					{
						FMaxLeft->_right = MaxLeft->_left;
					}
				}
				delete del;
				return true;
			}
		}
		return false;
	}
private:
	bool _InsertR(Node*& root, const K& key)
	{
		if (root == nullptr)
		{
			root = new Node(key);
			return true;
		}
		if (root->_key > key)
		{
			return _InsertR(root->_left, key);
		}
		else if(root->_key < key)
		{
			return _InsertR(root->_right, key);
		}
		else
		{
			return false;
		}
	}

	bool _eraseR(Node*& root, const K& key)
	{
		if (root == nullptr)
		{
			return false;
		}
		if (root->_key > key)
		{
			return _eraseR(root->_left, key);
		}
		else if (root->_key < key)
		{
			return _eraseR(root->_right, key);
		}
		else
		{
			if (root->_left == nullptr)
			{
				Node* del = root;
				root = root->_right;
				delete del;
			}
			else if (root->_right == nullptr)
			{
				Node* del = root;
				root = root->_left;
				delete del;
			}
			else
			{
				Node*& MaxLeft = root->_left;
				while (MaxLeft->_right)
				{
					MaxLeft = MaxLeft->_right;
				}
				swap(root->_key, MaxLeft->_key);
				_eraseR(MaxLeft, key);
			}
			return true;
		}
	}

	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 destory(Node* root)
	{
		if (root == nullptr)
		{
			return;
		}
		Node* left = root->_left;
		Node* right = root->_right;
		delete root;
		destory(left);
		destory(right);
	}
	void _InOrder(Node* root)
	{
		if (root == nullptr)
		{
			return;
		}
		_InOrder(root->_left);
		cout << root->_key << " ";
		_InOrder(root->_right);
	}
	Node* _root = nullptr;
};

总结：

BSTree还是很简单的，但还是要注意细节的把控，尤其是删除的地方，要画图仔细分析一下。

有问题的话欢迎进行讨论哦~

统一热红茶
关注
  • 8
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
PTA 数据结构 二叉搜索树的结构
weixin_42606045的博客
11-11 1678
7-2 二叉搜索树的结构 （30 分） 二叉搜索树或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值；若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；它的左、右子树也分别为二叉搜索树。（摘自百度百科） 给定一系列互不相等的整数，将它们顺次插入一棵初始为空的二叉搜索树，然后对结果树的结构进行描述。你需要能判断给定的描述是否正确...
数据结构 二叉搜索树
08-06
大二《数据结构》课程设计 二叉搜索树实现算法
【Java 数据结构】实现一个二叉搜索树
程序猿教你打篮球的博客
01-09 6872
本期主要讲解： 1、认识二叉搜索树 2、实现一个二叉搜索树 2.1 成员变量 2.2 insert 方法 2.3 search 方法 2.4 remove 方法(重点) 3、二叉搜索树总结
数据结构 二叉搜索树的删除
小手挥墨
04-30 4270
文章目录概述待删除的结点没有子树待删除的结点仅有一颗子树待删除的结点有两颗子树C代码实现 概述 这是一篇短文，专门考究一下二叉搜索树的删除。 二叉搜索树的建立非常简单，如果不熟悉的见此文 树与二叉树。 而删除则有数种情况： 待删除的结点没有子树。 待删除的结点仅有一颗子树。 待删除的结点有两颗子树。 下面逐一分析。 待删除的结点没有子树 如需删除下图中结点9： 这是最简单的一种情况，它没有子...
数据结构-二叉搜索树
m0_61433144的博客
08-07 1605
二叉搜索树也称二叉排序树或者二叉查找树，它是在普通二叉树上加入一些特性所形成的： 1，若左子树非空，则左子树上所有结点的值均小于根结点的值。 2，若右子树非空，则右子树上所有结点的值均大于根结点的值。 3，其左右子树也分别是一棵二叉搜索树。......
【数据结构】二叉查找树/二叉搜索树BST（附相关C++代码）
weixin_50941083的博客
05-14 845
本文内容将主要介绍二叉查找树的相关概念，与关于二叉查找树的重要操作，如添加节点、删除节点等。
Java数据结构——二叉搜索树
chenchenchencl的博客
10-19 1245
Java数据结构——二叉搜索树
『数据结构』二叉搜索树
叄拾叄画生
07-11 4616
什么是二叉搜索树？二叉搜索树的基本操作。二叉搜索树的查找、插入、删除等。二叉搜索树的性能分析。二叉搜索树的模拟实现（C++和Java）。模拟实现中遇到的问题。
数据结构——二叉搜索树 Python实现
2301_80278591的博客
04-18 646
基于二叉搜索树每个节点中的数值大小均满足：左子节点的值 < 根节点的值 < 右子节点的值的特点，二叉搜索树在搜索值时是依照二分来进行查找的，即先将待查找的值与每棵子树的根节点的值进行比较，当待查找的值小于每棵子树的根节点的值时，到该根节点的左子树递归查找；二叉树的许多相关操作是和递归密不可分的。所谓二叉搜索树，其实本质上就是一个树状的数据结构，也是有一个根节点和若干个子树所组成的，其基于二叉树的结构，而在其数据的填充位置上所进行优化而得到的数据结构，并运用二叉搜索树数据的分布特点来实现在搜索功能。
数据结构二叉搜索树02
vfjcgg的博客
12-06 413
二叉搜素树, BST, binary search tree。二叉查找树、二叉排序树。 二叉搜索树其实就是普通的二叉树上加了—些限制 二叉树对于结点是没有任何的限制，但是在二叉搜索树中在插入子结点的有一些特殊的要求: 1、非空左子树的所有的键值都小于其根结点的键值 2、非空右子树的所有键值都大于其根结点的键值3、左右子树本身也都是二叉搜索树 二叉搜索树的特点:相对较小的值总是保存在左子结点上，相对较大的值总是保存在右子结点上 二叉搜索树 // 结点类 class Node{ constructor(va
陈越、何钦铭-数据结构作业12：是否同一棵二叉搜索树
04-20
给定一个插入序列就可以唯一确定一棵二叉搜索树。然而，一棵给定的二叉搜索树却可以由多种不同的插入序列得到。例如分别按照序列{2, 1, 3}和{2, 3, 1}插入初始为空的二叉搜索树，都得到一样的结果。于是对于输入的...
陈越、何钦铭-数据结构作业8：二叉搜索树的操作集
03-28
函数Insert将X插入二叉搜索树BST并返回结果树的根结点指针； 函数Delete将X从二叉搜索树BST中删除，并返回结果树的根结点指针；如果X不在树中，则打印一行Not Found并返回原树的根结点指针； 函数Find在二叉搜索树...
javascript数据结构之二叉搜索树实现方法
10-23
主要介绍了javascript数据结构之二叉搜索树实现方法,较为详细的分析了二叉搜索树的概念、原理与JavaScript实现二叉搜索树的方法,对于学习JavaScript数据结构具有一定参考借鉴价值,需要的朋友可以参考下
数据结构逻辑
qq_42129915的博客
06-10 277
1、线性关系2：树型关系3：图像关系。
【数据结构】 -- 堆 （堆排序）（TOP-K问题）
prettyxian的博客
06-09 1021
要学习堆，首先要先简单的了解一下二叉树，二叉树是一种常见的树形数据结构，每个节点最多有两个子节点，通常称为左子节点和右子节点。二叉树的应用非常广泛，在后面我会详细介绍。满二叉树：除了叶子结点外，每个结点都有两个子结点一个深度为k的满二叉树有2的k次方减一个节点。完全二叉树：除了最底层可能不是满的外，其它每一层从左到右都是满的。满二叉树是完全二叉树的子集，满二叉树一定是完全二叉树，但完全二叉树不一定是满二叉树。堆就是一种完全二叉树。
【算法】常用排序算法（插入排序、希尔排序、堆排序、选择排序、冒泡排序、快速排序、归并排序、计数排序）超详细
abcwyffff的博客
06-09 987
排序算法是数据结构相关知识中非常重要的一节，相信很多小伙伴对这部分知识一知半解。那么接下来，小编就要带领大家一起来进行对排序算法的深入剖析学习，希望本篇文章能够使你有所收获！
如何使用Python中的collections模块提供的数据结构，如deque、Counter、OrderedDict等
2402_84885073的博客
06-09 366
Python 的模块提供了一些额外的数据结构，这些数据结构在内置的数据类型（如列表、字典、集合等）的基础上，增加了额外的功能或优化了性能。下面是如何使用模块中的dequeCounter和这三种数据结构的简单示例。
数据结构-二叉树
最新发布
passworddddddd的博客
06-12 175
树（Tree）是一种非常重要的数据结构，它模拟了一种层级或者分支结构。在树结构中，数据以节点（Node）的形式存储，并且每个节点都可以有零个或多个子节点。除了二叉树最后一层，其他各层的节点数都达到最大个数，且最后一层从左向右的叶节点连续存在，只缺右侧若干节点。完美二叉树是特殊的完全二叉树。除了最下一层的叶子节点外，每层节点都有两个子节点，就构成了满二叉树。如果树中每个节点最多只能有两个子节点，这样的树就称之为二叉树。
数据结构二叉搜索树avl树
04-12
二叉搜索树（Binary Search Tree，简称BST）是一种特殊的二叉树，它的左子树所有节点的关键值（键值）小于根节点的关键值，而右子树所有节点的关键值大于根节点的关键值。AVL树则是一种自平衡的二叉搜索树，它保证任何节点的左右子树高度差不超过1，因此能够保证树的查找、插入、删除等操作的时间复杂度为O(logN)。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值