c++:二叉搜索树BinarySortTree

最新推荐文章于 2024-07-31 17:03:28 发布
最新推荐文章于 2024-07-31 17:03:28 发布
阅读量277 收藏
点赞数 5
文章标签： 二叉树 数据结构 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43745617/article/details/116736216
版权

文章目录

二叉搜索树BinarySortTree

1.二叉搜索树概念

二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树:
若它的左子树不为空，则左子树上所有节点的值都小于根节点的值
若它的右子树不为空，则右子树上所有节点的值都大于根节点的值

它的左右子树也分别为二叉搜索树
如图所示
在这里插入图片描述

二叉搜索树最大的功能便是搜索；一般来讲它比顺序表以链表的搜索时间复杂度要低；但是在极端条件下，它和顺序表、链表的时间复杂度相同。
当是满二叉树时，若搜索一个值，最多只需要二叉树的层数次；时间复杂度O(logN)。
在这里插入图片描述
当二叉树为下图结构时，若找“9”，便要遍历所有节点，时间复杂度最大，为O(N)。
在这里插入图片描述

2.二叉搜索树操作

（1）查找

在这里插入图片描述

（2）插入节点

插入的具体过程如下：
a. 树为空，则直接插入
在这里插入图片描述
b. 树不空，按二叉搜索树性质查找插入位置，插入新节点
从根节点开始，若插入的值小于根节点，便让根节点的左孩子成为新的父亲；若插入的值大于根节点，便让根节点的右孩子成为新的父亲；以此类推，直到正确的插入数据。
在这里插入图片描述

（3）删除节点

首先查找元素是否在二叉搜索树中，如果不存在，则返回, 否则要删除的结点可能分下面四种情况：
a. 要删除的结点无孩子结点：删除后使其父亲节点指向nullptr；
b. 要删除的结点只有左孩子结点：删除后使其父亲结点指向其右孩子结点；
c. 要删除的结点只有右孩子结点：删除后使其父亲结点指向其左孩子结点；
d. 要删除的结点有左、右孩子结点：在它的右子树中寻找中序下的第一个结点(关键码最小)，用它的值填补到被删除节点中;然后对右子树中序下的第一个结点进行删除。
看起来有待删除节点有4中情况，实际情况a可以与情况b或者c合并起来，因此真正的删除过程如下：

3.二叉搜索树的代码实现

（1）功能实现

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

template<class K>
struct BSTNode 
{
	K _key;//所存储的数据
	struct BSTNode<K>* _left;
	struct BSTNode<K>* _right;
	BSTNode(const K& key)
		:_key(key)
		,_left(nullptr)
		,_right(nullptr)
	{}
};

template<class K>
class BSTree
{
	typedef BSTNode<K> Node;
private:
	Node* _root = nullptr;
public:
	//遍历
	void InOrder(Node* root)
	{
		if (root == nullptr)
		{
			return;
		}
		//中序遍历
		InOrder(root->_left);
		cout << root->_key << " ";
		InOrder(root->_right);
	}
	//重载一个无参函数，方便接口使用
	void InOrder()
	{
		InOrder(_root); 
		cout << endl;
	}
	//插入
	bool Insert(const K& key)
	{
		if (_root == nullptr)
		{
			_root = new Node(key);
		}
		Node* cur = _root;
		Node* parent = nullptr;
		while (cur)
		{
			parent = cur;
			if (key > cur->_key)
			{
				cur = cur->_right;
			}
			else if (key < cur->_key)
			{
				cur = cur->_left;
			}
			else
			{
				return false;
			}
		}
		cur = new Node(key);
		if (key > parent->_key)
		{
			parent->_right = cur;
		}
		else 
		{
			parent->_left = cur;
		}
	}
	//查找
	Node* Find(const K& key)
	{
		cout << "WANT FIND:" << key << endl;
		Node* cur = _root;
		while (cur)
		{
			if (key > cur->_key)
			{
				cur = cur->_right;
			}
			else if (key < cur->_key)
			{
				cur = cur->_left;
			}
			else
			{
				return cur;
			}
		}
		cout << "NOT FIND" << endl;
		return nullptr;
	}
	//删除节点
	bool Erase(const K& key)
	{
		cout << "ERASE:" << key << endl;
		Node* parent = nullptr;
		Node* cur = _root;
		while (cur)
		{
			if (key > cur->_key)
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (key < cur->_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;
					}
					delete cur;
				}
				else if (cur->_right == nullptr)
				{
					if (cur == _root)
						_root = cur->_left;
					else
					{
						if (cur == parent->_left)
							parent->_left = cur->_left;
						else
							parent->_right = cur->_left;
					}
					delete cur;
				}
				else
				{
					//subMin的父亲节点
					Node* subMinParent = cur;
					//右子树中寻找中序下的第一个节点subMin
					Node* subMin = cur->_right;
					while (subMin->_left)
					{
						subMinParent = subMin;
						subMin = subMin->_right;
					}
					cur->_key = subMin->_key;
					//subMin左孩子一定为空
					//考虑subMinParent可能为要删除的节点
					if (subMin == subMinParent->_left)
					{
						subMinParent->_left = subMin->_right;
					}
					else
					{
						subMinParent->_right = subMin->_right;
					}
					delete subMin;
				}
				return true;
			}
		}
		cout << "ERASE ERROR" << endl;
		return false;
	}
};

（2）测试

#include "BSTree.h"
using namespace std;
void BSTreeTest1()
{
	//插入节点
	BSTree<int> i;
	i.Insert(5);
	i.Insert(6);
	i.Insert(7);
	i.Insert(8);
	i.Insert(4);
	i.Insert(3);
	i.Insert(2);
	i.Insert(1);
	i.Insert(9);
	i.InOrder();
	cout << endl;
	//寻找节点
	BSTNode<int>* ret1 = i.Find(6);
	if (ret1)
	{
		cout << "FIND IT!" << endl;
	}
	BSTNode<int>* ret2 = i.Find(0);
	if (ret2)
	{
		cout << "FIND IT!" << endl;
	}
	cout << endl;

	//删除节点
	i.Erase(0);
	i.Erase(5);
	i.Erase(1);
	i.Erase(9);
	i.InOrder();
}

int main()
{
	BSTreeTest1();
	return 0;
}

运行截图
在这里插入图片描述

2.4 二叉搜索树的应用

1. K模型

即为上述代码所实现的模型

功能：
a.查找在不在；
b.排序&&去重

K模型即只有Key作为关键码;节点结构中只需要存储Key即可，Key即为需要搜索到的值。
比如：给一个单词word，判断该单词是否拼写正确，具体方式如下：
以单词集合中的每个单词作为key，构建一棵二叉搜索树在二叉搜索树中检索该单词是否存在，存在则拼写正确，不存在则拼写错误。

2. KV模型

每一个关键码key，都有与之对应的值Value;即<Key, Value>的键值对。

功能：
a.查找在不在；
b.排序&&去重
c.通过key查找value：比如字典
d.统计次数

比如英汉词典就是英文与中文的对应关系，通过英文可以快速找到与其对应的中文，英文单词与其对应的中文<word, chinese>就构成一种键值对。

实现一个简单的英汉词典dict，可以通过英文找到与其对应的中文，具体实现方式如下：
<word, chinese>为键值对构造二叉搜索树，查询英文单词时，只需给出英文单词，就可快速找到与其对应的中文。

3.KV模型的代码实现

代码逻辑完全相同，只需要添加一个新的值value，与key形成键值对

（1）功能实现
#pragma once
#pragma once
#include<iostream>
#include<vector>
using namespace std;

template<class K, class V>
struct BSTNodeKV
{
	const K _key;//所存储的数据
	V _value;
	struct BSTNodeKV<K, V>* _left;
	struct BSTNodeKV<K, V>* _right;
	BSTNodeKV(const K& key, const V& value)
		:_key(key)
		, _value(value)
		, _left(nullptr)
		, _right(nullptr)
	{}
};

template<class K, class V>
class BSTreeKV
{
	typedef BSTNodeKV<K, V> Node;
private:
	Node* _root = nullptr;
public:
	//遍历
	void InOrder(Node* root)
	{
		if (root == nullptr)
		{
			return;
		}
		//中序遍历
		InOrder(root->_left);
		cout << root->_key << ":"<<root->_value<<" ";
		InOrder(root->_right);
	}
	//重载一个无参函数，方便接口使用
	void InOrder()
	{
		InOrder(_root);
		cout << endl;
	}
	//插入
	bool Insert(const K& key, const V& value)
	{
		if (_root == nullptr)
		{
			_root = new Node(key, value);
		}
		Node* cur = _root;
		Node* parent = nullptr;
		while (cur)
		{
			parent = cur;
			if (key > cur->_key)
			{
				cur = cur->_right;
			}
			else if (key < cur->_key)
			{
				cur = cur->_left;
			}
			else
			{
				return false;
			}
		}
		cur = new Node(key, value);
		if (key > parent->_key)
		{
			parent->_right = cur;
		}
		else
		{
			parent->_left = cur;
		}
	}
	//查找
	Node* Find(const K& key, const V& value)
	{
		//cout << "WANT FIND:" << key << endl;
		Node* cur = _root;
		while (cur)
		{
			if (key > cur->_key)
			{
				cur = cur->_right;
			}
			else if (key < cur->_key)
			{
				cur = cur->_left;
			}
			else
			{
				return cur;
			}
		}
		//cout << "NOT FIND" << endl;
		return nullptr;
	}
	//删除节点
	bool Erase(const K& key, const V& value)
	{
		cout << "ERASE:" << key << endl;
		Node* parent = nullptr;
		Node* cur = _root;
		while (cur)
		{
			if (key > cur->_key)
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (key < cur->_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;
					}
					delete cur;
				}
				else if (cur->_right == nullptr)
				{
					if (cur == _root)
						_root = cur->_left;
					else
					{
						if (cur == parent->_left)
							parent->_left = cur->_left;
						else
							parent->_right = cur->_left;
					}
					delete cur;
				}
				else
				{
					//subMin的父亲节点
					Node* subMinParent = cur;
					//右子树中寻找中序下的第一个节点subMin
					Node* subMin = cur->_right;
					while (subMin->_left)
					{
						subMinParent = subMin;
						subMin = subMin->_right;
					}
					cur->_key = subMin->_key;
					//subMin左孩子一定为空
					//考虑subMinParent可能为要删除的节点
					if (subMin == subMinParent->_left)
					{
						subMinParent->_left = subMin->_right;
					}
					else
					{
						subMinParent->_right = subMin->_right;
					}
					delete subMin;
				}
				return true;
			}
		}
		cout << "ERASE ERROR" << endl;
		return false;
	}
	//通过key来找value
	V FindValue(const K& key)
	{
		cout << "WANT FIND:" << key <<":";
		Node* cur = _root;
		while (cur)
		{
			if (key > cur->_key)
			{
				cur = cur->_right;
			}
			else if (key < cur->_key)
			{
				cur = cur->_left;
			}
			else
			{
				return cur->_value;
			}
		}
		cout << "NOT FIND" << endl;
		exit(1);
	}
};

void BSTreeKVTest()
{
	BSTreeKV<string, string> dict;
	dict.Insert("banana", "香蕉");
	dict.Insert("ciname", "电影");
	dict.Insert("apple", "苹果");
	dict.Insert("dog", "狗");
	dict.Insert("string", "字符串");
	dict.Insert("sort", "排序");
	dict.InOrder();
	
	cout << dict.FindValue("sort") << endl;
	cout << dict.FindValue("dog") << endl;
	cout << dict.FindValue("aaaa") <<endl;
}
int main()
{
	/*BSTreeTest();
	cout << endl << endl << endl;*/
	BSTreeKVTest();
	return 0;
}
（2）测试
void BSTreeKVTest()
{
	//*******************************************************
	//插入与遍历
	BSTreeKV<string, string> dict;
	dict.Insert("banana", "香蕉");
	dict.Insert("ciname", "电影");
	dict.Insert("apple", "苹果");
	dict.Insert("dog", "狗");
	dict.Insert("string", "字符串");
	dict.Insert("sort", "排序");
	dict.InOrder();
	//*******************************************************
	//通过key寻找value
	cout << dict.FindValue("sort") << endl;
	cout << dict.FindValue("dog") << endl;
	cout << dict.FindValue("aaaa") <<endl;
	
	//********************************************************
	//计数功能
	string strArr[] = { "Aa","Aa" ,"Aa" ,"Bb","Bb" ,"Cc" };
	BSTreeKV<string, int>countTree;
	for (auto& str : strArr)
	{
		auto ret = countTree.Find(str);
		if (ret == nullptr)
		{
			countTree.Insert(str, 1);
		}
		else
		{
			ret->_value++;
		}
	}
	countTree.InOrder();
}
int main()
{
	/*BSTreeTest();
	cout << endl << endl << endl;*/
	BSTreeKVTest();
	return 0;
}

运行截图
在这里插入图片描述
在这里插入图片描述

mbf330
关注
  • 5
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
C++——二叉查找树的创建与查找
Wannna的博客
11-22 848
二叉排序、查找树： 1、用随机函数生成10个待排序元素； 2、利用二叉查找树输出升序序列； 3、利用同一棵二叉查找树输出降序序列； 4、写出查找的递归函数； #include<iostream> #include<ctime> using namespace std; typedef int ElemType; typedef struct BinarySortTreeN...
数据结构实验——二叉排序树的插入和删除算法
qq_54146731的博客
10-17 133
创建新的BinTreeNode类的指针p指向新插入的结点，如果通过IsEmpty()判断目前是空二叉树，则新插入的结点就为根结点，如果不是则判断e与插入结点处双亲结点的data大小，如果e较小，则将结点指针赋给f的左孩子指针域，否则赋给f的右孩子指针域。因此，在插入之前，首先在二叉排序树中检查待插入的数据元素，如果查找成功，说明树中已经存在这个数据元素，则不再插入:如果查找不成功，说明树中不存在关键字等于给定值的数据元素。①选择功能2，删除有左右孩子的结点87，并显示查找该元素的过程（前驱为81）
C++：二叉搜索树的剖析
AngelDg的博客
04-27 151
二叉搜索树二叉搜索树的概念二叉搜索树操作二叉搜索树的查找二叉搜索树的插入二叉搜索树的删除二叉搜索树的模拟实现二叉数的性能分析 前面对map/multimap/set/multiset进行了简单的介绍，在其文档介绍中发现，这几个容器有个共同点是:其底层都是按照二叉搜索树来实现的。那什么是二叉搜索树?其底层是二叉搜索树吗? 二叉搜索树的概念 二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下...
第1关：二叉排序树的创建
qq_67906475的博客
11-21 362
第1关：二叉排序树的创建
C++二叉搜索树
L_Kingming的博客
12-04 204
概念 二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树: 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值 它的左右子树也分别为二叉搜索树 二叉搜索树的查找 过程如图: 主体框架代码: #include <vector> #include <stack>...
二叉排序树Binary sort tree（BST）
热门推荐
xiaobai_hellow的博客
03-06 1万+
二叉搜索树（BST）1.二叉搜索树的概念2.二叉搜索树的操作及应用3.二叉搜索树的模拟实现 1.二叉搜索树的概念 二叉排序数也叫二叉搜索树，有以下特点： ①：二叉搜索树的左节点永远小于父节点。 ②：二叉搜索树的右节点永远大于父节点。 ③：它的左右子树也分别为二叉搜索树 2.二叉搜索树的操作及应用 二叉搜索树本质还是二叉树，只是对节点各种需求有了不同的方式。 1.名字叫二叉搜索树，那么其查找方式肯定很棒 由于它的特点，当树不为空的时候，我们只需要去比较要搜索的值与各个节点的值，如果大于该节点，那么就在该节点的
C++ 不知树系列之二叉排序树（递归和非递归遍历、删除、插入……）
y6123236的专栏
11-04 1436
本文讲解了什么是二叉排序树，并深入地探讨在二叉排序树如何进行数据的插入、遍历、删除……
二叉搜索树的算法实现
木子皿--啥都不会的菜鸟
04-24 545
文章目录1 二叉搜索树简介2 二叉搜索树的算法实现2.1 节点结构体的定义2.2 二叉搜索树插入节点 1 二叉搜索树简介 当我们要在一组数中要找到 26？你该怎么找？ 答案： 从左至右 或 从右至左遍历一次，找到这个数字。 当我们把数据进行排序（按照从小到大的顺序排列）后，再查找相应的这条记录？还是用上面的方法吗？ 答案：最快的方式，是采用折半法（俗称二分查找）。 **思考：**当我们有新的数...
二叉排序树 c++
小liu向bei的博客
12-21 173
//二叉排序树* #include //节点 struct BiTNode { int date; BiTNode* lchild; BiTNode* rchild; }; typedef BiTNode* BiTree; //查找 bool SearchBST (BiTree T,int key,BiTree f,BiTree& p) { if(!T) { p=f; return false; } else if(T->date==key) { p=T; return true; } els
2024.7.24 作业
qq_64434282的博客
07-24 2509
【代码】2024.7.24 作业。
嵌入式初学-C语言-七
MaBaB的博客
07-29 523
分支结构 分支结构：又被称之为选择结构 概念 选择结构：根据条件成立与否，选择相应的操作。
背单词工具(C++)
zeyeqianli的博客
07-24 3949
【代码】背单词工具(C++)
C++的STL简介（一）
2302_81171591的博客
07-23 1596
STL（standarf template libaray-标准模板库）：是C++标准库的重要组成部分，不仅是一个可复用的组件库，而且是一个包罗数据结构与算法的软件框架。
C++红黑树
杀意感知的博客
07-25 1063
AVL树：严格平衡（左右子树高度差不超过 1），所以 AVL 树的查找、插入、删除效率高：O(logN)，但在插入和删除节点后，要维持树的平衡状态，做的旋转处理还是很多的。红黑树：近似平衡（控制最长路径不超过最短路径的2倍），变了一种方式来控制树的平衡，相较于 AVL 树而言，没有那么严格。红黑树更多是一种折中的选择，它舍弃平衡二叉树的严格平衡，换取节点插入时尽可能少的调整。因为红黑树的旋转情况少于 AVL 树，使得红黑树整体性能略优于。
C：图案打印
2401_85010100的博客
07-23 1224
空心正方形，空心三角形，X形，沙漏图案打印
C++_string_知识总结（初学）
最新发布
2301_81200576的博客
07-31 824
因为string特殊的物理结构，可以简单地认为，迭代器就是指针。而实际上迭代器是一种封装的思想，使用者不用花太多心思在如何根据需要访问数据上，只需要延续使用指针的传统，从而达到了简化的作用。begin()、end()一组左闭右开的区间，end()指向的是最后一个字符的下一个位置。范围for遍历的底层其实还是迭代器，在模拟实现中，实现好迭代器后，范围for的写法立即生效。同时注意不用对ch++或者解引用。+=运算符重载时reserve不再以二倍来扩容，因为要插入的字符串太大时，两倍有可能达不到。
项目实战——外挂开发（30小时精通C++和外挂实战）
qq_44870829的博客
07-25 2473
全局指针变量g_data的地址值是固定死的，它存储的是gamedata的地址，我们可以通过这个找到g_data的存储空间里存储的地址（new出来的是变化的），就能找到gamedata的存储空间，找到了gamedata的存储空间就能找到成员变量sun指针（跳过前面4个字节地址）变量的存储空间，知道它里面存储的值（阳光存储空间的地址值）就能找到阳光存储空间，就能找到阳光存储空间中的阳光值value（跳过前面8个字节地址）。这样就达到了秒杀僵尸的功能了，我们发现第一个字节都是一样的，我们改后面三个字节就可以了。
C/C++基础知识
m0_67582670的博客
07-24 2245
3.signed char：有符号char（-128~127）2.unsigned char：无符号char（0~255）3.动态分配内存(malloc和new)1.静态分配，编译时在栈上分配好内存。4.自动分配，在局部函数中。1.char：标准类型。
C++最佳实践：二叉搜索树详解
"C++最佳实践——二叉搜索树" 在C++编程中，遵循最佳实践是提高代码质量、可读性和效率的关键。二叉搜索树（Binary Search Tree, BST）是一种特殊的二叉树，其每个节点都具有BST属性：对于任意两个节点x和y，如果y...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值