C++（进阶) 第3章 二叉搜索树

最新推荐文章于 2025-06-07 23:46:19 发布
原创 最新推荐文章于 2025-06-07 23:46:19 发布
· 1k 阅读 · 15 ·
版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c++ #开发语言

C++（进阶) 第3章 二叉搜索树

文章目录

前言

之前在数据结构篇简单的介绍了二叉搜索树，本篇博客会详细的介绍

一、什么是二叉搜索树？

⼆叉搜索树的概念

⼆叉搜索树⼜称⼆叉排序树，它或者是⼀棵空树，或者是具有以下性质的⼆叉树:
• 若它的左⼦树不为空，则左⼦树上所有结点的值都⼩于等于根结点的值
• 若它的右⼦树不为空，则右⼦树上所有结点的值都⼤于等于根结点的值
• 它的左右⼦树也分别为⼆叉搜索树

在这里插入图片描述

下面就是一颗比较经典的二叉搜索树
在这里插入图片描述

搜索二叉树也叫排序二叉树，因为它走中序遍历的时候刚好就是有序的

二、搜索二叉树的实现

0.搜索二叉树的时间复杂度

搜索二叉树的做好情况下时间复杂度就是log N，但是会出现极端情况
在这里插入图片描述
所以时间复杂度就是N
但是后面会有AVL树，红黑树，可以优化差不多 log N

1.基本框架

#include<bits/stdc++.h>
using namespace std;
template<class K>

struct BSTreeNode
{
	K _key;
	BSTreeNode<K>* _left;
	BSTreeNode<K>* _right;
	BSTreeNode(const K& key)
		:_key(key)
		,_left(nullptr)
		,_right(nullptr)
	{

	}
};
template<class K>
class BSTree
{
	typedef BSTreeNode<K> Node;
public:
private:
	Node* _root = nullptr;
};

2.Find

普通的二叉树其实没有什么意义，如果只是普通的二叉树它存东西的效率其实还不如链表，所以在原来的二叉树基础上添加了一些规则，左孩子比根小，右孩子比根大

假如就用下面的例子，现在我要在这颗树里面搜索看看有没有16这个数字

在这里插入图片描述
如果我们查找的值比根大那么就可以直接往右走，比根小只需要往左走就可以了那么最多只需要找这棵树的高度次就可以了

如果找到null了那么就说明找不到

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

3.Insert

注意：这里有一个规定，树里面的数据是不允许重复的,也，假如树里面已经有了10，那么这里就不允许再次插入，所以这里insert返回值用bool

bool Insert(const K& key)
{
	if (_root == nullptr)
	{
		_root = new Node(key);
		return true;
	}
	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
		{
			return false;
		}
	}

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

	}
	return true;


}

4.InOder

这里我用的是子函数的形式因为如果不这样的话，外面调用就要传入参数（_root）但是这里我_root是保护调用不了，

	void InOder()
	{
		_InOder(_root);
	}
private:
	void _InOder(Node* root)
	{
		if (root == nullptr)
		{
			return;
		}

		_InOder(root->_left);
		cout << root->_key << ' ';
		_InOder(root->_right);

	}

写完中序遍历就可以看下程序有没有写错了
在这里插入图片描述
这里可以看到输出的是有序的，就说明这里是没有写错的

到这里的完整代码就长这样

#pragma once

#include<bits/stdc++.h>
using namespace std;
template<class K>

struct BSTreeNode
{
	K _key;
	BSTreeNode<K>* _left;
	BSTreeNode<K>* _right;
	BSTreeNode(const K& key)
		:_key(key)
		,_left(nullptr)
		,_right(nullptr)
	{

	}
};

template<class K>
class BSTree
{
	typedef BSTreeNode<K> Node;
public:
	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* 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
			{
				return false;
			}
		}

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

		}
		return true;


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

		InOder(root->_left);
		cout << root->_key << ' ';
		InOder(root->_right);



	}
	void InOder()
	{
		_InOder(_root);
	}
private:
	void _InOder(Node* root)
	{
		if (root == nullptr)
		{
			return;
		}

		_InOder(root->_left);
		cout << root->_key << ' ';
		_InOder(root->_right);

	}
private:
	Node* _root = nullptr;
};

#define _CRT_SECURE_NO_WARNINGS 
#include"bstree.h"

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

    return 0;
}

5.Erase

这里删除的话就比较复杂了，需要先找到要删的那个节点，然后删除，但是删除的那个节点可能会还有孩子并且删除了以后搜索二叉树不能乱，大致可以分成以下三种情况

  1. 没有孩子
  2. 只要一个孩子
  3. 有俩个孩子

在这里插入图片描述
假如这里我要删除3，那么我需要找到一个人替代3的位置，这个时候左子树最右边的节点，或者右子树最左边的节点都可以，所以上面的1，2种情况可以归类成一种情况，因为最左边或者最左边的一定是只有一个孩子或者没有孩子的情况

假如上面我要删掉3，那么我去找右子树的最左边的值也就是4，那么3替换成4，然后下面的4就可以直接删掉了

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
		{
			if (cur->_left == nullptr)
			{
				if (parent == nullptr)
				{
					_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 (parent == nullptr)
				{
					_root = cur->_left;
				}
				else
				{
					if (parent->_left == cur)
					{
						parent->_left = cur->_left;
					}
					else
					{
						parent->_right = cur->_left;
					}
				}
				
				delete cur;
				return true;
			}
			else
			{
				Node* RightMin = cur->_right;
				Node* RightMinP = cur;
				while (RightMin ->_left)
				{
					RightMinP = RightMin;
					RightMin = RightMin->_left;
				}

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

在这里插入图片描述

三 、完整代码

#pragma once
#include<bits/stdc++.h>
using namespace std;

template<class K>
struct BSTreeNode
{
	K _key;
	BSTreeNode<K>* _left;
	BSTreeNode<K>* _right;
	BSTreeNode(const K& key)
		:_key(key)
		,_left(nullptr)
		,_right(nullptr)
	{

	}

};



template<class K> 
class BSTree
{
	typedef BSTreeNode<K> Node;

public:
	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* 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
			{
				return false;
			}
		}
		cur = new Node(key);
		if (parent->_key < cur->_key)
		{
			parent->_right = cur;
		}
		else
		{
			parent->_left = cur;
		}
		return true;

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

	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
			{
				if (cur->_left == nullptr)
				{
					if (parent == nullptr)
					{
						_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 (parent == nullptr)
					{
						_root = cur->_left;
					}
					else
					{
						if (parent->_left == cur)
						{
							parent->_left = cur->_left;
						}
						else
						{
							parent->_right = cur->_left;
						}
					}
					
					delete cur;
					return true;
				}
				else
				{
					Node* RightMin = cur->_right;
					Node* RightMinP = cur;
					while (RightMin ->_left)
					{
						RightMinP = RightMin;
						RightMin = RightMin->_left;
					}

					cur->_key = RightMin->_key;
					if (RightMinP->_left == RightMin )
					{
						RightMinP->_left = RightMin->_right;
					}
					else
					{
						RightMinP->_right = RightMin->_right;
					}
					
					delete RightMin;
					return true;
				}
			}
		}
		return false;
	}
private:
	void _InOrder(Node* root)
	{
		if (root == nullptr)
		{
			return;
		}

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

private:
	
	Node* _root = nullptr;
};

#define _CRT_SECURE_NO_WARNINGS 
#include"BStree.h"
using namespace std;
int main()
{
    int arr[] = { 8,3,1,10,6,4,7,14,13 };
    BSTree<int> t;
    for (auto e : arr)
    {
        t.Insert(e);
    }
    t.Insert(16);
    t.Insert(4);
    t.InOrder();

    for (auto e : arr)
    {
        t.Erase(e);
        t.InOrder();
    }
    return 0;
}

总结

删除有点复杂还是要花时间去理解

C++进阶（五）二叉搜索树
2301_78995005的博客
01-18 953
分享二叉搜索树知识。
【进阶数据结构】二叉搜索树&经典习题讲解
East-sunrise的博客
03-20 1181
二叉搜索树 —— 轻易找到你想要的
C++进阶(三) 二叉搜索树
qq_62800805的博客
03-03 930
BSTreeNode// 二叉搜索树节点结构体/*template<class K> 表示定义了一个模板类 BSTree，并且该类可以使用一个类型参数 K，这样在实际使用时可以将任意类型作为 K 的具体类型*/// 定义一个别名 Node，指向 BSTreeNode 类型的节点// 左子节点指针// 右子节点指针K _key;// 节点键值// 构造函数，初始化节点的键值，并将左右子节点指针初始化为空指针{}
C++进阶--＞二叉搜索树
2301_80475151的博客
10-28 733
二叉搜索树的概念、性能、实现、还有key/value二叉搜索树的实现
C++进阶--二叉搜索树
2402_87779153的博客
04-22 768
二叉搜索树定义，重要接口，次要接口
【C++进阶03】二叉搜索树
2302_76421042的博客
12-28 1581
中序遍历二叉搜索树会得到一个有序序列所以二叉搜索树又称二叉排序树它可以是一棵空树二叉搜索树没有相同值的节点二叉搜索树支持增删查，不支持改修改会破坏二叉搜索树跟节点比左子树大右子树小的结构。
C++进阶——二叉搜索树
博客 | 复习知识点 + 练习 + 最终的领悟 | 全力以赴
03-09 692
在我写BinarySearchTree的拷贝构造时，发现为什么，_root明明是私有的。这种设计是为了支持类的封装性和实现细节的隐藏，同时。例如：拷贝构造函数需要访问被拷贝对象的内部状态。赋值运算符需要访问右操作数的内部状态。比较运算符可能需要访问两个对象的内部状态。
[ 数据结构进阶 - C++ ] 二叉搜索树
优快云博客
09-21 934
二叉搜索树 K模型 KV模型
C++进阶知识3 二叉搜索树
Yusei_0523的博客
09-29 808
1. ⼆叉搜索树的概念 2. ⼆叉搜索树的性能分析 3. ⼆叉搜索树的插⼊ 4. ⼆叉搜索树的查找 5. ⼆叉搜索树key和key/value使⽤场景 5.1 key搜索场景： 5.2 key/value搜索场景：
C++进阶——二叉搜索树BST
weixin_43635473的博客
04-21 855
C++进阶——二叉搜索树BST
【C++进阶】详解二叉搜索树
weixin_64906519的博客
03-13 850
当二叉搜索树退化为单支树时，其查找的优势就会失去，那么解决办法就是我们后面会讲的AVL树和红黑树了，所以我们要先掌握二叉搜索树，因为这些都是在此之上的知识。希望大家都能掌握并且可以持续关注，我会带来更多的C++知识。
C++进阶(3): 二叉搜索树
ffyhyh的博客
10-01 662
C++进阶：二叉搜索树
C++进阶 二叉搜索树的讲解
Mike的博客
09-15 1432
讲解二叉树的内容。
c++重点知识总结
Uk110的博客
06-06 882
1.基类private成员在派生类中无论以什么方式继承都是不可见的。这里的。
极限复习c++
2302_76213070的博客
06-05 2230
快速过一遍必背代码（类、多态、模板）和简答题答案，强化肌肉记忆！祝考试顺利，代码全 AC！
C/C++ 面试复习笔记（4）
apolloyhl的博客
06-06 926
内存颠簸是指系统在频繁地进行内存页的换入换出操作，导致大量的磁盘 I/O，系统性能急剧下降的现象。当系统的物理内存不足，而进程对内存的需求又不断变化时，就容易出现内存颠簸。例如，一个进程频繁地访问不同的内存页，而这些页在内存中频繁地被换出和换入。在 Linux 系统中，可以通过以下方法避免或解决内存颠簸问题：增加物理内存：如果物理内存不足是导致内存颠簸的主要原因，增加内存条可以直接提 高系统的可用内存，减少页交换操作。
加法c++
D_31415926的博客
06-06 387
给定 a 和 b 分别作为被加数和加数，而且限定 a 是 4 位数字，b 是 3 位数字，都是正整数。请你模拟以上加法过程进行输出。如果最后 a+b 的结果是 5 位数，为了保证对齐，需要在被加数和加数前面加空格。只需判断a+b的位数（注：四位数+三位数只可能是四位数或五位数，因为1000+100=1100，9999+999=10998），当a+b为四位数或五位数时输出特定的格式即可。输入两个正整数 a 和 b。
【题解】[UTPC2024] C.Card Deck
最新发布
scy923的博客
06-07 579
由于放入袋中后会进行补位，也就是说我们并不关心补进来的是哪一张真正的原始牌，当进行第。轮之后所有可能的袋子里牌所组成的集合的大小之和。考虑进行转化，只考虑前。，表示这张牌永远不会被放入袋子中，否则表示这张牌会在第。因此可以对每一张牌单独计算贡献。原题的模型是每一步可以选择顶部。，则这张牌出现在集合里的次数为。的牌都已经放入袋中，总共有。张牌，每张牌都有一个属性。张牌等价，所以最后的答案为。(可以为空）放在袋中，求。轮后袋子里的数，最后求。，下证明两个模型等价。
如何在c/c++中定义和使用宏
wydaicls的博客
06-07 387
本文介绍了C/C++中的宏定义和条件编译机制。宏定义分为对象式宏（如#define PI 3.1415926）和函数式宏（如#define MAX(a,b)），在预处理阶段进行文本替换，使用时需注意括号和多行定义的处理。条件编译通过#ifdef、#ifndef、#if等指令实现，其中#ifdef检查宏是否定义，#if使用表达式判断，并可用#elif和#else进行多分支控制。#undef可取消宏定义，#pragma once能防止头文件重复包含。这些预处理指令为代码提供了编译时的灵活控制能力。
在C++项目实战中，如何高效实现一个基于二叉搜索树的数据结构以支持查找和插入？请提供示例代码。
10-27
参考资源链接：[算法竞赛入门经典授课教案第6章数据结构基础.doc](https://wenku.youkuaiyun.com/doc/3xs4vmg2d4?utm_source=wenku_answer2doc_content) 在C++中实现一个基于二叉搜索树的数据结构，需要掌握二叉树的性质及其遍历方式。二叉搜索树（BST）是一种特殊的二叉树，它能够提供对数时间复杂度内的查找和插入操作。二叉搜索树的每个节点都包含一个键值对，其中左子树的所有节点的键值都小于该节点的键值，右子树的所有节点的键值都大于该节点的键值。 以下是C++代码示例，展示了如何实现一个基本的二叉搜索树及其查找和插入功能： ```cpp struct TreeNode { int val; TreeNode *left; TreeNode *right; TreeNode(int x) : val(x), left(nullptr), right(nullptr) {} }; class BST { private: TreeNode* root; TreeNode* insert(TreeNode* node, int value) { if (node == nullptr) { return new TreeNode(value); } if (value < node->val) { node->left = insert(node->left, value); } else if (value > node->val) { node->right = insert(node->right, value); } return node; } TreeNode* search(TreeNode* node, int value) { if (node == nullptr || node->val == value) { return node; } if (value < node->val) { return search(node->left, value); } else { return search(node->right, value); } } public: BST() : root(nullptr) {} void insert(int value) { root = insert(root, value); } TreeNode* search(int value) { return search(root, value); } }; ``` 在这个示例中，我们首先定义了二叉搜索树的节点结构TreeNode，然后在BST类中实现了插入和查找的方法。插入方法通过递归遍历树来定位插入位置，并创建新节点。查找方法同样通过递归来查找给定的值。 为了更深入地理解这些概念以及如何在实际项目中应用它们，可以参考《算法竞赛入门经典授课教案第6章数据结构基础.doc》。这份教案不仅涵盖了基本的数据结构和算法概念，还提供了丰富的示例和问题，适合那些希望在数据结构和算法领域进阶的学生和开发者。通过学习这份资料，你将能够更好地掌握二叉搜索树的实现细节，并将其应用到更复杂的项目中。 参考资源链接：[算法竞赛入门经典授课教案第6章数据结构基础.doc](https://wenku.youkuaiyun.com/doc/3xs4vmg2d4?utm_source=wenku_answer2doc_content)
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值