【C++】学习笔记——二叉搜索树

已于 2024-05-23 22:09:11 修改
阅读量837 收藏 11
点赞数 9
分类专栏： C++学习 文章标签： c++ 学习 笔记
于 2024-05-20 19:02:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_69828905/article/details/139064971
版权

文章目录

十四、二叉搜索树

1. 二叉搜索树的概念

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

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

在这里插入图片描述

二叉搜索树的查找非常方便，最多查找 树的高度 次就能找到，他还有一个隐藏特点：二叉搜索树的中序遍历是有序的。

2. 二叉搜索树的实现

二叉搜索树，树是一种结构，需要用类来定义，节点也是一种结构，需要另一个类来定义。节点对数来说是完全公开的，所以节点我们使用 struct 。我们创建一个头文件：BinarySearchTree.h ，在里面先编写一个框架出来：

#pragma once

// 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:
	//
private:
	Node* _root = nullptr;
};

查找

二叉搜索树非常适合查找，逻辑也非常简单。通过不断与当前节点比较而选择进入左子树或者右子树。

bool Find(const K& key)
{
	Node* cur = _root;

	// cur处有节点
	while (cur)
	{
		// 要查找的值比当前节点的值要小
		if (key < cur->_key)
		{
			// 前往左子树
			cur = cur->_left;
		}
		//要查找的值比当前节点的值要大
		else if (key > cur->_key)
		{
			// 前往右子树
			cur = cur->_right;
		}
		// 相等时
		else
		{
			return true;
		}
	}
	// 没找到
	return false;
}

在这里插入图片描述

插入

插入也是比较简单的，当插入的关键字已存在时，现阶段没有多大用处，我们就插入已有的关键字，当关键字不存在时，也是一种查找，当 找到空位置 时，该位置就可以插入。唯一需要注意的是，需要使用一个指针指向插入位置的父节点，否则无法进行节点之间的连接。

bool Insert(const K& key)
{
	// 注意空树
	if (_root == nullptr)
	{
		_root = new Node(key);
		return true;
	}

	Node* cur = _root;
	Node* parent = nullptr;
	while (cur)
	{
		if (key < cur->_key)
		{
			parent = cur;
			cur = cur->_left;
		}
		else if (key > cur->_key)
		{
			parent = cur;
			cur = cur->_right;
		}
		else
		{
			// 现阶段不插入相同的值
			return false;
		}
	}

	// 创建新节点
	cur = new Node(key);
	if (key < parent->_key)
	{
		// 新节点插在左子树
		parent->_left = cur;
	}
	else
	{
		// 新节点插在右子树
		parent->_right = cur;
	}

	return true;
}

中序遍历

中序遍历需要借助当前节点，所以需要一个形参，但是根节点又是属于类的私有成员变量，在外部无法访问，所以我们需要嵌套一层函数来访问。

// private内
void _InOrder(Node* root)
{
	if (root == nullptr)
	{
		return;
	}

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

// 套一层函数来获取根节点
// public内
void InOrder()
{
	_InOrder(_root);
	std::cout << std::endl;
}

我们来测试一下：创建一个源文件 Test.cpp。

#include <iostream>
#include "BinarySearchTree.h"
using namespace std;

int main(void)
{
	BSTree<int> t;
	int a[] = { 8,3,1,10,6,4,7,14,13 };
	for (auto e : a)
	{
		t.Insert(e);
	}
	t.InOrder();
	return 0;
}

在这里插入图片描述
二叉搜索树的中序遍历确实是有序的，看来前面的函数都没有问题。

删除

前面的函数其实都是比较简单的，二叉搜索树的删除会比较困难。二叉搜索树的删除分为三种情况：

  1. 删除没有孩子节点的节点。
    在这里插入图片描述
    比如删除上图中的 1 4 7 13 。这种情况最简单，直接删掉即可。
  2. 删除只有一个孩子的节点。
    在这里插入图片描述
    如上图中的 10 14 。这种情况也算是比较简单的，比如说我们要删除 14 。我们只需要将 14 的孩子 托付给 14 的父节点 即可。
    在这里插入图片描述
  3. 删除有两个孩子的节点。


比如删除上图中的 8 3 6 。这种情况最为复杂，也最难。这种情况该怎么删除呢？有一种方法叫做 替换删除法 ，比如说我要删除 3 ，我可以从 3 的孩子里找出能够替换掉 3 的节点，即 左子树中的最右侧（最大）的节点，或者右子树中的最左侧（最小）的节点 。这两个节点与被删除的节点替换都可以完成删除操作。
在这里插入图片描述

在这里插入图片描述

其实情况1和情况2差不多，因为情况1同样可以理解为将 空托付给父节点 。

bool Erase(const K& key)
{
	Node* cur = _root;
	Node* parent = nullptr;
	while (cur)
	{
		if (key < cur->_key)
		{
			parent = cur;
			cur = cur->_left;
		}
		else if (key > cur->_key)
		{
			parent = cur;
			cur = cur->_right;
		}
		// 找到了要删除的节点
		else
		{
			// 左子树为空，托付右子树
			if (cur->_left == nullptr)
			{
				if (cur == parent->_left)
				{
					parent->_left = cur->_right;
				}
				else
				{
					parent->_right = cur->_right;
				}
				delete cur;
				return true;
			}
			// 右子树为空，托付左子树
			else if (cur->_right == nullptr)
			{
				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 (rightMin->_left)
				{
					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;
			}
		}
	}

	return false;
}

上面的函数有两个小细节，①假如删除8，则其右孩子 10 就是要删除的节点，所以 rightMinParent 不能初始化为 nullptr。②假如删除8，则其右孩子 10 就是要删除的节点，此时 10 是 8 的右节点，所以 rightMin 不一定是 rightMinParent 的左节点。
测试一下：

#include <iostream>
#include "BinarySearchTree.h"
using namespace std;

int main(void)
{
	BSTree<int> t;
	int a[] = { 8,3,1,10,6,4,7,14,13 };
	for (auto e : a)
	{
		t.Insert(e);
	}
	t.InOrder();
	t.Erase(8);
	t.InOrder();
	return 0;
}

在这里插入图片描述
已经没有问题了吗？NoNoNo，当要删除的节点是根节点，并且只有左子树或者只有右子树时就会出问题了。此时 Parent 为 nullptr 但是被解引用了，所以我们需要加一下判断：

bool Erase(const K& key)
{
	Node* cur = _root;
	Node* parent = nullptr;
	while (cur)
	{
		if (key < cur->_key)
		{
			parent = cur;
			cur = cur->_left;
		}
		else if (key > cur->_key)
		{
			parent = cur;
			cur = cur->_right;
		}
		// 找到了要删除的节点
		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 (rightMin->_left)
				{
					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;
			}
		}
	}

	return false;
}

拷贝构造

由于默认生成的拷贝构造函数是浅拷贝，直接拷贝构造会导致两个对象指向同一个二叉搜索树，我们要实现深拷贝所以要手动写一个拷贝构造函数。

// 强制生成默认构造函数
BSTree() = default;

// 拷贝构造函数
BSTree(const BSTree<K>& t)
{
	_root = Copy(t._root);
}

// private内
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;
}

析构函数

~BSTree()
{
	Destroy(_root);
}

// private内
void Destroy(Node* root)
{
	if (root == nullptr)
	{
		return;
	}

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

测试一下：

#include <iostream>
#include "BinarySearchTree.h"
using namespace std;

int main(void)
{
	BSTree<int> t;
	int a[] = { 8,3,1,10,6,4,7,14,13 };
	for (auto e : a)
	{
		t.Insert(e);
	}
	t.InOrder();
	BSTree<int> t1(t);
	t1.InOrder();
	return 0;
}

在这里插入图片描述

赋值重载

BSTree<K>& operator=(BSTree<K> t)
{
	std::swap(_root, t._root);
	return *this;
}

完整代码

#pragma once

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

	BSTree<K>& operator=(BSTree<K> t)
	{
		std::swap(_root, t._root);
		return *this;
	}

	// 析构函数
	~BSTree()
	{
		Destroy(_root);
	}

	bool Insert(const K& key)
	{
		if (_root == nullptr)
		{
			_root = new Node(key);
			return true;
		}

		Node* cur = _root;
		Node* parent = nullptr;
		while (cur)
		{
			if (key < cur->_key)
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (key > cur->_key)
			{
				parent = cur;
				cur = cur->_right;
			}
			else
			{
				// 现阶段不插入相同的值
				return false;
			}
		}

		// 创建新节点
		cur = new Node(key);
		if (key < parent->_key)
		{
			// 新节点插在左子树
			parent->_left = cur;
		}
		else
		{
			// 新节点插在右子树
			parent->_right = cur;
		}

		return true;
	}

	bool Find(const K& key)
	{
		Node* cur = _root;

		// cur处有节点
		while (cur)
		{
			// 要查找的值比当前节点的值要小
			if (key < cur->_key)
			{
				// 前往左子树
				cur = cur->_left;
			}
			//要查找的值比当前节点的值要大
			else if (key > cur->_key)
			{
				// 前往右子树
				cur = cur->_right;
			}
			// 相等时
			else
			{
				return true;
			}
		}
		// 没找到
		return false;
	}

	void InOrder()
	{
		_InOrder(_root);
		std::cout << std::endl;
	}

	bool Erase(const K& key)
	{
		Node* cur = _root;
		Node* parent = nullptr;
		while (cur)
		{
			if (key < cur->_key)
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (key > cur->_key)
			{
				parent = cur;
				cur = cur->_right;
			}
			// 找到了要删除的节点
			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 (rightMin->_left)
					{
						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;
				}
			}
		}

		return false;
	}
private:
	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 _InOrder(Node* root)
	{
		if (root == nullptr)
		{
			return;
		}

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

	void Destroy(Node* root)
	{
		if (root == nullptr)
		{
			return;
		}

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

	Node* _root = nullptr;
};

3. 二叉搜索树的应用

K搜索模型

K搜索模型主要运用于想要 快速找到某个值在不在 。比如说门禁系统。

KV搜索模型

KV搜索模型主要运用于想要 通过某个值（key）查找另一个值（value）在不在 。比如说商场车库，通过车牌号找到进车库的时间好用来计费。

上面实现的就是 K搜索模型 ，如何实现 KV搜索模型 呢？其实也不难，节点结构体内多存入一个 value 即可，然后输入 key 的时候也要输入 value。逻辑与 K搜索模型 大差不差。

未完待续

lge101058
关注
  • 9
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
《数据结构、算法与应用 —— C++语言描述》学习笔记 — 二叉搜索树
coding-hwz
09-30 182
《数据结构、算法与应用 —— C++语言描述》学习笔记 — 二叉搜索树一、二叉搜索树1、二叉搜索树特征2、索引二叉搜索树二、二叉搜索树实现 一、二叉搜索树 前面我们学习了抽象数据类型 dictionary，使用散列实现的字典操作（查找、插入和删除）所需要的平均时间为O(1)O(1)O(1)。而这些操作在最坏情况下的时间与字典的元素个数呈线性关系。对于以下操作，散列并不具备哦较好的平均性能： （1）升序输出字典元素 （2）升序找到第 k 个元素 （3）删除第 k 个元素。 为了执行操作（1）需要从表中收集数据
二叉搜索树+C++程序+对二叉搜索树的基本操作
02-16
二叉搜索树+C++程序+对二叉搜索树的基本操作：包括查找、插入、删除元素。 文件是标准cpp文件，可以在devc++上成功运行，在vs上运行，稍加编辑便可以。 建议用devc，此软件使用方便。
C++学习笔记——二叉搜索树
Coulnaut的博客
07-15 324
接下来的部分将会记录一些数据结构。有时候看一本书，就像欣赏一部电影，在无数的铺垫后，结局便浮现出来了。先来说一说第一个数据结构——二叉搜索树。 目录 概念 基础操作 创建 插入 查询 删除 彩蛋 概念 二叉搜索树，之所以是搜索树，是因为便于搜索。二叉搜索树可以说是堆的一种进化，因为堆的父亲结点总是比孩子结点大或者小，这要看是大堆还是小堆。那么二叉搜索数满足的是节点总是比左...
人工智能导论学习笔记03——二叉查找树
weixin_51128278的博客
09-01 300
人工智能导论学习笔记03——二叉查找树 人工智能导论学习笔记人工智能导论学习笔记03——二叉查找树二叉搜索树算法实现1. 二叉排序树的查找算法2. 在二叉排序树插入结点的算法3. 在二叉排序树删除结点的算法4. 二叉排序树性能分析代码实现python**构造一个BST**删除叶节点删除只有一个孩子的节点删除有两个孩子的内部节点时间复杂度分析练习题：延伸阅读Leetcode附录C++代码实现：参考 肝！ 二叉搜索树 二叉查找树(Binary Search Tree)，(又:二叉搜索树，二叉排序树)它或者是
7.数据结构C++学习笔记——树和二叉树
qq_46417568的博客
05-17 378
1. 1 树形结构结点之间有分支，具有层次关系树（Tree）是个结点的有限集。若n=0，称为空树。若n>0，则它满足如下两个条件：（1）有且只仅有一个特定的称为根（Root）的结点。（2）其余节点可分为m(m>=0)个互不相交的有限集T1,T2,T3...其中每一个集合本身又是一棵树，并称为根的子树（SubTree）。显然，树的定义是递归的定义。图 1.2.1 树的示意图个节点最多只有两个“叉”的树，普通树（多叉树）若不转为二叉树，则运算很难实现。
PTA数据结构题目集 第四周——二叉搜索树&二叉平衡树
cos的博客
08-08 1246
PTA数据结构题目集 第四周——二叉搜索树&二叉平衡树，涉及知识为二叉搜索树和平衡二叉树的基本操作，所用语言为c++。
C++学习笔记——AVL树
Coulnaut的博客
07-16 217
上回说到，二叉搜索树的时间复杂度并不稳定，于是进化出了另外一种树，AVL树，也叫平衡树。 目录 1、概念 2、定义 3、插入 3.1 左单旋 3.2右单旋 3.3左右双旋 3.4右左双旋 彩蛋 1、概念 由于搜索二叉树对一个已经有序的数据进行插入的话，则会变成一个上一篇博文所画的树，变成一个类似单链表的树。它的查找效率就和单链表的时间复杂度是一样的，O(N)。于是有了一...
C++学习笔记——红黑树
Coulnaut的博客
07-20 341
在前面的基础上，来到最后一棵树，红黑树。 目录 概念 性质 结点的定义 树的结构与定义 红黑树的插入 概念 红黑树又可以叫双色树，只要有能够进行区分的两种颜色就行，通常是红色和黑色。它也是一种二叉搜索树，只是在每个结点上增加了颜色。通过颜色，来让这棵树达到平衡。 性质 以红黑两种颜色为例，可以看上面的图，来看下面的性质。 根节点都是黑色 如果一个结点是红色的，则它...
C++学习笔记（23）——二叉树进阶
broken_enginer的博客
06-12 452
二叉树的数据有序性由地址链接实现。
学习笔记——树
weixin_53851097的博客
03-02 304
自学——二叉树
二叉搜索树的c++实现
07-05
使用二叉链表和c++来实现二叉搜索树，提供插入、删除、遍历、求最小节点、最大最节点等操作。
二叉树-基于C++实现的二叉搜索树.zip
04-26
二叉树 二叉树_基于C++实现的二叉搜索树
C++ 二叉搜索树(BST)的实现方法
08-30
主要介绍了C++ 二叉搜索树(BST)的实现方法，非常不错，具有参考借鉴价值，需要的的朋友参考下
信息奥赛c++学习笔记——贪心算法
01-06
一，算法 在当前状态下找出局部最优解，转化为全局最优解。 二，活动安排问题 1.问题描述：给定n个开区间（ai，bi），在给定范围内尽量选择多个区间，使得这些区间两两没有公共点。 2.算法：按照结束时间bi从小到大...
【C++】——Stack与Queue（含优先队列（详细解读）
m0_74092462的博客
06-09 979
优先队列是一种容器适配器，根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。stack是一种容器适配器，专门用在具有后进先出操作的上下文环境中，其删除只能从容器的一端进行元素的插入与提取操作。 队列是一种容器适配器，专门用于在FIFO上下文(先进先出)中操作，其中从容器一端插入元素，另一端提取元素。
C++——计算不同的非空子串个数
我发布的博客，快来抄答案吧
06-09 132
BCSP-X 11题 C++代码详解
LeetCode 算法：轮转数组c++
小金牛来了
06-09 654
LeetCode 算法：轮转数组c++
手搓顺序表（C语言）
最新发布
m0_62646213的博客
06-12 1093
顺序表头插头删，尾插尾删，任意位置插入删除的实现和优劣分析
怎么用c++写一个二叉搜索树
05-26
以下是一个简单的 C++ 代码示例，用于实现二叉搜索树： ```cpp #include using namespace std; // 定义二叉搜索树节点 struct BSTNode { int data; BSTNode* left; BSTNode* right; }; // 创建新节点 ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值