【C++】实现一个搜索二叉树（BSTree）：从定义到操作全解析

最新推荐文章于 2024-05-11 18:41:21 发布
最新推荐文章于 2024-05-11 18:41:21 发布
阅读量662 收藏 4
点赞数 16
分类专栏： C++ 数据结构与算法 文章标签： c++ 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Colorful___/article/details/136439217
版权

文章目录


搜索二叉树（Binary Search Tree，简称BST）是一种特殊的二叉树，它满足任一节点的左子树中的所有节点的值都小于该节点的值，右子树中的所有节点的值都大于该节点的值。这使得BST在查找、插入和删除操作上具有较高的效率。本文将详细介绍如何从零开始实现一个搜索二叉树，包括其节点结构的定义和一系列基本操作的实现。

BSTreeNode类的定义

首先，我们需要定义树的节点BSTreeNode，它将作为树的基础结构：

template<class K, class V>
class BSTreeNode {
public:
    K _key;     // 节点存储的键
    V _value;   // 节点存储的值
    BSTreeNode* _left;   // 左子节点
    BSTreeNode* _right;  // 右子节点

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

BSTree类的实现

接着，我们来实现BSTree类，它包含了一系列操作二叉搜索树的方法：

插入操作

插入操作Insert的核心思想是比较待插入节点的键与当前节点的键，决定向左子树还是右子树递归地进行插入操作。

	bool Insert(const K& key, const V& value) {
		if (!_root) {
			_root = new Node(key, value);
			return true;
		}

		Node* parent = nullptr;
		Node* current = _root;
		while (current) {
			parent = current;
			if (key < current->_key) {
				current = current->_left;
			}
			else if (key > current->_key) {
				current = current->_right;
			}
			else {
				return false; // key已经存在
			}
		}

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

		return true;
	}

查找操作

查找操作Find通过逐层比较键值，沿树向下移动，直到找到匹配的节点或达到叶子节点。

Node* Find(const K& key) {
	Node* current = _root;
	while (current) {
		if (key < current->_key) {
			current = current->_left;
		}
		else if (key > current->_key) {
			current = current->_right;
		}
		else {
			return current; // 找到了
		}
	}
	return nullptr; // 没有找到
}

删除操作

删除操作Erase是最复杂的，它需要处理三种情况：被删除节点是叶子节点、只有一个子节点、有两个子节点。

  1. 被删除节点是叶子节点：直接删除该节点，并将其父节点的相应指针设置为nullptr。
  2. 被删除节点只有一个子节点：删除该节点，并将其父节点的相应指针指向其子节点。
  3. 被删除节点有两个子节点：找到该节点的中序后继节点（右子树中的最小节点），用它来替换被删除节点的键和值，然后删除中序后继节点。

下面是Erase函数的实现代码：

bool Erase(const K& key) {
	Node* parent = nullptr;
	Node* current = _root;
	// 查找key对应的节点，同时记录其父节点
	while (current != nullptr && current->_key != key) {
		parent = current;
		if (key < current->_key) {
			current = current->_left;
		}
		else {
			current = current->_right;
		}

		if (current == nullptr) {
			// 没有找到对应的节点
			return false;
		}
	}
	//case1&2: 没有孩子或者只有一个孩子
	if (current->_left == nullptr || current->_right == nullptr) {
		Node* child = (current->_left == nullptr) ? current->_right : current->_left;
		if (parent == nullptr) {
			// 删除的是根节点
			_root = child;
		}
		else {
			if (parent->_left == current) {
				parent->_left = child;
			}
			else {
				parent->_right = child;
			}
		}
		delete current;
	}
	else {
		// case 3: 两个孩子
		// 找到右子树最小节点， 即中序后继节点
		Node* successor = current->_right;
		Node* successorParent = current;
		while (successor->_left != nullptr) {
			successorParent = successor;
			successor = successor->_left;
		}

		// 替换current 的节点和键值
		current->_key = successor->_key;
		current->_value = successor->_value;
		if (successorParent->_left = successor) {
			successorParent->_left = successor->_right;
		}
		else {
			successorParent->_right = successor->_right;
		}

		delete successor;
	}
}

中序遍历

中序遍历InOrder按照左子树-根节点-右子树的顺序访问树中的每个节点，对于BST来说，这将以升序方式访问所有节点。

	void _InOrder(Node* root) {
		if (!root) return;
		_InOrder(root->_left);
		cout << root->_key << " : " << root->_value << endl;
		_InOrder(root->_right);
	}
	void InOrder() {
    	_InOrder(_root);
	}

递归实现

对于插入、查找和删除操作，我们还提供了递归版本的实现方法，以更直观地展示这些操作的逻辑。

// 递归版本 //
	bool FindR(const K& key) {
		return _FindR(_root, key);
	}

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

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

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

	bool _InsertR(Node*& root, const K& key, const V& value) {
		if (root == nullptr) {
			root = new Node(key, value);
			return true;
		}

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

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

		if (root->_key < key) {
			return _EraseR(root->_right, key);
		}
		else if (root->_key > key) {
			return _EraseR(root->_left, key);
		}
		else {
			//case1&2: 没有孩子或者只有一个孩子
			Node* del = root;
			if (root->_right == nullptr) {
				root = root->_left;
			} 
			else if (root->_left == nullptr){
				root = root->_right;
			}
			else {
				// case 3: 两个孩子
				// 找到右子树最小节点，即中序后继节点
				Node* successor = root->_right;
				while (successor->_left != nullptr) {
					successor = successor->_left;
				}

				// 将中序后继节点的值复制到当前节点
				root->_key = successor->_key;

				// 递归删除中序后继节点
				_EraseR(root->_right, successor->_key);
			}
			delete del;
			return true;
		}
	}

完整代码和测试

文章最后给出了BSTree类的完整实现代码，并提供了几个简单的测试用例来验证我们的实现。

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

template<class K, class V>
class BSTreeNode {
public:
	K _key;	// 节点存储的键
	V _value;	// 节点存储的值
	BSTreeNode* _left; //左子节点
	BSTreeNode* _right; //右子节点

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

template<class K, class V>
class BSTree
{
	typedef BSTreeNode<K, V> Node;
public:
	//强制生成默认构造
	BSTree() = default;

	BSTree(const BSTree<K,V>& t) {
		_root = Copy(t._root);
	}

	BSTree<K,V>& operator=(BSTree<K,V>& t) {
		swap(_root, t._root);
	}

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

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

	~BSTree()
	{
		Destroy(_root);
	}

	void Destroy(Node* root) {
		if (root == nullptr)
			return;
		Destroy(root->_left);
		Destroy(root->_right);
		delete root;
	}

	bool Insert(const K& key, const V& value) {
		if (!_root) {
			_root = new Node(key, value);
			return true;
		}

		Node* parent = nullptr;
		Node* current = _root;
		while (current) {
			parent = current;
			if (key < current->_key) {
				current = current->_left;
			}
			else if (key > current->_key) {
				current = current->_right;
			}
			else {
				return false; // key已经存在
			}
		}

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

		return true;
	}

	Node* Find(const K& key) {
		Node* current = _root;
		while (current) {
			if (key < current->_key) {
				current = current->_left;
			}
			else if (key > current->_key) {
				current = current->_right;
			}
			else {
				return current; // 找到了
			}
		}
		return nullptr; // 没有找到
	}
	bool Erase(const K& key) {
		Node* parent = nullptr;
		Node* current = _root;
		// 查找key对应的节点，同时记录其父节点
		while (current != nullptr && current->_key != key) {
			parent = current;
			if (key < current->_key) {
				current = current->_left;
			}
			else {
				current = current->_right;
			}

			if (current == nullptr) {
				// 没有找到对应的节点
				return false;
			}
		}
		//case1&2: 没有孩子或者只有一个孩子
		if (current->_left == nullptr || current->_right == nullptr) {
			Node* child = (current->_left == nullptr) ? current->_right : current->_left;
			if (parent == nullptr) {
				// 删除的是根节点
				_root = child;
			}
			else {
				if (parent->_left == current) {
					parent->_left = child;
				}
				else {
					parent->_right = child;
				}
			}
			delete current;
		}
		else {
			// case 3: 两个孩子
			// 找到右子树最小节点， 即中序后继节点
			Node* successor = current->_right;
			Node* successorParent = current;
			while (successor->_left != nullptr) {
				successorParent = successor;
				successor = successor->_left;
			}

			// 替换current 的节点和键值
			current->_key = successor->_key;
			current->_value = successor->_value;
			if (successorParent->_left = successor) {
				successorParent->_left = successor->_right;
			}
			else {
				successorParent->_right = successor->_right;
			}

			delete successor;
		}
	}

	void InOrder() {
		_InOrder(_root);
	}

	// 递归版本 //
	bool FindR(const K& key) {
		return _FindR(_root, key);
	}

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

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

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

	bool _InsertR(Node*& root, const K& key, const V& value) {
		if (root == nullptr) {
			root = new Node(key, value);
			return true;
		}

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

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

		if (root->_key < key) {
			return _EraseR(root->_right, key);
		}
		else if (root->_key > key) {
			return _EraseR(root->_left, key);
		}
		else {
			//case1&2: 没有孩子或者只有一个孩子
			Node* del = root;
			if (root->_right == nullptr) {
				root = root->_left;
			} 
			else if (root->_left == nullptr){
				root = root->_right;
			}
			else {
				// case 3: 两个孩子
				// 找到右子树最小节点，即中序后继节点
				Node* successor = root->_right;
				while (successor->_left != nullptr) {
					successor = successor->_left;
				}

				// 将中序后继节点的值复制到当前节点
				root->_key = successor->_key;

				// 递归删除中序后继节点
				_EraseR(root->_right, successor->_key);
			}
			delete del;
			return true;
		}
	}

	void _InOrder(Node* root) {
		if (!root) return;
		_InOrder(root->_left);
		cout << root->_key << " : " << root->_value << endl;
		_InOrder(root->_right);
	}
	
	Node* _root = nullptr;
};

void TestBSTree1()
{
	BSTree<string, string> dict;
	dict.InsertR("insert", "插入");
	dict.InsertR("erase", "删除");
	dict.InsertR("left", "左边");
	dict.InsertR("string", "字符串");
	dict.InOrder();
	string str;
	while (cin >> str)
	{
		auto ret = dict.Find(str);
		if (ret)
		{
			cout << str << ":" << ret->_value << endl;
		}
		else
		{
			cout << "单词拼写错误" << endl;
		}
		cout << "删除： " << ret->_key << " : " << ret->_value << endl;
		dict.EraseR(ret->_key);
		dict.InOrder();
	}
}

void TestBSTree2()
{
	string strs[] = { "苹果", "西瓜", "苹果", "樱桃", "苹果", "樱桃", "苹果", "樱桃", "苹果" };
	// 统计水果出现的次
	BSTree<string, int> countTree;
	for (auto str : strs)
	{
		auto ret = countTree.Find(str);
		if (ret == NULL)
		{
			countTree.Insert(str, 1);
		}
		else
		{
			ret->_value++;
		}
	}
	countTree.InOrder();
}

void TestBSTree3() {
	BSTree<int, string> t;
	t.Insert(8, "八");
	t.Insert(3, "三");
	t.Insert(1, "一");
	t.Insert(10, "十");
	t.Insert(6, "六");
	t.Insert(4, "四");
	t.Insert(7, "七");
	t.Insert(14, "十四");
	t.Insert(13, "十三");
	
	t.InOrder();

	BSTree<int, string> t1(t);
	t1.InOrder();
}

总结

通过本文的介绍，我们了解了二叉搜索树的基本概念、节点结构的定义以及如何实现插入、查找、删除和中序遍历等基本操作。实现一个搜索二叉树不仅能够加深对数据结构和算法的理解，也能够提升编程能力和问题解决能力。

Q_hd
关注
  • 16
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
【C++】二叉搜索树解析
love_guanghui的博客
03-02 989
二叉搜索树概念 概念
266-C++ 二叉树
weixin_45964837的博客
03-19 609
1.判断是否为完全二叉树的方法，先将根节点(A)入队，队列不为空，将A出队，将A的左右孩子(BC)入队，队列不为空，将A的左孩子(B)出队，将A的左孩子的左右孩子(DE)入队，队列不为空，将A的右孩子©出队，将A的右孩子的左右孩子(FG)入队，队列不为空，将A的左孩子的左孩子(D)出队，将A的左孩子的左孩子的左右孩子(H空)入队，队列不为空，将A的左孩子的右孩子(E)出队，将A的左孩子的右孩子的左右孩子(空I)入队，队列不为空，将A的右孩子的左孩子(F)出队，将A的右孩子的左孩子的左右孩子(空空)入队，队列
【C++进阶】二叉树进阶之二叉搜索树以及模拟实现
Weraphael的博客
09-12 506
本篇博客介绍了二叉搜索树，如何模拟实现二叉搜索树（递归版和非递归版），以及使用场景
二叉查找树（二）- C++实现
生活需要深度
06-30 365
上一章介绍了"二叉查找树的相关理论知识，并通过C语言实现了二叉查找树"。这一章给出二叉查找树的C++版本。这里不再对树的相关概念进行介绍，若遇到不明白的概念，可以在上一章查找。目录 1. 二叉树查找树 2. 二叉查找树的C++实现 3. 二叉查找树的C++实现(完整源码) 4. 二叉查找树的C++测试程序转载请注明出处：二叉查找树(二)之 C++的实现 - 如果天空不死 - 博客园更多内容: 数据结构与算法系列 目录 (01) 二叉查找树(一)之 图文解析 和 C语言的实现 (02) 二叉查找树(二)之 C
数据结构图文解析之：树的简介及二叉排序树C++模板实现.
疾风剑豪
04-21 310
阅读目录 0. 数据结构图文解析系列 1. 树的简介 1.1 树的特征 1.2 树的相关概念 2. 二叉树简介 2.1 二叉树的定义 2.2 斜树、满二叉树、完全二叉树、二叉查找树 2.3 二叉树的性质 3. 二叉查找树 3.1 节点结构 3.2 二叉查找树的抽象数据结构 3.3 插入新节点 3.2 遍历平衡二叉树 3.2 前驱与后继 3.3 ...
【转】数据结构图文解析之：树的简介及二叉排序树C++模板实现
weixin_30600503的博客
07-09 42
以下转载自https://www.cnblogs.com/QG-whz/p/5168620.html#_labelTop 阅读目录 0. 数据结构图文解析系列 1. 树的简介 1.1 树的特征 1.2 树的相关概念 2. 二叉树简介 2.1 二叉树的定义 2.2 斜树、满二叉树、完全二叉树、二叉查找树 2.3 二叉树的性质 3. 二叉查...
数据结构/C++：二叉搜索树
盒马的博客
03-03 1534
讲解以C++实现的数据结构：二叉搜索树
二叉查找树解析及其C++实现
Nim的辙迹
01-21 552
二叉查找树的介绍及其C++实现
树的简介及二叉排序树C++模板实现.
turnura的博客
11-07 278
树的简介及二叉排序树C++模板实现.1. 树的简介1.1 树的特征1.2 树的相关概念2. 二叉树简介2.1 二叉树的定义2.2 斜树、满二叉树、完全二叉树、二叉查找树2.3 二叉树的性质3. 二叉查找树3.1 节点结构3.2 二叉查找树的抽象数据结构 1. 树的简介 1.1 树的特征 树是一种数据结构，它是n(n>=0)个节点的有限集。n=0时称为空树。n>0时，有限集的元素构成一个具有层次感的数据结构 区别于线性表一对一的元素关系，树中的节点是一对多的关系。树具有以下特点： n>0
二叉树-基于C++实现的二叉树操作.zip
04-26
二叉树 二叉树_基于C++实现的二叉树操作
C++实现二叉树基本操作详解
12-26
本学年论文介绍了二叉树的定义，二叉树的存储结构，二叉树的相关术语，以此引入二叉树这一概念，为展开二叉树的基本操作做好理论铺垫。二叉树的基本操作主要包含以下几个模块：二叉树的遍历方法，计算二叉树的结点个...
C++自实现二叉树的基本操作
11-03
1、本文详细描述了c++语言实现二叉树基本操作的方法。 2、通过详细示例，让读者更直观地阅读，更清晰的理解。 3、示例代码可直接复制，编译后可直接运行。 4、根据示例以及运行结果，让读者加强记忆及理解。
基于C++实现（WinForm）二叉树及模拟社会关系网络【100010542】
01-28
采用开发平台为 Qt Creator ...完成实现类（二叉树）的设计与实现。包括先序、中序、后序遍历；先序、中序、后序线索化；统计叶子结点个数。 设计显示图形，并将图形与二叉树进行映射。 进行整体调试与容错性检测。
根据二叉树的抽象数据类型的定义，使用二叉链表实现一个二叉树。
12-07
二叉树的基本功能： 1、二叉树的建立 2、前序遍历二叉树 3、中序遍历二叉树 4、后序遍历二叉树 5、按层序遍历二叉树 6、求二叉树的深度 7、求指定结点到根的路径 8、二叉树的销毁 9、其他：自定义操作
c++父类指针指向子类
最新发布
qq_43700779的博客
05-11 195
父类指针指向子类，调用的函数是谁的
c++ 点到多边形的距离
jacke121的专栏
05-08 319
c++ 点到多边形的距离
C++初探_虚基类的声明
qq_43634157的博客
05-09 124
存在的原因：希望在多重继承时（即：派生类有多个直接基类，而这些直接基类是从同一个祖先基类派生而来），派生类只继承一个共同的祖先基类对象。分析：禁止信息通过中间类自动传递给虚基类。因此，在派生类中，必须通过显式地调用虚基类构造函数进行初始化。
UE5C++ FString做为参数取值时报错error：C4840
YanisWu的博客
05-11 168
UE5 C++ 的FString类型取值问题。
c++实验4:二叉树的存储及操作实现
11-25
二叉树是一种非常常见的数据结构，它可以用来表示树形结构的数据，比如家谱、组织结构等。在实验4中，我们主要学习了二叉树的存储及操作实现。 首先，我们需要了解二叉树的存储方式。二叉树可以通过链式存储和顺序存储两种方式来实现。链式存储是指用指针来实现树节点之间的连接，而顺序存储则是利用数组来存储树的节点。在实验中，我们需要掌握这两种存储方式的实现原理及其优缺点。 其次，我们学习了二叉树的基本操作，包括节点的插入、删除、查找以及遍历等。通过实验，我们可以了解到这些操作的具体实现方式，比如使用递归或者队列来实现树的遍历操作。同时，我们还需要理解这些操作的时间复杂度，并且掌握在各种场景下选择合适的操作方式。 最后，在实验中我们还需要实现一些二叉树的高级操作，比如树的深度、宽度等。这些操作需要对树的结构有更深入的理解，并且需要掌握相应的算法来实现。 通过实验4的学习，我们不仅能够掌握二叉树的存储与操作技术，还可以提升自己的编程能力和算法思维。这些知识对于我们以后的工作和学习都将有很大的帮助。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Q_hd

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

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

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

打赏作者

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

抵扣说明：

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

余额充值