C++实现二叉搜索树

最新推荐文章于 2025-05-14 19:24:02 发布
原创 最新推荐文章于 2025-05-14 19:24:02 发布 · 97 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#数据结构 #c++

二插搜索树的插入

（1）树是空树，直接插入接口

（2）如果不是空树

需要找到插入位置，如果插入的值比当前节点的值要大，就去右子树找插入位置。如果插入的值比当前位置小，就去左子树找插入位置。如果和当前节点的值相等，就返回false，因为二叉搜索树不能存在两个相同的值。

普通写法：

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

		Node* parent = nullptr;
		Node* cur = _root;
		while (cur)
		{
			parent = cur;
			if (cur->_key < key)
			{
				cur = cur->_right;
			}
			else if (cur->_key > key)
			{
				cur = cur->_left;
			}
			else
			{
				return false;
			}
		}

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

递归写法：

由于根节点是私有成员，在外部不能访问，因此需要一个成员函数去调用，这也是C++常用的处理方法。

这里使用的是节点的引用，就可以在递归途中直接修改节点

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

二叉搜索树的查找

如果要查找的值比当前节点的值要大，就去右子树查找，如果比当前节点的值要小，就去左子树查找，如果等于当前节点的值，就返回true，用这个方法向下找，如果没有找到就返回false

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 FindR(const K& key)
	{
		return _FindR(_root, key);
	}
bool _FindR(Node* root,const K& key)
	{
		if (root == nullptr)
		{
			return false;
		}

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

二叉搜索树的删除

二叉搜索树的删除需要分类讨论

首先是要阐述的节点是否有双亲，其次是要删除的节点是双亲的左孩子还是右孩子，并且要删除的节点有没有孩子，是只有左孩子还是只有右孩子，或者是有两个孩子

（1）要删除的节点有双亲

（a）要删除的节点是双亲的左孩子

【1】要删除的节点没有孩子：直接删除这个节点就可以

【2】 要删除的节点只有左孩子：此时需要让这个节点的父节点指向这个节点的左孩子，再删除这个节点

 【3】要删除的节点只有右孩子：此时需要让这个节点的父节点指向这个节点的右孩子，再删除这个节点

【4】要删除的节点有两个孩子

这里需要找一个替代节点，可以使删除节点左子树的最大节点（左子树的最右侧的节点），或者要删除及诶单左子树的最小节点（左子树的最左侧节点） ，把这个节点的值赋值给要删除的节点，再删除掉这个替代节点即可。

（b） 要删除的节点是双亲的左孩子

与左孩子同理

（2）要删除的节点没有双亲

（a）要删除节点没有孩子：直接删除即可

（b）要删除的节点只有左孩子：让左孩子直接当根节点，删除这个节点即可

（c）要删除的节点只有右孩子：让这个节点当根节点即可

（d）要删除的节点有两个孩子

找到右子树的最小节点，替换之后删除即可

	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
			{
				if (cur->_left == nullptr)
				{
					if (cur == _root)
					{
						_root = cur->_right;
					}
					else
					{
						if (cur == parent->_left)
						{
							parent->_left = cur->_right;
						}
						else
						{
							parent->_right = cur->_right;
						}
					}
				}
				else if (cur->_right == nullptr)
				{
					if (cur == _root)
					{
						_root = cur->_right;
					}
					else
					{
						if (cur == parent->_left)
						{
							parent->_left = cur->_left;
						}
						else
						{
							parent->_right = cur->_left;
						}
					}
				}
				else
				{
					Node* parent = cur;
					Node* subLeft = cur;
					while (subLeft->_left)
					{
						parent = subLeft;
						subLeft = subLeft->_left;
					}
					swap(subLeft->_key, cur->_key);

					if (subLeft == parent->_left)
					{
						parent->_left = subLeft->_right;
					}
					else
					{
						parent->_left = subLeft->_right;
					}
				}
				return  true;
			}
		}
		return false;
	}

递归写法：

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

整体实现

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

template<class K>
struct BSTreeNode
{
	BSTreeNode<K>* _left;
	BSTreeNode<K>* _right;
	K _key;

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

template<class K>
class BSTree
{
	typedef BSTreeNode<K> Node;
public:
	bool Insert(const K& key)
	{
		if (_root == nullptr)
		{
			_root = new Node(key);
			return true;
		}

		Node* parent = nullptr;
		Node* cur = _root;
		while (cur)
		{
			parent = cur;
			if (cur->_key < key)
			{
				cur = cur->_right;
			}
			else if (cur->_key > key)
			{
				cur = cur->_left;
			}
			else
			{
				return false;
			}
		}

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

	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 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
			{
				if (cur->_left == nullptr)
				{
					if (cur == _root)
					{
						_root = cur->_right;
					}
					else
					{
						if (cur == parent->_left)
						{
							parent->_left = cur->_right;
						}
						else
						{
							parent->_right = cur->_right;
						}
					}
				}
				else if (cur->_right == nullptr)
				{
					if (cur == _root)
					{
						_root = cur->_right;
					}
					else
					{
						if (cur == parent->_left)
						{
							parent->_left = cur->_left;
						}
						else
						{
							parent->_right = cur->_left;
						}
					}
				}
				else
				{
					Node* parent = cur;
					Node* subLeft = cur;
					while (subLeft->_left)
					{
						parent = subLeft;
						subLeft = subLeft->_left;
					}
					swap(subLeft->_key, cur->_key);

					if (subLeft == parent->_left)
					{
						parent->_left = subLeft->_right;
					}
					else
					{
						parent->_left = subLeft->_right;
					}
				}
				return  true;
			}
		}
		return false;
	}

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

	bool FindR(const K& key)
	{
		return _FindR(_root, key);
	}

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

	bool EraseR(const K& key)
	{
		return _EnerseR(_root, key);
	}
private:
	void _InOrder(Node* root)
	{
		if (root == nullptr)
			return;
		_InOrder(root->_left);
		cout << root->_key << " ";
		_InOrder(root->_right);
	}

	bool _FindR(Node* root,const K& key)
	{
		if (root == nullptr)
		{
			return false;
		}

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

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

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

萍雨蝶
关注
【C++】二叉搜索树
春风不语。
10-01 1491
本篇到这里就结束了，主要讲了二叉搜索树的基本概念以及实现逻辑，希望对大家有所帮助，祝生活愉快，我们下篇再见！
二叉搜索树C++代码
07-30
本文主要讨论二叉搜索树的基本性质以及基本操作，并用C++代码实现，每个成员操作以成员函数的形式出现，并附有适当的说明。 包括： 普通二叉树的遍历（先序，中序，后序，分层），二叉搜索树的建立，插值，删值，求前驱，求后继，求size，求最大节点，最小节点
⼆叉搜索树 （ 代码实现 c++ ）
最新发布
shajjs的博客
05-14 792
⼆叉搜索树的性能分析一.⼆叉搜索树的概念⼆叉搜索树⼜称⼆叉排序树，它或者是⼀棵空树，或者是具有以下性质的⼆叉树:若它的左⼦树不为空，则左⼦树上所有结点的值都⼩于等于根结点的值若它的右⼦树不为空，则右⼦树上所有结点的值都⼤于等于根结点的值它的左右⼦树也分别为⼆叉搜索树。
二叉搜索树c/c++代码实现
xxxxxiao123的博客
06-30 331
包含了二叉搜索树的插入，删除，查找，中序遍历，找最大值最小值的操作，代码中有注释。 /*Keep on going Never give up*/ //#pragma GCC optimize(3,"Ofast","inline") #include <bits/stdc++.h> using namespace std; struct Node{ int data; Node *l,*r,*parent; }; //由大到小排序（中序遍历二叉树） void sortx(Nod
二叉搜索树 及 c++代码实现
zhaowenchaofang的专栏
06-16 1265
本文算法参考《算法导论》chp12 未解决问题：搜索时越界问题完美解决。（解决方案1.可以是在每个叶子结点都设置标志位，2.在每个结点后认为加一个节点，这样开销会更大些）    本文提供了一种解决方案，不过在main函数进行返回值判定，代码封装性并不是特别好 构造二叉树、插入、删除、搜索、  查找最大值、最小值、前驱、后继的各种实现 具体代码如下： #include #inclu
C++——二叉搜索树的实现
大学生一枚
07-13 530
二叉搜索树又叫做二叉排序树，他或者是一棵空树，或者具有以下性质：若他的左子树不为空，则左子树的所有节点的值都小于根节点的值，若他的右子树不为空，则右子树的所有节点的值都大于根节点的值，他的左右子树也分别为二叉搜索树；
C++实现二叉搜索树（BST），通过控制台能够实现增删改查
12-02
在C++中实现二叉搜索树，首先需要定义一个表示节点的数据结构，一般包括键值、指针到左右子节点以及可能需要的额外信息，例如存储的值或用于链接的指针。以下是一个简单的节点定义： ```cpp struct TreeNode { int...
详细解读：C++实现二叉搜索树 (Binary Search Tree, BST)
**My Coding Family**
03-15 1007
🏆本文收录于「编程与技术实战」专栏，此专栏涵盖了C/C++编程、人工智能、数据结构、机器学习等技术领域的内容，助你早日登顶实现财富自由🚀；同时，欢迎大家关注&&收藏&&订阅！持续更新中，up！up！up！！
C++实现二叉树功能的插入删除等等基本操作
07-01
自己上课做的，是基于黑窗口的，关于Mfc的正在做，所以请持续关注我吧
二叉搜索树的c++实现
07-05
使用二叉链表和c++来实现二叉搜索树，提供插入、删除、遍历、求最小节点、最大最节点等操作。
【C++数据结构】二叉搜索树（超详细图解操作过程，超详细讲解代码实现）
谁在夜里看海.的博客
07-17 4404
有一种查找方法，具有极高的查找效率，时间复杂度仅为 O(log⁡n)。在每一步查找过程中都会将搜索范围减半，这就是二分查找。 但是在实际应用中，我们并不经常使用二分查找。这是因为它只能在有序数组或有序数据结构上工作，如果数据是无序的，则需要先进行排序；而且它只适用于数组或连续存储的数据结构中。 在实际运用中，我们更常用的是二叉搜索树（Binary Search Tree, BST），其查找时间复杂度也是 O(log⁡n)，并且拥有高效的插入和删除操作。
【C++、数据结构】二叉排序树（二叉查找树、二叉搜索树）（图解+完整代码）
金哥的博客
10-22 2269
二叉搜索树/二叉排序树/二叉查找树：创建、插入、查找、删除（非递归以及递归版本代码），以及超详细步骤图解
二叉搜索树
四夕日 月
09-18 907
二叉搜索树： 二叉树的查找很简单，先序后序中序都可以，一开始要判断是否为空。 插入要判断一下是否存在，查找时同时记录其父节点，然后直到找到空节点，插入。 删除比较复杂一点： 逐一判断： 先判断是否为空，然后查找到要删除的节点p，并记录其父节点q，如果查不到，返回false； 当p节点有两个子树时，查到其中序遍历的后继节点，即排序后的之后以为，记为s。查找的同时记录s的父节点r，然后将s
【数据结构】二叉搜索树/搜索二叉树(C++实现)
Brant_zero的博客
11-05 2653
二叉搜索树的概念、二叉搜索树的实现，二叉搜索树的插入、二叉搜索树的删除、二叉搜索树的查找、二叉搜索树性能分析，二叉搜索树key模型、二叉搜索树key-value模型
二叉搜索树C++详细实现
士杰的博客
03-12 884
相信大部分人都会实现二叉搜索树，实际上就是根据与当前节点相比的大与小进行整个树的建立。这里部分代码引用的是王争老师的二叉搜索树代码，为了方便关于二叉搜索树其他内容的讲解，代码基本上具有注释，如果哪里写的不明白可以留言，因为我自己也修改了一下，不知道是否存在bug。 具体的功能有： 搜索元素 删除元素 插入元素 最大元素获取 最小元素获取 删除最大元素 删除最小元素 前、中、后、层序遍历 获取ce...
二叉搜索树（C++）
mmz123_的博客
01-27 2651
文章目录二叉搜索树概念与操作二叉搜索树的概念二叉搜索树的操作查找插入删除二叉搜索树的应用二叉树的性能分析 二叉搜索树概念与操作 二叉搜索树的概念 二叉搜索树又称二叉排序树，若它的左子树不为空，则左子树上所有节点的值都小于根节点的值；若它的右子树不为空，则右子树上所有节点的值都大于根节点的值，它的左右子树也分别未二叉搜索树。也可以是一颗空树。 int a[] = { 5, 3, 4, 1, 7, 8, 2, 6, 0, 9 }; 二叉搜索树的操作 查找 迭代： Node* Find(const K&am
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值