C++二叉树进阶——二叉搜索树

最新推荐文章于 2024-07-21 11:20:00 发布
最新推荐文章于 2024-07-21 11:20:00 发布
阅读量651 收藏 29
点赞数 28
分类专栏： # 数据结构 文章标签： c++ 算法 二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_74276498/article/details/136122672
版权

二叉搜索树

1. 二叉树的概念

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

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

2. 二叉树的实现

2.1创建节点类

template <class T>
struct BSTreeNode
{
	typedef BSTreeNode Node;
	Node* _left;
	Node* _right;
	T _key;

	BSTreeNode(const T& val)
		:_left(nullptr)
		,_right(nullptr)
		,_key(val)
	{}
};

2.2 查找Find

  • 查找就很简单了，因为搜索二叉树的结构特殊，任何一个节点的左节点都小于父节点，任何一个节点的右节点都大于父节点。所以搜索一个值只需要判断大于这个节点还是小于这个节点。如果小于则往左节点走，如果大于则往右节点走。
bool Find(const T& val)
{
	Node* cur = _root;
	while (cur)
	{
		if (val > cur->_key) 
			cur = cur->_right;
		else if (val < cur->_key) 
			cur = cur->_left;
		else return true;
	}
	return false;
}

2.3 插入Insert

  • 插入也是同样的道理，大于某个节点就往右走，小于某个节点就往左走。直到为空，这个节点就是我们要插入的点。但是因为树是单向的，所以同样要有个parent指针用来记录上一个节点，便于链接节点。

注意细节：

  1. 当插入的节点是第一个节点的时候。
  2. 链接的时候是连接左节点还是右节点。
bool Insert(const T& val)
{
	//记录链接的节点。
	Node* parent = nullptr;
	Node* cur = _root;
	//当插入的节点是第一个节点时
	if (_root == nullptr)
	{
		_root = new Node(val);
		return true;
	}
	while (cur)
	{
		if (val > cur->_key)
		{
			parent = cur;
			cur = cur->_right;
		}
		else if (val < cur->_key)
		{
			parent = cur;
			cur = cur->_left;
		}
		else
		{
			return false;
		}
	}
	cur = new Node(val);
	//判断是链接右节点还是左节点。
	if (parent->_key < val)
		parent->_right = cur;
	else
		parent->_left = cur;
	return true;
}

2.4 删除Erase

删除分三种情况：

  1. 要删除的节点的左节点为空。
  2. 要删除的节点的右节点为空。
  3. 要删除的左右节点都不为空。

在这里插入图片描述
在这里插入图片描述

bool Erase(const T& val)
{
	Node* cur = _root;
	Node* parent = nullptr;
	while (cur)
	{
		if (val > cur->_key)
		{
			parent = cur;
			cur = cur->_right;
		}
		else if (val < cur->_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;
				}
			}
			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;
				}
			}
			else
			{
				//替换法
				//这里要注意力RightMin不能定义成nullptr，因为如果删除的是头节点就会出现野指针的问题，所以这里要定义成cur
				Node* RightMin = cur;
				//定义右子树，找到右子树最左节点
				Node* RightCur = cur->_right;

				while (RightCur->_left)
				{
					RightMin = RightCur;
					RightMin = RightMin->_left;
				}
				
				//交换值
				swap(RightCur->_key, cur->_key);
				if (RightMin->_left == RightCur)
				{
					RightMin -> _left = RightCur->_right;
				}
				else
				{
					RightMin->_right = RightCur->_right;
				}
				delete RightCur;
			}
			return true;
		}
	}
	return false;
}

2.5 中序遍历

这里我们会发现中序遍历搜索二叉树得到是一个有序的数列。

//这里说明一下，因为中序是要使用到递归的，也就是要传_root成员变量的。
//但是我们又不能修改_root所以要额外写一个函数来是由递归。
void Inorder()
{
	_Inorder(_root);
	cout << endl;
}
private:
void _Inorder(Node* root)
{
	if (root == nullptr)
		return;

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

2.6 构造/析构

BSTree(Node* root = nullptr)
	:_root(root)
{}

BSTree(const BSTree<T>& b)
{
	_root = Copy(b._root);
}

BSTree<T>& operator=(BSTree<T> b)
{
	swap(_root, b._root);
	return *this;
}

~BSTree()
{
	Destroy(_root);
}

private:
//前序常见节点
Node* Copy(Node* root)
{
	if (root == nullptr)
		return nullptr;

	Node* newNode = new Node(root->_key);
	newNode->_left = Copy(root->_left);
	newNode->_right = Copy(root->_right);
	return newNode;
}

//后序delete节点
void Destroy(Node* root)
{
	if (root == nullptr)
		return;

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

3. 递归实现

递归版本的整体思路是一样的。

3.1 查找FindR

bool FindR(const T& val)
{
	return _FindR(val, _root);
}
bool _FindR(const T& val, Node* root)
{
	if (root == nullptr)
		return false;

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

3.2 插入InsertR

在这里插入图片描述

bool InsertR(const T& val)
{
	return _InsertR(val, _root);
}

bool _InsertR(const T& val, Node*& root)
{
	if (root == nullptr)
	{
		root = new Node(val);
		return true;
	}

	if (val > root->_key)
		return _InsertR(val, root->_right);
	else if (val < root->_key)
		return _InsertR(val, root->_left);
	else
		return false;
}

3.3 删除EraseR

删除也是一样的参数传递Node*& root
但是当删除的节点左右都不为空的时候就可以不用替换法了，只需要将将最左节点和删除的点swap一下，在递归删除节点指向的_right也就是右子树再次递归一下即可。

bool EraseR(const T& val)
{
	return _EraseR(val, _root);
}

bool _EraseR(const T& val, Node*& root)
{
	if (root == nullptr)
		return false;

	if (val > root->_key)
		return _EraseR(val, root->_right);
	else if (val < root->_key)
		return _EraseR(val, root->_left);
	else
	{
		Node* del = root;
		if (root->_left == nullptr)
		{
			root = root->_right;
		}
		else if (root->_right == nullptr)
		{
			root = root->_left;
		}
		else
		{
			Node* cur = root->_right;
			while (cur->_left)
			{
				cur = cur->_left;
			}
			//交换cur节点和最左节点
			swap(root->_key, cur->_key);
			
			递归右子树
			return _EraseR(val, root->_right);
		}
		delete del;
		return true;
	}
}

4.整体代码

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

template <class T>
struct BSTreeNode
{
	typedef BSTreeNode Node;
	Node* _left;
	Node* _right;
	T _key;

	BSTreeNode(const T& val)
		:_left(nullptr)
		,_right(nullptr)
		,_key(val)
	{}
};

template <class T>
class BSTree
{
	typedef BSTreeNode<T> Node;
public:

	BSTree(Node* root = nullptr)
		:_root(root)
	{}

	BSTree(const BSTree<T>& b)
	{
		_root = Copy(b._root);
	}

	BSTree<T>& operator=(BSTree<T> b)
	{
		swap(_root, b._root);
		return *this;
	}

	~BSTree()
	{
		Destroy(_root);
	}

	bool Find(const T& val)
	{
		Node* cur = _root;
		while (cur)
		{
			if (val > cur->_key) 
				cur = cur->_right;
			else if (val < cur->_key) 
				cur = cur->_left;
			else return true;
		}
		return false;
	}

	bool Insert(const T& val)
	{
		Node* parent = nullptr;
		Node* cur = _root;
		if (_root == nullptr)
		{
			_root = new Node(val);
			return true;
		}
		while (cur)
		{
			if (val > cur->_key)
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (val < cur->_key)
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				return false;
			}
		}
		cur = new Node(val);
		if (parent->_key < val)
			parent->_right = cur;
		else
			parent->_left = cur;
		return true;
	}

	bool Erase(const T& val)
	{
		Node* cur = _root;
		Node* parent = nullptr;
		while (cur)
		{
			if (val > cur->_key)
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (val < cur->_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;
					}
				}
				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;
					}
				}
				else
				{
					//替换法
					Node* RightMin = cur;
					Node* RightCur = cur->_right;

					while (RightCur->_left)
					{
						RightMin = RightCur;
						RightMin = RightMin->_left;
					}

					swap(RightCur->_key, cur->_key);
					if (RightMin->_left == RightCur)
					{
						RightMin -> _left = RightCur->_right;
					}
					else
					{
						RightMin->_right = RightCur->_right;
					}
					delete RightCur;
				}
				return true;
			}
		}
		return false;
	}

	void Inorder()
	{
		_Inorder(_root);
		cout << endl;
	}


///递归版本/


	bool FindR(const T& val)
	{
		return _FindR(val, _root);
	}

	bool InsertR(const T& val)
	{
		return _InsertR(val, _root);
	}

	bool EraseR(const T& val)
	{
		return _EraseR(val, _root);
	}

private:
	bool _EraseR(const T& val, Node*& root)
	{
		if (root == nullptr)
			return false;

		if (val > root->_key)
			return _EraseR(val, root->_right);
		else if (val < root->_key)
			return _EraseR(val, root->_left);
		else
		{
			Node* del = root;
			if (root->_left == nullptr)
			{
				root = root->_right;
			}
			else if (root->_right == nullptr)
			{
				root = root->_left;
			}
			else
			{
				Node* cur = root->_right;
				while (cur->_left)
				{
					cur = cur->_left;
				}

				swap(root->_key, cur->_key);
				
				return _EraseR(val, root->_right);
			}
			delete del;
			return true;
		}
	}

	bool _InsertR(const T& val, Node*& root)
	{
		if (root == nullptr)
		{
			root = new Node(val);
			return true;
		}

		if (val > root->_key)
			return _InsertR(val, root->_right);
		else if (val < root->_key)
			return _InsertR(val, root->_left);
		else
			return false;
	}

	bool _FindR(const T& val, Node* root)
	{
		if (root == nullptr)
			return false;

		if (val > root->_key)
			return _FindR(val, root->_right);
		else if (val < root->_key)
			return _FindR(val, root->_left);
		else
			return true;
	}
private:

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

		Node* newNode = new Node(root->_key);
		newNode->_left = Copy(root->_left);
		newNode->_right = Copy(root->_right);
		return newNode;
	}

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

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

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

		_Inorder(root->_left);
		cout << root->_key << " ";
		_Inorder(root->_right);
	}
private:
	Node* _root = nullptr;
};
初阳hacker
关注
  • 28
    点赞
  • 踩
  • 29
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 35
    评论
专栏目录
二叉树-基于C++实现的二叉搜索树.zip
04-26
二叉搜索树（Binary Search Tree，BST）是二叉树的一个特例，它具有以下特性：对于任意节点，其左子树中的所有节点的值都小于该节点的值，而右子树中的所有节点的值都大于该节点的值。这种特性使得二叉搜索树非常...
C语言判定一棵二叉树是否为二叉搜索树的方法分析
12-31
本文实例讲述了C语言判定一棵二叉树是否为二叉搜索树的方法。分享给大家供大家参考，具体如下： 问题 给定一棵二叉树，判定该二叉树是否是二叉搜索树（Binary Search Tree）？ 解法1:暴力搜索 首先说明一下二叉树和...
C++进阶——二叉搜索树BST
weixin_43635473的博客
04-21 684
C++进阶——二叉搜索树BST
【C++】二叉树进阶（二叉搜索树）
是阿建吖！
05-26 1651
这篇文章详细介绍了二叉搜索树（BST）的基本概念、操作、代码实现以及应用。首先，介绍了BST的定义和核心操作，包括查找、插入和删除，并提供了非递归和递归两种实现方式。随后，通过具体的代码示例，展示了BST的节点设置、类框架构建以及查找、插入、中序遍历和删除函数的完整实现。此外，还探讨了BST在实际问题中的应用和性能分析。进阶部分则包含了一系列与二叉树相关的OJ题目，涵盖了从根据遍历序列构造二叉树，到层序遍历、公共祖先查找、BST与双向链表转换等多种场景，希望能够帮助读者深入理解二叉树的结构和应用。
二叉树的进阶——C++ 二叉搜索树
a1299960335的博客
05-17 361
二叉搜索树一、二叉搜索树1.二叉搜索树的概念2.二叉搜索树的使用场景二、二叉搜索树的分类1.Key树模拟实现key树2.KV树模拟实现KV树 一、二叉搜索树 1.二叉搜索树的概念 二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树： 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值 若它的右子树不为空，则右子树所有的节点都大于根节点的值 它的左右子树也是二叉搜索树 2.二叉搜索树的使用场景 因为二叉搜索树的性质，它的中序是有序的。所以可以用来进行排序（用的不多） 既然叫做
C++初阶学习————二叉树进阶（二叉搜索树）
hxMGE的博客
11-29 414
入门学习
【C++进阶学习】第五弹——二叉搜索树——二叉树进阶及set和map的铺垫
2301_80220607的博客
07-02 3046
数据结构二叉树进阶——二叉搜索树，为之后C++中的map和set打基础，不难，关键在于思路的梳理！！！
C++进阶——二叉搜索树
weixin_51885188的博客
03-03 996
二叉搜索树 这篇文章主要为大家介绍二叉树搜索树的概念、操作、实现以及它的应用。同时学习二叉搜索树也是在为我们后面学习map与set做铺垫，当我们了解了二叉搜索树的特性后，后面将有助于我们更好的理解map和set的特性 二叉搜索树的概念（特征） 二叉搜索树也称二叉排序树，它或是一棵空树，或者是具有以下性质的二叉树： 若它的左子树不为空，则左子树上所有的节点值都小于根节点的值 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值 它的左右子树也分别为二叉搜索树 int arr[] = {5,3,
【C++进阶：二叉树进阶】二叉搜索树的操作和key模型、key/value模型的实现 | 二叉搜索树的应用 | 二叉搜索树的性能分析
wh128341的博客
08-27 1508
从这里开始 C++ 的语法就告一段落了。二叉树在前面的数据结构和算法初阶中就讲过，本文取名为二叉树进阶是因为：我们之前说过，普通二叉树单纯的存储数据价值不大，因为仅仅是单纯的存储数据，你不如去使用顺序表和链表这样友善的多。它一定要套一种应用场景，二叉树的其中一个重要的应用场景就是我们本文中要学习的二叉搜索树。二叉搜索树又称搜索二叉树或二叉排序树 (如果你对下图的二叉搜索树中序遍历，你会发现它是有序并且升序的)，我们当前学习的搜索二叉树一般是不允许修改的，不过下面我们会学习搜索二叉树的 key_value 模
二叉树进阶——手撕二叉搜索树
m0_73802195的博客
04-06 793
若它的左子树不为空，则左子树上的所有节点的值都小于根节点的值若它的右子树不为空，则右子树上的所有节点的值都大于根节点的值总的来说二叉搜索树，比较难的地方就是删除部分，多画图多思考。下篇我们就要深入二叉搜索树。
C++进阶 —— 二叉树搜索树
NapoleonCoder的博客
12-07 562
二叉搜索树，K、KV模型！
C++ 二叉搜索树(BST)的实现方法
08-30
C++ 二叉搜索树(BST)是一种特殊的二叉树，它具有以下特征： 1. 二叉搜索树的每个节点都包含一个键值（key）和一个值（value）。 2. 对于任意一个节点，左子树中的键值都小于该节点的键值，而右子树中的键值都大于该...
二叉树的二叉搜索表示.rar_二叉搜索树_二叉树的二叉搜索
09-22
二叉搜索树（Binary Search Tree，BST）是一种特殊类型的二叉树，它的每个节点都具有以下特性： 1. **左子树性质**：左子树上所有节点的值都小于当前节点的值。 2. **右子树性质**：右子树上所有节点的值都大于当前...
(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度
qq_44962949的博客
07-17 238
【代码】(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度。
C++ 继承篇
2301_79201049的博客
07-18 661
必须对继承而来的成员进行初始化直接通过初始化列表或者赋值的方式进行初始化调用父类构造函数进行初始化
学懂C语言系列（三）：C语言基本语法
martian665的专栏
07-17 570
学懂C语言系列,C语言基本语法
C++笔记3：基类指针delete子类对象的内存泄漏问题
最新发布
subtitle_的博客
07-21 139
C++笔记3：基类指针delete子类对象的内存泄漏问题
【ProtoBuf】ProtoBuf 快速上手
Elena's Blog
07-17 500
在。
算法学习9——二叉搜索树
05-19
二叉搜索树，也叫二叉查找树（BST，Binary Search Tree），是一种特殊的二叉树。相对于普通的二叉树，它有一个特点：所有左子树的节点都比根节点小，所有右子树的节点都比根节点大。因此，它可以快速地进行查找、...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

初阳hacker

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

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

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

打赏作者

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

抵扣说明：

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

余额充值