【C++、数据结构】二叉搜索树 模拟实现

已于 2023-04-24 15:11:56 修改
阅读量601 收藏 12
点赞数 21
分类专栏： 数据结构 C++ 文章标签： c++ 数据结构
于 2022-12-29 19:14:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_63059866/article/details/128459747
版权

文章目录

📖 前言

  • 从本章起，我们开始深入学习二叉树，学习其更高端的应用，然后将学习STL中比较重要的两个容器set和map。
  • 学习二叉搜索树也是为以后学习和实现set和map做铺垫。

1. 二叉搜索树

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

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

在这里插入图片描述

也就是说一棵二叉搜索树的任一个根节点，它的左子树所有节点的值都是小于根节点的值的，它的右子树所有结点的值都是大于根节点的值的。

二叉搜索树查找的时间复杂度：

  • 根据二叉搜索树的性质
  • 我们大多数人认为其搜索的一个值的速度是为树的高度次
  • 树的高度次的话，很多人就会认为是log2N次
  • 但是事实并不是，正确得查找时间复杂度是〇（N）

只有当是满二叉树或者是完全二叉树时间复杂度才是〇（logN）！！

解释：

当出现单边树的情况时，就是〇（N）的情况。
在这里插入图片描述

此时树的高速就是结点的个数，同时如果数据量过大，而且是递归查找的话，很有可能会有爆栈的风险！！
在以后我们会学习平衡二叉树，就是为了解决上述情况的问题。

2. 二叉搜索树的模拟实现

2.1 结点的声明

template<class K>

struct BSTreeNode
{
	BSTreeNode<K>* _left;
	BSTreeNode<K>* _right;

	K _key;

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

2.2 基本的几个成员函数

template<class K>

class BSTree
{                
	typedef BSTreeNode<K> Node;
private:
	//没有参数是不能递归的
	void DestroyTree(Node* root)
	{
		if (root == nullptr)
			return;

		DestroyTree(root->_left);
		DestroyTree(root->_right);
		delete root;
	}

	Node* CopyTree(Node* root)
	{
		if (root == nullptr)
			return nullptr;

		Node* copyNode = new Node(root->_key);
		copyNode->_left = CopyTree(root->_left);
		copyNode->_right = CopyTree(root->_right);
		
		return copyNode;
	}
public:
	//强制编译器自己生成构造函数 -- C++11
	BSTree() = default;

	/*BSTree()
		:_root(nullptr)
	{}*/

	//前序遍历递归拷贝
	BSTree(const BSTree<K>& t)
	{
		_root = CopyTree(t._root);
	}

	//t1 = t2; -- 任何赋值重载都可以用现代写法
	BSTree<K>& operator=(BSTree<K> t)
	{
		swap(_root, t._root);
		return *this;
	}

	~BSTree()
	{
		DestroyTree(_root);
		_root = nullptr;
	}

构造函数：

  • 这里我们可以采用传统的方法
  • 直接初始化成员变量
  • 也可以用C++11的语法default
  • 强制编译器自己生成构造函数

拷贝构造：

  • 这里我们用了递归的方式进行拷贝
  • 采用根 - 左 - 右 的前序遍历的递归方式对整个二叉树拷贝
  • 最后将跟结点返回

析构函数：

  • 析构函数我们这里也是采用递归的方式进行一个一个结点析构
  • 同样的我们再嵌套一个子函数
  • 也是采用类似前序遍历的方法将整个二叉树释放掉

采用递归方式的缺点就是如果数的结点个数足够多的时候，就会有爆栈的风险！！

非递归版本

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

根据二叉搜索树的性质，查找规则很简单：

  • 从根节点开始找起
  • 要找的值如果比根节点的值大，则在根节点的右子树中找
  • 要找的值如果比根节点的值小，则在根节点的左子树中找
  • 再在子树中重复上述操作，最终找到要找的值

所以再没有平衡二叉搜索树的情况下，查找的时间复杂度为〇（N）

（2）插入：
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
			{
				parent = cur;
				cur = cur->_left;
			}
		}

		cur = new Node(key);
		if (parent->_key < key)
		{
			parent->_right = cur;
		}
		else
		{
			parent->_left = cur;
		}

		return true;
	}

根据搜索二叉树的特性，插入规则如下：

  • 上述过程也是一个查找的过程
  • 根据要插入值的大小，定位其在树中合适的位置
  • 找到合适位置之后，直接插入即可
（3）删除：（重点）

二叉搜索树的删除，是一件非常麻烦的事情

  • 要删除结点，就要理清楚父子节点的链接关系（一不留神就把关系理乱了）
  • 要求删过之后的二叉树还是一棵搜索二叉树（相当困难，普通直接删除做不到）

分析问题：

  • （1）当没有孩子或者只有一个孩子时
  • 可以直接删除，孩子托管给父亲 — (托孤)

在这里插入图片描述
以删除14这个结点为例：

  • 该结点比10这个结点（父结点）大，在其右子树
  • 那么该右子树的所有的值都比10这个结点大
  • 所以要链接在10这个结点的右边

以删除7这个结点为例：

  • 该结点比6这个结点（父结点）大，在其右子树
  • 因为7这个结点没有孩子
  • 直接删除，将父节点（6结点）的右指向空
  • （2）当有两个孩子时
  • 没办法给父亲，父亲养不了，要找个人替代我养孩子

核心步骤：

  • 要找到 【左子树的最大值节点，或者右子树的最小值节点】
  • 找到之后，将要删除的结点和找到的结点的值进行交换（这里我们暂时用的是值交换）
  • 再将被交换过之后的值的结点删除
  • 一般被交换的结点都是末尾的叶子结点（按照上述的没有孩子的结点删除方式删除）

代码如下：

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
		{
			//找到了就分三种情况

			//该结点有一个孩子 -- 左为空 or 右为空（托孤）
			//该结点有两个孩子 -- 替换法
			
			//第一种情况：该结点有一个孩子且该结点的左为空
			if (cur->_left == nullptr)
			{
				//当删除的是根节点的时候
				//if(parent == nullptr)
				if (cur == _root)
				{
					_root = cur->_right;
				}
				else
				{
					if (cur == parent->_left)
					{
						parent->_left = cur->_right;
					}
					else
					{
						parent->_right = cur->_right;
					}
				}

				delete cur;
			}
			//第二种情况：该结点有一个孩子且该结点的右为空
			else if (cur->_right == nullptr)
			{
				if (cur == parent)
				{
					_root = cur->_left;
				}
				else
				{
					if (cur == parent->_left)
					{
						parent->_left = cur->_left;
					}
					else
					{
						parent->_right = cur->_left;
					}
				}

				delete cur; 
			}
			//两个孩子都不为空（替换法删除）
			else 
			{
				//我们这里统一找右树最左结点（最小）
				//右子树的最小结点替代

				//minParent一开始不能给空，因为右子树的跟一开始就可能是minRight
				//Node* minParent = nullptr; -- 循环直接不能进去

				Node* minParent = cur;

				//从右子树的根开始
				Node* minRight = cur->_right;
				
				//找最左结点（最小）
				while (minRight->_left)
				{
					minParent = minRight;   
					minRight = minRight->_left;
				}

				//交换
				swap(minRight->_key, cur->_key);
				//**return Erase(key); -- 这是错的，因为这里已经不符合搜索树的规则了
				//递归过程中找不到想要想要删除的数（交换到后头的数）
				
				//直接赋值
				//cur->_key = minRight->_key;     
				                                                 
				//删除

				//找到最小结点，此结点一定是该结点父亲结点的左孩子
				//此结点一定没有左孩子（一定是左为空），有可能有右孩子，也可能没有右孩子
				//此时只需要将父亲的左指向该结点的右孩子即可
				//删除完成

				if (minParent->_left == minRight)
				{
					minParent->_left = minRight->_right;
				}
				else if (minParent->_right == minRight)
				{
					minParent->_right = minRight->_right;
				}

				delete  minRight;
			}

			return true;
		}
	}

	return false;
}

代码解释，如下图：

  • 第一种情况：该结点有一个孩子且该结点的左为空

在这里插入图片描述

  • 第二种情况：该结点有一个孩子且该结点的右为空

在这里插入图片描述

  • 第三种情况：两个孩子都不为空（替换法删除）

在这里插入图片描述
左子树的最大值节点，或者右子树的最小值节点

  • 根据二叉搜索树的特性
  • 任何一个结点的左子树所有结点的值都比根小
  • 任何一个结点的右子树所有结点的值都比根大

找要删除结点的左子树的最大值节点：

  • 那么找左子树的最右边结点
  • 那么该结点一定比根结点的右子树中所有的值都小
  • 但是该结点在根结点的左子树中是最大的
  • 让其和根结点的值交换
  • 将被交换的结点删除后，整棵树仍保持是一棵二叉搜索树

同理，找右子树的最小值节点也是一样的道理

递归版本

递归版本理解起来就相对与非递归版本更好理解了，直接看代码

（1）查找：
bool FindR(const K& key)
{
	return _FindR(_root, key);
}
   
bool _FindR(Node* root, const K& key)
{
	if (root == nullptr)
		return false;

	if (root->_key < key)
	{
		return _FindR(root->_right, key);
	}
	else if (root->_key > key)
	{
		return _FindR(root->_left, key);
	}
	else
	{
		return true;
	}
}

逐层递归查找即可…

（2）插入：（重点）
bool InsertR(const K& key)
{
	return _InsertR(_root, key);
}

bool _InsertR(Node*& root, const K& key)
{
	//没有父指针，胜似父指针
	if (root == nullptr)
	{
		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;
	}
}

该如何链接上树呢？

  • 可以在递归的参数中多一个父亲结点，每次递归都更新一下Parent，然后再带到下一层递归
  • 显然这样在学过C++之后就麻烦了

用了一个指针的引用就解决了问题

  • 因为root的值此时是空，但是root同时是这个结点里的_left这个指针的别名
  • 相当于当前结点的父节点的左指针的别名
  • 意味着此时再去给root赋值就是去给该结点父亲结点的_left赋值
  • 那么此时就链接起来了
（3）删除：
bool EraseR(const K& key)
{
	return _EraseR(_root, key);
}

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
	{
		Node* del = root;
		
		//root是要删除结点的左结点/右结点的别名

		if (root->_left == nullptr)
		{
			root = root->_right;
		}
		else if (root->_right == nullptr)
		{
			root = root->_left;
		}
		else
		{
			Node* minRight = root->_right;
			while (minRight->_left)
			{
				minRight = minRight->_left;
			}

			swap(root->_key, minRight->_key);

			return _EraseR(root->_right, key);
			//转换成在root->_right（右子树）中去删除key
			//这里删除这个key一定会走左为空的场景（找最小）
		}

		delete del;
		return true;
	}
}

相等时就开始删除了（递归只是用来查找要删除的数的位置）

  • root是要删除结点的左结点 / 右结点的别名

分三种情况删除：

  1. 要删除的结点左为空
  2. 要删除的结点右为空
  3. 要删除的结点左右都为空（替换法）

总的来说递归版本比非递归版本更容易理解，删除过程参考非递归删除过程……（有异曲同工之妙）

yy_上上谦
关注
  • 21
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 14
    评论
专栏目录
数据结构【二叉搜索树模拟实现、LeetCode刷题】
我心如火
11-13 384
二叉搜索树模拟实现，LeetCode刷题
模拟实现二叉搜索树超详解（C++）
m0_67430750的博客
05-06 752
模拟实现二叉搜索树，包括了递归和非递归两种版本。
二叉树模拟实现--c
sakeww的博客
09-20 295
BinaryTree.h #pragma once #include<malloc.h> #include<assert.h> #include<stdio.h> //binary tree node data type二叉树节点数据类型 typedef int BTNDataType; typedef struct BTNode { struct BTNode* left; struct BTNode* right; BTNDataType data;//节
C++：二叉搜索树模拟实现（KV模型）
Zhenyu_Coder的博客
02-08 3708
二叉搜索树又称二叉排序树，作为map、set以及红黑树的底层数据结构基础，对于后续模拟实现封装相关解决具体重要意义。同时二叉搜索树分为Key模型和KV模型，在生活中也具有广泛应用，比如英汉字典，通过英文查找对应中文等等。本篇博客将着手二叉搜索树的底层原理，模拟实现二叉搜索树。
C++二叉搜索树模拟实现
kkbca的博客
11-01 265
二叉搜索树讲解+模拟实现 Key模型和Ker-Value模型
【C++】二叉搜索树
m0_62179366的博客
10-24 2062
二叉搜索树的简单应用及实现。
【C++】二叉搜索树模拟实现（两种方法删除节点）
m0_62572672的博客
11-05 817
4.二叉树的删除（方法二：较为推荐）用引用结合递归的方式，具体逻辑没有变化，不过用引用简化了处理指针指向的问题，唯一注意的一点是在交换值之后递归的时候不能直接从根节点开始找。需要手动给出要删除节点所在子树的根节点，不然是找不到的。
【C++进阶】二叉搜索树特性 && 二叉搜索树模拟实现
2301_78611726的博客
05-02 954
我们之前在c语言部分数据结构初阶就已经讲过二叉树了，为什么那时我们不讲二叉搜索树呢？这是有原因的，这里讲二叉树进阶是因为：1.map与set特性需要先铺垫二叉搜索树的概念，理解了二叉搜索树可以更好的理解map与set2.当时用c语言讲二叉树时没有将进阶，是因为这部分较难，长时间下容易忘记。3.一些OJ题更适合用c++解决，当时用c语言会比较麻烦，需要动态开辟数组等。因此有了进阶二叉树部分，是对我们的二叉树进行的收尾总结。
C++：二叉搜索树的底层模拟实现
2301_76445610的博客
05-04 693
最后这个判断的前者是判断是否是正常情况，在正常情况中，最小右子树节点的父节点只是一个普通的节点，且最小右子树节点的父节点的左边一定是最小右子树节点，所以可以让父节点指向最小右字数节点的 右子树。是右指针还是左指针？a、删除的节点他的左子树是空的，则他的父节点要指向他的右子树，同理删除的节点他的右子树是空的，他的父节点要指向他的左子树。删除的节点他的左子树是空的，则他的父节点要指向他的右子树，同理删除的节点他的右子树是空的，他的父节点要指向他的左子树。
二叉查找树 减治法——C++代码
05-24
二叉查找树（Binary Search Tree，BST）是一种特殊的二叉树数据结构，它的每个节点都包含一个键（key）、一个关联的值、一个指向左子树的引用和一个指向右子树的引用。在二叉查找树中，对于任意节点，其左子树中的...
二叉搜索树（C#，C++）
10-11
在C++和C#这两种编程语言中实现二叉搜索树，我们需要关注以下关键点： 1. **数据结构定义**：首先，要定义一个表示节点的类或结构体，它包含键、值、左子节点和右子节点的引用。在C++中，可以定义为`struct Node`，...
使用C++实现相关算法及其数据结构源码
08-09
使用C++实现相关算法及其数据结构源码 List：线性表实现 数组实现 链表实现 StackAndQueue: 栈和队列实现 数组实现 链表实现 String: 串实现 数组实现 KMP算法 BinTree: 二叉树实现 数组实现 先序遍历 中序遍历 ...
C语言操作符详解1（含进制转换，原反补码）
hdxbufcbjuhg的博客
09-02 1345
左移操作符对一个十进制整数的影响是有规律的，无论正负数，都可以对原数值起到乘以2的移位次方的作用，比如将10左移了1位，那么就对原数值乘以了2的一次方，变成了20，依次类推，如果是-10左移了1位，那么就会变成-20对一个无符号数进行右移操作，会对它进行除以2的移位次方，比如将10右移一位，就对它除以了2的一次方，最后变成了5，那如果这个数不是偶数怎么办呢？比如123向右移一位，它除以2就是61.5，最后结果会返回这个数两边较小的整数，61.5的两边分别是61和62，最终得到小的那个数61，所以综上，
C++红黑树的底层原理及其实现原理和实现
2302_80214413的博客
09-02 887
今天给大家带来的是红黑树的底层逻辑和底层实现原理及其实现过程，相信大家看完一定会收获满满！~~~
Linux C 内核编程 /proc 编程例子
yong1585855343的博客
09-02 430
Linux 内核编程 /proc 例子代码
Qt/C++ 个人开源项目#串口助手（源码与发布链接）
最新发布
填坑之路
09-06 392
该串口助手提供了编译好的发布包，用户可以自行下载可以直接启动应用。在应用界面中，选择要连接的串口设备，配置相关串口参数，点击“连接”即可开始数据通信。工具具有直观的用户界面和丰富的功能，旨在帮助用户与串口设备建立可靠通信，便于调试、数据传输和分析。串口助手具备自动检测功能，可以自动识别当前系统中的串口设备。：支持实时显示从串口设备接收的数据，用户可以选择显示格式（如十六进制、ASCII等）。：用户可以通过界面输入并发送数据，支持单次发送和定时发送，便于测试连续传输。：支持无校验、奇校验、偶校验等。
【C++ Primer Plus习题】9.1
qq_74047911的博客
09-02 311
【C++ Primer Plus习题】9.1
森林遍历与树的概念-C++实现
在C++中，处理树与森林的数据结构是实现算法的重要组成部分。本主题将主要讨论森林的遍历以及相关概念。 **树的概念** 树由一个或多个节点组成，其中每个节点可能有零个或多个子节点。在树中，有一个特殊的节点称为...
评论 14
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

yy_上上谦

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

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

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

打赏作者

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

抵扣说明：

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

余额充值