二叉搜索树的实现（迭代方式）

已于 2023-10-26 16:01:23 修改
阅读量179 收藏 1
点赞数
分类专栏： 数据结构与算法 C/C++ 文章标签： c++ 算法 开发语言 数据结构
于 2023-10-26 11:42:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_73567058/article/details/134052295
版权

二叉搜索树（Binary Search Tree，BST）是一种基于二叉树的数据结构，具有以下特点：

  1. 对于树中的每个节点，其左子树中的所有节点的值都小于该节点的值，而右子树中的所有节点的值都大于该节点的值。
  2. 左子树和右子树也都是二叉搜索树。

这个特性使得二叉搜索树能够高效地支持插入、删除和查找操作。

插入操作：
要在二叉搜索树中插入一个新节点，需要按照以下步骤进行：

  1. 如果树为空，则将新节点作为根节点。
  2. 如果树不为空，则从根节点开始比较新节点的值与当前节点的值。
  3. 如果新节点的值小于当前节点的值，继续在当前节点的左子树中插入新节点。
  4. 如果新节点的值大于当前节点的值，继续在当前节点的右子树中插入新节点。
  5. 重复步骤3和4，直到找到一个空位置插入新节点。

删除操作：
要在二叉搜索树中删除一个节点，需要按照以下步骤进行：

  1. 首先，找到要删除的节点。如果节点不存在，则删除操作失败。
  2. 如果要删除的节点没有子节点，直接删除即可。
  3. 如果要删除的节点只有一个子节点，将其子节点替代要删除的节点。
  4. 如果要删除的节点有两个子节点，需要找到其右子树中的最小节点（或左子树中的最大节点），将其值替换到要删除的节点上，然后删除这个最小（或最大）节点。

针对第4点，左子树的最右节点和右子树的最左节点，只有这两个节点能起到承上启下的作用，比所有的左子树节点都大，比所有的右子树节点都小；去替换目标节点后，这颗二叉树才能保持为搜索二叉树。

查找操作：
要在二叉搜索树中查找一个特定的值，需要按照以下步骤进行：

  1. 从根节点开始，将要查找的值与当前节点的值进行比较。
  2. 如果要查找的值等于当前节点的值，则找到了目标节点，返回该节点。
  3. 如果要查找的值小于当前节点的值，继续在当前节点的左子树中查找。
  4. 如果要查找的值大于当前节点的值，继续在当前节点的右子树中查找。
  5. 重复步骤3和4，直到找到目标节点或者遍历到叶子节点为止。

二叉搜索树的时间复杂度取决于树的平衡性。在最坏情况下，树可能变成链表，导致插入、删除和查找操作的时间复杂度为 O(n)。但是，如果树保持平衡，例如平衡二叉搜索树（AVL树、红黑树等），则这些操作的时间复杂度可以保持在 O(log n)。

以下是BST的代码实现：

定义BST的节点结构BSTreeNode，包含左子树指针_left、右子树指针_right和键值_key。

#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)
	{ }
};

定义BSTree类，其中的Find函数用于查找指定的键值。从根节点开始，根据当前节点的键值与目标键值的大小关系，沿着左子树或右子树逐步查找，直到找到目标键值或遍历完整个树。

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 Erase(const K& key)
	{
		if (_root == nullptr)
			return false;

		Node* cur = _root;
		Node* parent = nullptr;
		while (cur)
		{
			//不能在这更新parent,否则删除节点时parent和cur指向相同
			if (key < cur->_key)
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (key > cur->_key)
			{
				parent = cur;
				cur = cur->_right;
			}
			else//删除操作
			{
				//只有一个孩子，托孤法				
				if (cur->_right == nullptr)//只有一个左孩子（+无孩子）
				{
					if (parent == nullptr)
					{
						_root = cur->_left;
						delete cur;
						return true;
					}

					if (cur == parent->_left)
						parent->_left = cur->_left;
					else
						parent->_right = cur->_left;
					delete cur;
				}
				else if (cur->_left == nullptr)//只有一个右孩子
				{
					if (parent == nullptr)
					{
						_root = cur->_right;
						delete cur;
						return true;
					}

					if (cur == parent->_left)
						parent->_left = cur->_right;
					else
						parent->_right = cur->_right;
					delete cur;
				}
				else //左右都有孩子
				{
					//有两个孩子，替换删除法；左子树的最大（最右）节点或右子数的最小（最左）节点
					//找到右子树的最左节点
					Node* subLeft = cur->_right;
					Node* subParent = cur;
					while (subLeft->_left)
					{
						subParent = subLeft;
						subLeft = subLeft->_left;
					}
					swap(subLeft->_key, cur->_key);
					//经过交换后，现在只需删除subLeft，已经转化为只有一个孩子的情况，使用托孤法
					if (subParent->_left == subLeft)
						subParent->_left = subLeft->_right;
					else
						subParent->_right = subLeft->_right;

					delete subLeft;
				}
				return true;
			}
		}
		return false;
	}

Erase函数用于删除指定的键值对应的节点。删除操作分为四种情况：

  1. 节点只有一个左孩子（包括无孩子），使用"托孤法"将其父节点指向其左孩子。
  2. 节点只有一个右孩子，同样使用"托孤法"将其父节点指向其右孩子。
  3. 节点既有左孩子又有右孩子，采用"替换删除法"，找到右子树的最左节点（或左子树的最右节点），将其键值与当前节点键值交换，然后删除这个最左节点。
  4. 无孩子可以随便合并到只有一个孩子的情况，代码是兼容的。

	bool insert(const K& key)
	{
		if (_root == nullptr)
		{
			_root = new Node(key);
			return true;
		}
		else
		{
			Node* parent = nullptr;
			Node* cur = _root;
			while (cur)
			{	
				//parent = cur; 虽然写这里也可以，但是写在里面结构更清晰
				if (cur->_key > key)
				{
					parent = cur;
					cur = cur->_left;
				}
				else if (cur->_key < key)
				{
					parent = cur;
					cur = cur->_right;
				}
				else
					return false;
			}

			cur = new Node(key);
			parent->_key > cur->_key ? parent->_left = cur : parent->_right = cur;
		}
	}

insert函数用于插入一个新节点。若树为空，直接创建根节点；否则，从根节点开始，根据当前节点的键值与待插入键值的大小关系，沿着左子树或右子树逐步查找插入位置，直到找到一个空位置，然后创建新节点并插入。

	void midOrder()
	{
		_midOrder(_root);
	}
private:
	Node * _root = nullptr;

	void _midOrder(Node* node)
	{
		if (node == nullptr)
			return;

		_midOrder(node->_left);
		cout << node->_key << " ";
		_midOrder(node->_right);
	}
};

midOrder函数用于中序遍历树。由于根节点指针_root是私有的，无法在类外直接使用，因此提供了一个公有的无参遍历函数，在类内部调用私有的递归遍历函数_midOrder。

int main()
{
	int a[] = { 8,3,1,6,4,7,14,13 };
	BSTree<int> bst;
	for (int x : a)
	{
		bst.insert(x);
	}
	
	//测试：遍历删除
	for (int x : a)
	{
		bst.midOrder();
		cout << endl;
		bst.Erase(x);
		bst.midOrder();
		cout << endl;
		cout << endl;
	}

	cout << "全部删除成功" << endl;
	system("pause");
	return 0;
}

在主函数中，首先创建了一个BSTree对象bst，然后依次插入数组a中的元素。接下来进行遍历删除的测试，每次删除一个元素后，都会输出当前树的中序遍历结果。最后输出"全部删除成功"，并暂停程序的执行。

这段代码实现了BST的基本功能，包括查找、插入和删除操作，并且通过遍历删除的测试验证了代码的正确性。

这是插入后建立的二叉树的逻辑关系：

完整代码如下:

#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 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)
	{
		if (_root == nullptr)
			return false;

		Node* cur = _root;
		Node* parent = nullptr;
		while (cur)
		{
			//不能在这更新parent,否则删除节点时parent和cur指向相同
			if (key < cur->_key)
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (key > cur->_key)
			{
				parent = cur;
				cur = cur->_right;
			}
			else//删除操作
			{
				//只有一个孩子，托孤法				
				if (cur->_right == nullptr)//只有一个左孩子（+无孩子）
				{
					if (parent == nullptr)
					{
						_root = cur->_left;
						delete cur;
						return true;
					}

					if (cur == parent->_left)
						parent->_left = cur->_left;
					else
						parent->_right = cur->_left;
					delete cur;
				}
				else if (cur->_left == nullptr)//只有一个右孩子
				{
					if (parent == nullptr)
					{
						_root = cur->_right;
						delete cur;
						return true;
					}

					if (cur == parent->_left)
						parent->_left = cur->_right;
					else
						parent->_right = cur->_right;
					delete cur;
				}
				else //左右都有孩子
				{
					//有两个孩子，替换删除法；左子树的最大（最右）节点或右子数的最小（最左）节点
					//找到右子树的最左节点
					Node* subLeft = cur->_right;
					Node* subParent = cur;
					while (subLeft->_left)
					{
						subParent = subLeft;
						subLeft = subLeft->_left;
					}
					swap(subLeft->_key, cur->_key);
					//经过交换后，现在只需删除subLeft，已经转化为只有一个孩子的情况，使用托孤法
					if (subParent->_left == subLeft)
						subParent->_left = subLeft->_right;
					else
						subParent->_right = subLeft->_right;

					delete subLeft;
				}
				return true;
			}
		}
		return false;
	}

	//插入节点，要保证插入的值不同，一旦发现相同的，返回false
	bool insert(const K& key)
	{
		if (_root == nullptr)
		{
			_root = new Node(key);
			return true;
		}
		else
		{
			Node* parent = nullptr;
			Node* cur = _root;
			while (cur)
			{	
				//parent = cur; 虽然写这里也可以，但是写在里面结构更清晰
				if (cur->_key > key)
				{
					parent = cur;
					cur = cur->_left;
				}
				else if (cur->_key < key)
				{
					parent = cur;
					cur = cur->_right;
				}
				else
					return false;
			}

			cur = new Node(key);
			parent->_key > cur->_key ? parent->_left = cur : parent->_right = cur;
		}
	}

	//遍历树需要传根节点指针，但是树的指针是私有的
	//解决方法：套一层壳，给用户提供无参的遍历函数，在类内部调用传参遍历函数
	void midOrder()
	{
		_midOrder(_root);
	}
private:
	Node * _root = nullptr;

	void _midOrder(Node* node)
	{
		if (node == nullptr)
			return;

		_midOrder(node->_left);
		cout << node->_key << " ";
		_midOrder(node->_right);
	}
};


int main()
{
	int a[] = { 8,3,1,6,4,7,14,13 };
	BSTree<int> bst;
	for (int x : a)
	{
		bst.insert(x);
	}
	
	//测试：遍历删除
	for (int x : a)
	{
		bst.midOrder();
		cout << endl;
		bst.Erase(x);
		bst.midOrder();
		cout << endl;
		cout << endl;
	}

	cout << "全部删除成功" << endl;
	system("pause");
	return 0;
}

以上是BST的实现是以迭代方式（循环），下一篇博客会展示以递归方式实现BST的增、删、查。

4C++
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
LeetCode-173. 二叉搜索树迭代器
保持对编程的热情！
12-26 218
实现一个二叉搜索树迭代器。你将使用二叉搜索树的根节点初始化迭代器。 调用 next() 将返回二叉搜索树中的下一个最小的数。 示例： BSTIterator iterator = new BSTIterator(root); iterator.next(); // 返回 3 iterator.next(); // 返回 7 iterator.hasNext(); // 返回...
LintCode_二叉查找树迭代器
Jeza SS
08-23 497
设计实现一个带有下列属性的二叉查找树的迭代器： 元素按照递增的顺序被访问（比如中序遍历）next()和hasNext()的询问操作要求均摊时间复杂度是O(1) 您在真实的面试中是否遇到过这个题？  Yes 样例 对于下列二叉查找树，使用迭代器进行中序遍历的结果为 [1, 6, 10, 11, 12] 10 / \ 1
[leetcode 173] Binary Search Tree Iterator-------为二叉搜索树实现迭代器功能
清空
03-30 912
Question: Implement an iterator over a binary search tree (BST). Your iterator will be initialized with the root node of a BST. Calling next() will return the next smallest number in the BST.
173. 二叉搜索树迭代器
qq_36059306的博客
03-06 161
二叉搜索树迭代器 实现一个二叉搜索树迭代器。你将使用二叉搜索树的根节点初始化迭代器。 调用 next() 将返回二叉搜索树中的下一个最小的数。 示例： BSTIterator iterator = new BSTIterator(root); iterator.next(); // 返回 3 iterator.next(); // 返回 7 iterator.hasNext(); /...
Leetcode 173. 二叉搜索树迭代器
liaoxuda_edu的博客
08-09 580
刚刚拿到这个题目的时候一脸懵逼，这啥子情况。冷静一想，悟出其中奥妙。 不就是搜索二叉树进行中序遍历一下，然后用hasnext和next方法操作一下而已啦。 很简单很简单，Mid方法是自己写的中序遍历的方法。用一个Deque来做容器，虽然STL源码剖析上说这个deque能不用最好不用，因为其复杂度比较高，操作起来比较费事，但是图个方便嘛。下面为源码。    AC解： class BSTI...
二叉搜索树迭代器
qq_43806430的博客
03-19 133
二叉搜索树迭代器 /** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode() {} * TreeNode(int val) { this.val = val; } * TreeNode(int val, TreeNode left, TreeNod...
leetcode 173. 二叉搜索树迭代器
_ostreamBaba
09-15 453
实现一个二叉搜索树迭代器。你将使用二叉搜索树的根节点初始化迭代器。 调用 next() 将返回二叉搜索树中的下一个最小的数。 注意: next() 和hasNext() 操作的时间复杂度是O(1)，并使用 O(h) 内存，其中 h 是树的高度。 中序遍历一下存下每个点即可。 /** * Definition for binary tree * public clas...
LeetCode 173. 二叉搜索树迭代器
weixin_37763870的博客
02-17 281
题目描述 实现一个二叉搜索树迭代器。你将使用二叉搜索树的根节点初始化迭代器。 调用 next() 将返回二叉搜索树中的下一个最小的数。 思路 详见链接 代码 class TreeNode: def __init__(self,x): self.val = x self.left = None self.right = None class BSTIterator: def __i...
二叉搜索树的迭代器
Tlwhisper的博客
04-20 272
文章目录1、描述2、关键字3、思路4、notes5、复杂度6、code 1、描述 实现一个二叉搜索树迭代器类BSTIterator ，表示一个按中序遍历二叉搜索树（BST）的迭代器： BSTIterator(TreeNode root) 初始化 BSTIterator 类的一个对象。BST 的根节点 root 会作为构造函数的一部分给出。指针应初始化为一个不存在于 BST 中的数字，且该数字小于 BST 中的任何元素。 boolean hasNext() 如果向指针右侧遍历存在数字，则返回 true ；否则
173.二叉搜索树迭代器
cqjnovo的博客
09-04 1192
实现一个二叉搜索树迭代器类roottruefalseint next()注意，指针初始化为一个不存在于 BST 中的数字，所以对next()的首次调用将返回 BST 中的最小元素。你可以假设next()调用总是有效的，也就是说，当调用next()时，BST 的中序遍历中至少存在一个下一个数字。// 返回 3// 返回 7// 返回 True// 返回 9// 返回 True// 返回 15// 返回 True// 返回 20// 返回 False[1, 105]105。
Python实现二叉搜索树BST的方法示例
09-18
3. **查询二叉搜索树中的节点**：`search1`和`search2`函数分别使用递归和迭代方式搜索具有给定关键字的节点。 ```python # 递归实现 def search1(root, value): # ... (见上文) # 迭代实现 def search2(root, ...
二叉搜索树迭代器(java代码).docx
04-19
### 二、二叉搜索树迭代器实现原理 二叉搜索树迭代器的主要目的是提供一种能够遍历二叉搜索树中所有节点的方法，通常按照某种顺序进行访问，如中序遍历（In-order Traversal）可以得到升序排序的结果。 #### 1. ...
二叉搜索树查找算法【实现】.rar_C++_C++ 二叉搜索树_organizationzme
09-23
7. **优化**：除了基本的查找、插入和删除操作，我们还可以对二叉搜索树进行优化，例如，使用迭代而不是递归，或者在插入和删除时考虑平衡因子以保持树的平衡。 以上就是二叉搜索树查找算法的基本实现和相关知识。...
树-98. 验证二叉搜索树-PYTHON
01-20
在二叉搜索树（Binary Search Tree，BST）中，每个节点的值必须满足以下规则：对于任意节点，其左子树中的所有节点的值都小于该节点的值，而其右子树中的所有节点的值都大于该节点的值。在给定的题目“树-98. 验证...
C语言：刷题笔记
weixin_45930573的博客
09-04 404
c语言刷题记录
【C++】STL—vector的使用
2301_77112794的博客
09-04 693
本文介绍了vector重点函数接口的使用
【C++】vector的简单模拟实现
2303_80828380的博客
09-05 1177
vector的简单模拟实现！！！
C语言 ——— #define 定义宏
weixin_55341642的博客
09-04 827
a + b 的和 于 b - a 的差 做乘法，a + b = 8 ，b - a = 2。#define 机制包括了一个规定，允许把参数替换到文本中，这种实现通常称宏。在宏中的每个变量都加上了括号，加上括号的意义在哪，是否能去掉括号呢？所以在声明宏的时候，最好加上必要的括号，以免出现优先级问题。可以从代码验证中看出，不加括号的结果和预期的结果大相径庭。预期结果：8 * 2 = 16。
C语言 | Leetcode C语言题解之第389题找不同
最新发布
m0_59237910的博客
09-07 487
C语言 | Leetcode C语言题解之第389题找不同
实现二叉搜索树迭代器
"二叉搜索树迭代器的实现与使用" 二叉搜索树（Binary Search Tree, BST）是一种特殊的二叉树结构，其中每个节点的值都大于其左子树中的所有节点值，且小于其右子树中的所有节点值。这使得在BST中进行查找、插入和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值