C++数据结构 —— 二叉搜索树

最新推荐文章于 2024-04-24 19:37:23 发布
最新推荐文章于 2024-04-24 19:37:23 发布
阅读量668 收藏
点赞数
文章标签： 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_59913110/article/details/129015343
版权

目录

1.二叉搜索树的基本概念

1.1二叉搜索树的基本特征

 2.二叉搜索树的实现

2.1数据的插入(迭代实现)

2.2数据的搜索(迭代实现)

2.3中序遍历(递归实现)

2.4数据的删除(迭代实现)

2.5数据的搜索(递归实现)

2.6数据的插入(递归实现)

2.7数据的删除(递归实现)

2.8类的完善

3.二叉搜索树的应用

4.完整代码

 二叉搜索树

1.二叉搜索树的基本概念

二叉搜索树又称二叉排序树，它可以是一颗空树。二叉搜索树的作用是搜索，排序(二叉搜索树的中序遍历是一组递增有序数据)。

1.1二叉搜索树的基本特征

如果某颗二叉树(包括空树)满足以下性质，可以作为一颗二叉搜索树：

        1.如果左子树不为空，其键值应小于根节点的键值。

        2.如果右子树不为空，其键值应大于根节点的键值。

        3.左右子树都满足上述条件。

没有二叉搜索树之前，常用的查找算法为二分查找。但是二分查找是有局限性的(必须针对有序数组)。二叉搜索树因其特性，例如我们需要查找Key值，只需要与根节点的键值做比较：若Key小于根节点的键值，则往根节点的左子树遍历；若Key值大于根节点的键值，则往根节点的右子树遍历。经计算，查找的次数等于二叉搜索树的深度。正因为如此，二叉搜索树并不是一个优秀的数据结构，因为一但碰到极端情况，二叉搜索树的搜索效率将会大打折扣。所以在往后的章节中，将会使其平衡。

 2.二叉搜索树的实现

 将二叉搜索树定义为一个类，现在将展示类的框架。往后所有的演示代码，都可以直接加入其中：

// 节点
template <class K>
struct BST_node
{
	BST_node<K>* _left;		//左子树
	BST_node<K>* _right;	//右子树
	K _key;

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

template <class K>		//节点键值的数据类型
class BST
{
	typedef BST_node<K> Node;
public:

private:
	Node* _root;	//根节点
};

2.1数据的插入(迭代实现)

bool insert(const K& key)
{
	if (_root == nullptr)
	{
		_root = new Node(key);
		return true;
	}
		
	Node* prev = nullptr;	// cur的父节点
	Node* cur = _root;
	while (cur)
	{
		if (key < cur->_key)	//如果比根节点的键值小
		{
			prev = cur;
			cur = cur->_left;
		}
		else if(key > cur->_key)	//如果比根节点的键值大
		{
			prev = cur;
			cur = cur->_right;
		}
		else
		{
			// 我们不允许插入重复的数据
			return false;
		}
	}

	// 直到遍历到空，才施行插入
	cur = new Node(key);
	if (key < prev->_key)
	{
		prev->_left = cur;
	}
	else if (key > prev->_key)
	{
		prev->_right = cur;
	}
	return true;
}

2.2数据的搜索(迭代实现)

bool find(const K& key)
{
	if (_root == nullptr)
	{
		return false;
	}
		
	Node* cur = _root;
	while (cur)
	{
		if (key < cur->_key)
		{
			cur = cur->_left;
		}
		else if (key > cur->_key)
		{
			cur = cur->_right;
		}
		else
		{
			// 找到了
			return true;
		}
	}
	return false;
}

2.3中序遍历(递归实现)

void MidTraval()	//此接口作公有
{
	__MidTraval(_root);
	cout << endl;
}

void __MidTraval(Node* root)	//此接口做私有
{
	if (root == nullptr)
	{
		return;
	}

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

2.4数据的删除(迭代实现)

需要注意，要删除二叉搜索树的节点，就必须分两种情况讨论：

        1.要删除节点的左子树或右子树为空。

        2.要删除节点的左、右子树都不为空。

bool erase(const K& key)
{
	if (_root == nullptr)
	{
		return false;
	}

	Node* prev = _root;
	Node* cur = _root;
	while (cur)
	{
		if (key < cur->_key)
		{
			prev = cur;
			cur = cur->_left;
		}
		else if (key > cur->_key)
		{
			prev = cur;
			cur = cur->_right;
		}
		else
		{
			// 如果左子树为空
			if (cur->_left == nullptr)
			{
				// 假设右子树不为空，则将右子树托孤给父节点
				if (_root == cur)
				{
					_root = _root->_right;
				}
				else if (prev->_left == cur)
				{
					prev->_left = cur->_right;
				}
				else if (prev->_right == cur)
				{
					prev->_right = cur->_right;
				}

				delete cur;
				return true;
			}

			// 如果右子树为空
			else if (cur->_right == nullptr)
			{
				//假设左子树不为空，则将左子树托孤给父节点
				if (_root == cur)
				{
					_root = _root->_left;
				}
				else if (prev->_left == cur)
				{
					prev->_left = cur->_left;
				}
				else if (prev->_right == cur)
				{
					prev->_right = cur->_left;
				}

				delete cur;
				return true;
			}

			// 如果左右子树都不为空
			else
			{
				// 假设使用右子树的最小值替代
				Node* prev = _root;
				Node* minRight = cur->_right;

				while (minRight->_left)		//二叉树特性，越往左越小
				{
					prev = minRight;
					minRight = minRight->_left;
				}

				cur->_key = minRight->_key;

				// 替换好后，就要删除minRight
				if (prev->_left == minRight)
				{
					prev->_left = minRight->_right;
				}
				else if (prev->_right == minRight)
				{
					prev->_right = minRight->_right;
				}
					
				delete minRight;
				return true;
			}
		}
	}
	return false;
}

2.5数据的搜索(递归实现)

bool findR(const K& key)
{
	return __findR(_root, key);
}

bool __findR(Node* root, const K& key)	//此接口作私有
{
	if (root == nullptr)
	{
		return false;
	}

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

2.6数据的插入(递归实现)

bool insertR(const K& key)
{
	return __insertR(_root, key);
}

bool __insertR(Node*& root, const K& key)	//此接口作私有
{
	if (root == nullptr)
	{
		root = new Node(key);	//注意引用传参，root相当于root->left或root->right的别名
		return true;
	}


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

2.7数据的删除(递归实现)

bool eraseR(const K& key)
{
	return __eraseR(_root, key);
}

bool __eraseR(Node*& root, const K& key)	//此接口作私有
{
	if (root == nullptr)
	{
		return false;
	}

	if (key < root->_key)
	{
		return __eraseR(root->_left, key);
	}
	else if (key > root->_key)
	{
		return __eraseR(root->_right, key);
	}
	else
	{
		Node* del = root;
		if (root->_left == nullptr)
		{
			// 此时root就是要删除的节点，并且是root的父节点的子节点的引用(root == root->_left...)
			root = root->_right;

			delete del;
			return true;
		}
		else if (root->_right == nullptr)
		{
			root = root->_left;

			delete del;
			return true;
		}
		else
		{
			Node* prev = _root;
			Node* minRight = root->_right;

			while (minRight->_left)		//二叉树特性，越往左越小
			{
				prev = minRight;
				minRight = minRight->_left;
			}

			root->_key = minRight->_key;

			// 替换好后，就要删除minRight
			if (prev->_left == minRight)
			{
				prev->_left = minRight->_right;
			}
			else if (prev->_right == minRight)
			{
				prev->_right = minRight->_right;
			}

			delete minRight;
			return true;
		}
	}
	return false;
}

2.8类的完善

BST()
	:_root(nullptr)
{}

~BST()
{
	Destructor(_root);
	_root = nullptr;
}

void Destructor(Node* root)	//此函数作私有
{
	if (root == nullptr)
	{
		return;
	}

	// 后序删除
	Destructor(root->_left);
	Destructor(root->_right);
	delete root;
}

BST(const BST<K>& t)
{
	_root = Copy(t._root);
}

Node* Copy(Node* root)	//此接口作私有
{
	if (root == nullptr)
	{
		return nullptr;
	}

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

BST<K>& operator==(BST<K> t)	//现代写法
{
	swap(_root, t._root);
	return *this;
}

3.二叉搜索树的应用

1.K模型：

        K模型即只有key作为关键码，结构中只需要存储Key即可，关键码即为需要搜索到的值。上面模拟实现的搜索就是K模型。

        例如将英文字典所有的英文单词存储二叉搜索树这个数据结构，那么可将英文单词看作关键码Key，假设我们想查找"hello"这个单词，直接去数据结构找即可。

2.KV模型：

        每一个关键码key，都有与之对应的值Value，即<Key, Value>的键值对。该种方式在现实生活中非常常见。

        例如英汉互译，一个英文单词对应了多个汉语翻译。我们将<英文单词，中文翻译的数组>这样的键值对放入二叉搜索树中。例如查找"hello"这个单词的中文翻译，只需要查找键值对的英文单词即可。

KV模型例题：

给定下面数组，求每种水果出现的次数：

string arr[] = { "苹果", "西瓜", "苹果", "西瓜", "苹果", "苹果", "西瓜",
"苹果", "香蕉", "苹果", "香蕉" };

第一步：先实现二叉搜索树(为了方便，这里只保留插入数据、查找和中序遍历的接口)：

namespace KV
{

	// 节点
	template <class Key,class Val>
	struct BST_node
	{
		BST_node<Key,Val>* _left;		//左子树
		BST_node<Key,Val>* _right;	//右子树
		Key _key;
		Val _val;
		BST_node(const Key& key,const Val& val)
			:_key(key), _val(val),_left(nullptr), _right(nullptr)
		{}
	};

	template <class Key,class Val>
	class BST
	{
		typedef BST_node<Key,Val> Node;
	public:
		bool insert(const Key& key,const Val& val)
		{
			if (_root == nullptr)
			{
				_root = new Node(key,val);
				return true;
			}

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

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


		Node* find(const Key& key)
		{
			if (_root == nullptr)
			{
				return nullptr;
			}

			Node* cur = _root;
			while (cur)
			{
				if (key < cur->_key)
				{
					cur = cur->_left;
				}
				else if (key > cur->_key)
				{
					cur = cur->_right;
				}
				else
				{
					// 找到了
					return cur;
				}
			}
			return nullptr;
		}


		bool erase(const Key& key)
		{
			if (_root == nullptr)
			{
				return false;
			}

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

						delete cur;
						return true;
					}

					else if (cur->_right == nullptr)
					{
						if (_root == cur)
						{
							_root = _root->_left;
						}
						else if (prev->_left == cur)
						{
							prev->_left = cur->_left;
						}
						else if (prev->_right == cur)
						{
							prev->_right = cur->_left;
						}

						delete cur;
						return true;
					}

					else
					{
						Node* prev = _root;
						Node* minRight = cur->_right;

						while (minRight->_left)
						{
							prev = minRight;
							minRight = minRight->_left;
						}

						cur->_key = minRight->_key;
						if (prev->_left == minRight)
						{
							prev->_left = minRight->_right;
						}
						else if (prev->_right == minRight)
						{
							prev->_right = minRight->_right;
						}

						delete minRight;
						return true;
					}
				}
			}
			return false;
		}


		void MidTraval()	
		{
			__MidTraval(_root);
			cout << endl;
		}

	private:
		Node* _root = nullptr;

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

			__MidTraval(root->_left);
			cout << root->_key << ":" << root->_val << endl;
			__MidTraval(root->_right);
		}
	};
}

第二步：算法实现：

void test_count()
{
	KV::BST<string, int> bt;
	string arr[] = { "苹果", "西瓜", "苹果", "西瓜", "苹果", "苹果", "西瓜",
"苹果", "香蕉", "苹果", "香蕉" };

	for (auto& e : arr)
	{
		KV::BST_node<string, int>* ret = bt.find(e);
		if (ret)	//不为空，证明数据结构已有
		{
			ret->_val++;	//次数++
		}
		else
		{
			bt.insert(e, 1);
		}
	}

	bt.MidTraval();
}

4.完整代码

 二叉搜索树

小龙向钱进
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
C++实现数据结构——二分搜索和二叉搜索树
m0_37433111的博客
08-25 146
2020年8月25日 周二 天气晴 【不悲叹过去，不荒废现在，不惧怕未来】 本文目录1. 引言2. 主文件——main.cpp3. BST类 .h文件——bstree.h4. 预编译头文件——stdafx.h参考文献 1. 引言 用C++实现了简单的二分搜索和二叉搜索树（BST）类，成员函数实现了BST和AVL树（高度平衡的BST）的创建，遍历，查找、删除指定结点等功能，主函数中有所有成员函数的测试案例。代码是用VS2019实现的，每个函数的功能都添加了一定注释，由于用了模板，函数的声明和定义都放在了
数据结构C++实现——二叉树
qq_22033751的博客
12-06 607
二叉树二叉树的定义 二叉树是结点的有限集合，该集合或者为空集，或者是由一个根和两棵互不相交的，称为该根的左子树和右子树的二叉树组成。 二叉树可以是空集，也可以有空的左子树和右子树的二叉树组成 树不能是空树，可以有空二叉树 二叉树的性质 二叉树的第i层（假设根是第0层）则最多有2i个结点 高度为h的二叉树至多2h个结点（根的高度为1） 任意一颗二叉树，若叶子结点的个数为n0，度为2的结点的个数为n2，
数据结构和算法学习记录——认识二叉搜索树及二叉搜索树的查找操作（递归以及迭代实现-查找操作、查找最大和最小元素）
li13437542099的博客
04-18 1097
如果二叉搜索树排成了一条链，即斜二叉树，他的这颗树的高度就为n-1，这样最坏的情况下要找到一个节点就需要n-1次了。函数的代码实现也没什么难点，按照思路，在递归的方法实现中（查找最小元素）：节点的左子树不为空就进行递归，直到某一个节点的左子树为空就返回。最小元素一定是在树的最左分枝的端节点上。但递归实现的方法效率不是很高，从编译的角度来看，尾递归可以用循环的方式来实现了。因为二叉搜索树的特殊性，比根节点小的在左子树，比根节点大的在右子树。如果x的值大于根节点，就将节点的指针指向右子树继续循环查找；
【C++详解】——搜索二叉树
weixin_69519040的博客
04-22 565
本文介绍了搜索二叉树的原理，并且模拟实现了一个搜索二叉树，其中插入、删除、查找功能分别使用了递归和非递归两种实现方式。本文还介绍了两种搜索二叉树的应用场景，根据相应的应用场景将搜索二叉树改造成了KV结构。 本文详细代码链接：https://gitee.com/hrimkn
C++ 之二叉搜索树
最新发布
qq_74732628的博客
04-24 557
详解c++ 二叉搜索树的实现以及功能
【C++】二叉搜索树
m0_62179366的博客
10-24 1948
二叉搜索树的简单应用及实现。
二叉查找树 减治法——C++代码
05-24
二叉查找树（Binary Search Tree，BST）是一种特殊的二叉树数据结构，它的每个节点都包含一个键（key）、一个关联的值、一个指向左子树的引用和一个指向右子树的引用。在二叉查找树中，对于任意节点，其左子树中的...
课程设计——二叉查找树
03-13
在这个“课程设计——二叉查找树”项目中，开发者创建了一个桌面应用程序，用于实现对二叉查找树的操作。用户可以通过界面进行交互，进行查找操作，同时能够直观地观察到操作的结果。这对于学习和理解二叉查找树的...
《数据结构——C++实现》（第二版）课本源代码
10-30
2. **高级数据结构实现**：例如二叉树（包括二叉搜索树、AVL树、红黑树等）、堆（最大堆和最小堆）、哈希表等。这些数据结构在实际应用中非常常见，如数据库索引、优先队列等。 3. **图数据结构**：包括邻接矩阵和...
数据结构——二叉树的实现.zip
09-18
这个压缩包文件"数据结构——二叉树的实现.zip"显然包含了关于二叉树实现的详细内容，特别是二叉链表和左子右兄弟两种不同的实现方法。 首先，我们来探讨二叉链表的实现。二叉链表是最基础的二叉树存储方式，每个...
数据结构（二叉平衡排序树）课程设计报告
10-25
二叉平衡排序树，顾名思义，是一种保持平衡的二叉搜索树。传统的二叉搜索树在插入和删除操作后可能会导致树的高度极度不平衡，从而影响查找效率。然而，二叉平衡排序树通过特定的结构调整策略，确保了树的左右子树...
C/C++数据结构（十）—— 二叉查找树
热门推荐
Edison's 小宇宙
01-13 2万+
二叉查找树（Binary Search Tree），也称二叉排序树或二叉搜索树。
C++的数据结构与算法(六)二叉树搜索算法学习
蒋成的博客
07-14 739
文章目录1.二分搜索树原理1.1 理论介绍1.2代码实现2.二分搜索树的节点插入3.二分搜索树的查找4.二分搜索树的遍历(深度优先遍历)5.层序遍历(广度优先遍历)6.删除最大值，最小值、删除节点7.二分搜索树的顺序性8.二分搜索树的顺序性9.二分搜索树的局限性 1.二分搜索树原理 1.1 理论介绍 同上篇文章介绍的二叉堆本质上类似，都是一个二叉树。选择什么特征的二叉树是根据具体问题来决定的，了解...
【C++ STL】-- 二叉搜索树
weixin_64609308的博客
11-25 2136
详细配图讲解：搜索二叉树的构建与函数接口实现
C++二叉搜索树BinarySearchTree
学习C++的小陈同学
11-03 125
本章介绍了搜索二叉树的特性，并且用C++模拟实现，详细分析了代码思路
C++——二叉树排序树
博主qq1077644249
02-18 1259
1 二叉搜索树概念 2 二叉搜索树操作与模拟实现 2.1 二叉搜索树的查找 非递归版本 递归版本 2.2 二叉搜索树的插入 非递归版本 递归版本 2.3 二叉搜索树的删除 非递归版本 递归版本 3 二叉搜索树的应用（K模型、KV模型） 4 二叉搜索树的性能分析
怎么用c++写一个二叉搜索树
05-26
以下是一个简单的 C++ 代码示例，用于实现二叉搜索树： ```cpp #include <iostream> using namespace std; // 定义二叉搜索树节点 struct BSTNode { int data; BSTNode* left; BSTNode* right; }; // 创建新节点 BSTNode* createNode(int value) { BSTNode* newNode = new BSTNode(); newNode->data = value; newNode->left = nullptr; newNode->right = nullptr; return newNode; } // 插入节点 BSTNode* insertNode(BSTNode* root, int value) { if (root == nullptr) { root = createNode(value); return root; } else if (value <= root->data) { root->left = insertNode(root->left, value); } else { root->right = insertNode(root->right, value); } return root; } // 查找节点 bool searchNode(BSTNode* root, int value) { if (root == nullptr) { return false; } if (root->data == value) { return true; } else if (value < root->data) { return searchNode(root->left, value); } else { return searchNode(root->right, value); } } // 打印二叉搜索树（中序遍历） void printTree(BSTNode* root) { if (root == nullptr) { return; } printTree(root->left); cout << root->data << " "; printTree(root->right); } int main() { // 创建根节点 BSTNode* root = nullptr; // 插入节点 root = insertNode(root, 8); root = insertNode(root, 3); root = insertNode(root, 10); root = insertNode(root, 1); root = insertNode(root, 6); root = insertNode(root, 14); root = insertNode(root, 4); root = insertNode(root, 7); root = insertNode(root, 13); // 打印二叉搜索树 cout << "二叉搜索树: "; printTree(root); cout << endl; // 查找节点 int value = 6; if (searchNode(root, value)) { cout << value << " 在二叉搜索树中" << endl; } else { cout << value << " 不在二叉搜索树中" << endl; } return 0; } ``` 以上代码创建了一个二叉搜索树，并实现了插入节点、查找节点和打印二叉搜索树等基本操作。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

小龙向钱进

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

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

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

打赏作者

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

抵扣说明：

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

余额充值