【二叉搜索树】

最新推荐文章于 2024-09-15 11:40:06 发布
最新推荐文章于 2024-09-15 11:40:06 发布
阅读量592 收藏 26
点赞数 26
分类专栏： C++ 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2302_79013877/article/details/141027412
版权

二叉搜索树

小杨

一、二叉搜索树的概念

二叉搜索树又称二叉排序树，他或者是一颗空树，或者是具有以下性质的二叉树：

  1. 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值。
  2. 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值。
  3. 它的左右子树也分别为二叉搜索树。

二叉搜索树(BST,Binary Search Tree)也称为二叉排序树或二叉查找树。
在这里插入图片描述

二、二叉搜索树操作

在这里插入图片描述

int arr={8,3,1,10,6,47,14,13};

1.二叉搜索树的查找
  1. 从根开始比较，查找，比根大则往右边走查找，比根小则往左边走查找。
  2. 最多查找高度次，走到空，如果还没找到，就证明这个值不存在。

e.g:比如说我要找9.
先与根节点8比较，比8大，就与8的右边(10)比较,比10小，就到10的左边比较，但是10的左边为空，就意味着没有这个值，就结束查找。
在这里插入图片描述

2.二叉搜索树的插入

插入的具体过程如下：

  1. 树为空，则直接新增节点，赋值给root指针。
  2. 树不为空，按二叉搜索树性质查找插入位置，插入新节点。

e.g:插入一个值为11的节点：
首先根节点8比11小，因此继续去跟8的右节点(10)比较，11比10大，因此根11的右节点14比较，11比14小，跟14的左节点13比较，11比13小，因此继续跟13的左节点比较，因为13的左节点为空，所以，11就插入在13的左边。
在这里插入图片描述
e.g:同理插入节点0
在这里插入图片描述

3.二叉搜索树的删除

首先查找元素是否在二叉搜索树中，如果不存在，则返回，否则要删除的节点可能分下面四种情况:

  1. 要删除的节点无孩子节点
  2. 要删除的节点只有左孩子节点
  3. 要删除的节点只有右孩子节点
  4. 要删除的节点有左、右孩子节点

看起来有待删除节点有4种情况，实际情况1可以与情况2或者3合并起来，因此真正的删除过程如下：

  1. 情况b:删除该节点且使被删除节点的双亲节点指向被删除节点的左孩子节点-直接删除
  2. 情况c:删除该节点且使被删除节点的双亲节点指向被删除节点的右孩子节点-直接删除
  3. 情况d:在它的右子树中寻找中序下的第一个节点(关键码最小)，或者找左子树寻找中序的最后一个节点(关键码最大)，用它的值填补到被删除节点中，再来处理该节点的删除问题-替换法删除

在这里插入图片描述
e.g:删除14节点
在这里插入图片描述
e.g:删除6节点
在这里插入图片描述
e.g:删除3节点：
在这里插入图片描述

三、二叉搜索树的实现

#pragma once

namespace yang
{
	//二叉搜索树节点
	template<class T>
	struct BSTNode
	{
		BSTNode(const T& data = T())
			:_pLeft(nullptr)
			,_pRight(nullptr)
			,_data(data)
		{}

		BSTNode<T>* _pLeft;
		BSTNode<T>* _pRight;
		T _data;
	};
	//二叉搜索树
	template<class T>
	class BSTree
	{
		//别名：类型名字
		typedef BSTNode<T> Node;

		//中序遍历
		void InOrder()
		{
			_InOrder(_root);
			cout << endl;
		}

		//析构函数
		~BSTree()
		{
			Destroy(_root);
			_root = nullptr;
		}

		//查找
		bool find(const T& data)
		{
			Node* cur = _root;

			while (cur)
			{
				if (cur->_data < data)
				{
					cur = cur->_pLeft;
				}
				else if (cur->_data == data)
				{
					cur = cur->_pRight;
				}
				else
				{
					return true;
				}
			}
			return false;

		}

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

			Node* curp = nullptr;
			Node* cur = _root;
			while (cur)
			{
				if (key > cur->_data)
				{
					curp = cur;
					cur = cur->_pRight;
				}
				else if (key < cur->_data)
				{
					curp = cur;
					cur = cur->_pLeft;
				}
				else
				{
					return false;
				}
				
			}

			cur = new Node(key);
			//看新建的节点是在curp的那一边
			if (curp->_date <cur)
			{
				curp->_pRight = cur;
			}
			else
			{
				curp->_pLeft = cur;
			}

		}

		//删除
		bool Erase(const K& key)
		{
			Node* curp = nullptr;
			Node* cur = _root;

			while (cur)
			{
				if (cur->_data < key)
				{
					curp = cur;
					cur = cur->_pRight;
				}
				else if (cur->_data > key)
				{
					curp = cur;
					cur = cur->_pLeft;
				}
				else//找到与key相等的值，开始执行删除
				{
					//一个孩子，但右孩子为空,只有左孩子
					if (cur->_pRight == nullptr)
					{
						//如果cur的父亲为空，那么意味着cur为父亲，删除，将cur目前的左变为根即可即可
						if (curp == nullptr) cur = cur->_pLeft;
						//否则看cur是curp的左还是右
						else
						{
							//如果curp的左为cur，那么就将curp的左指向cur的左，然后删除cur
							if (curp->_pLeft == cur)
							{
								curp->_pLeft = cur->_pLeft;
							}
							else
							{
								curp->_pRight = cur->_pLeft;
							}
						}

						//删除cur节点
						delete cur;
						return true;
					}
					//一个孩子，但左孩子为空,只有右孩子
					else if (cur->_pLeft == nullptr)
					{
						//如果cur的父亲为空，那么意味着cur为父亲，删除，将cur目前的右变为根即可即可
						if (curp == nullptr) cur = cur->_pRight;
						//否则看cur是curp的左还是右
						else
						{
							//如果curp的左为cur，那么就将curp的左指向cur的右，然后删除cur
							if (curp->_pLeft == cur)
							{
								curp->_pLeft = cur->_pRight;
							}
							else
							{
								curp->_pRight = cur->_pRight;
							}
						}

						delete cur;
						return true;
					}
					else
					{
						//两个孩子的情况
						Node* rightMinp = cur;给他为cur是为了防止不进入下面while而导致的空指针情况
						Node* rightMin = cur->_pRight;//这里给right的目的是因为我们找的是右子树最左边的，即右子树最小的数

						//然后走到右子树的最左节点
						while (rightMin->_pLeft)
						{
							rightMinp = rightMin;
							rightMin = rightMin->_pLeft;
						}

						//找人看孩子
						cur->_data = rightMin->_data;

						//走了循环的判断
						if (rightMinp->_pLeft == rightMin)
						{
							rightMinp->_pLeft = rightMin->_pRight;
						}
						else
							rightMinp->_pRight = rightMin->_pRight;

						//删除rightMin节点
						delete rightMin;
						return true;
					}

				}
			}
		}
		
	public:
		void _InOrder(Node* root)
		{
			if (root == nullptr) return;
			_InOrder(root->_pLeft);
			cout << root->_data << " ";
			_InOrder(root->_pRight);
		}

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

	private:
		Node* _root;
	};
}

四、二叉搜索树的应用

  1. K模型：K模型即只有key作为关键码，结构中只需要存储Key即可，关键码即为需要搜索到的值。
    比如：给一个单词word，判断该单词是否拼写正确，具体方式如下：
    以词库中所有单词集合中的每个单词作为key，构建一棵二叉搜索树在二叉搜索树中检索该单词是否存在，存在则拼写正确，不存在则拼写错误。
  2. KV模型：每一个关键码key，都有与之对应的值Value，即<Key, Value>的键值对。该种方式在现实生活中非常常见：
    比如英汉词典就是英文与中文的对应关系，通过英文可以快速找到与其对应的中文，英文单词与其对应的中文<word, chinese>就构成一种键值对；再比如统计单词次数，统计成功后，给定单词就可快速找到其出现的次数，单词与其出现次数就是<word, count>就构成一种键值对。
//kv接口二叉搜索住
template<class K,class V>
struct BSTNode
{
	K _key;
	V _value;
	BSTNode<K,V>* _left;
	BSTNode<K,V>* _right;

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

template<class K, class V>
class BSTree
{
	typedef BSTNode<K,V> Node;

public:
	BSTree() = default; 

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

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

		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
			{
				return false;
			}
		}

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


	Node* 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 cur;
			}
		}
		return nullptr;
	}


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

	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
			{
				//erase
				//一个孩子时，但左孩子为空
				if (cur->_left == nullptr)
				{
					//判断父亲节点是否存在
					//若不存在就只动_root就好
					if (parent == nullptr)
						_root = cur->_right;
					else
					{
						//判断cur是否是parent的左右孩子
						//若是左孩子，就parent左对应cur的右
						//若是右孩子，就parent左对应cur的右
						if (parent->_left == cur)
						{
							parent->_left = cur->_right;
						}
						else
						{
							parent->_right = cur->_right;
						}
					}
					delete cur;
					return true;
				}
				else if (cur->_right == nullptr)//一个孩子时，但右孩子为空
				{
					//判断父亲节点是否存在
					//若不存在就只动_root就好
					if (parent == nullptr)
						_root = cur->_left;
					else
					{
						//判断cur是否是parent的左右孩子
						//若是左孩子，就parent左对应cur的左
						//若是右孩子，就parent左对应cur的左

						if (parent->_left == cur)
						{
							parent->_left = cur->_left;
						}
						else
						{
							parent->_right = cur->_left;
						}
					}
					delete cur;
					return true;
				}
				else
				{
					//2个孩子的情况
					Node* rightMinP = cur;//给他为cur是为了防止不进入下面while而导致的空指针情况
					Node* rightMin = cur->_right;//这里给right的目的是因为我们找的是右子树最左边的，即右子树最小的数
					while (rightMin->_left)
					{
						rightMinP = rightMin;
						rightMin = rightMin->_left;
					}
					//找人看孩子
					cur->_key = rightMin->_key;

					//走这个循环后的判断
					if (rightMinP->_left == rightMin)
						rightMinP->_left = rightMin->_right;
					else//不走这个循环的判断
						rightMinP->_right = rightMin->_right;

					delete rightMin;
					return true;
				}

			}
		}
		return false;
	}
private:
	void _InOrder(Node* root)
	{
		if (root == nullptr)
			return;

		_InOrder(root->_left);
		cout << root->_key << ":"<<root->_value<<endl;
		_InOrder(root->_right);
	}

	void Destroy(Node* root)
	{
		if (root == nullptr)
			return;
		Destroy(root->_left);
		Destroy(root->_right);
		delete 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;
	}
private:
	Node* _root = nullptr;
};

kv结构二叉搜索树的几个测试用例：

void TestBSTree1()
{
 // 输入单词，查找单词对应的中文翻译
 BSTree<string, string> dict;
 dict.Insert("string", "字符串");
 dict.Insert("tree", "树");
 dict.Insert("left", "左边、剩余");
 dict.Insert("right", "右边");
 dict.Insert("sort", "排序");
 // 插入词库中所有单词
 string str;
 while (cin>>str)
 {
 BSTreeNode<string, string>* ret = dict.Find(str);
 if (ret == nullptr)
 {
 cout << "单词拼写错误，词库中没有这个单词:" <<str <<endl;
 }
 else
 {
 cout << str << "中文翻译:" << ret->_value << endl;
 }
 }
}
void TestBSTree2()
{
 // 统计水果出现的次数
 string arr[] = { "苹果", "西瓜", "苹果", "西瓜", "苹果", "苹果", "西瓜", 
"苹果", "香蕉", "苹果", "香蕉" };
 BSTree<string, int> countTree;
 for (const auto& str : arr)
 {
 // 先查找水果在不在搜索树中
 // 1、不在，说明水果第一次出现，则插入<水果, 1>
 // 2、在，则查找到的节点中水果对应的次数++
 //BSTreeNode<string, int>* ret = countTree.Find(str);
 auto ret = countTree.Find(str);
 if (ret == NULL)
 {
 countTree.Insert(str, 1);
 }
 else
 {
 ret->_value++;
 }
 }
 countTree.InOrder();
}

五、二叉搜索树的性能分析

插入和删除操作都必须先查找，查找效率代表了二叉搜索树中各个操作的性能。
对有n个结点的二叉搜索树，若每个元素查找的概率相等，则二叉搜索树平均查找长度是结点在二叉搜索树的深度的函数，即结点越深，则比较次数越多。
但对于同一个关键码集合，如果各关键码插入的次序不同，可能得到不同结构的二叉搜索树：

在这里插入图片描述
最优情况下，二叉搜索树为完全二叉树(或者接近完全二叉树)，其平均比较次数为：logN
最差情况下，二叉搜索树退化为单支树(或者类似单支)，其平均比较次数为：N.

问题：如果退化成单支树，二叉搜索树的性能就失去了。那能否进行改进，不论按照什么次序插入关键码，二叉搜索树的性能都能达到最优？那就需要引入AVL树和红黑树了。

砖筑
关注
专栏目录
二叉搜索树
CCPP Blog
07-05 4113
定义 二叉搜索树(Binary Search Tree)或称二叉查找树，也称二叉排序树(Binary Sort Tree)。它或者是一棵空树，或者是具有下列性质的二叉树： 若左子树不空，则左子树上所有节点的值均小于它的根节点的值； 若右子树不空，则右子树上所有节点的值均大于它的根节点的值； 左、右子树也分别为二叉搜索树； 性质 二叉搜索树与普通二叉树相比，有一些优秀的特征或性质： 由于节点是有序排放的：左子树<根节点<右子树。故在查找一个节点的时候，只需先和根节点比较，再决定是进入左子树还是右子树查找。而
二叉排序树（二叉查找树、二叉搜索树）（图解+完整代码）
热门推荐
weixin_54186646的博客
04-25 8万+
图解二叉排序树（二叉查找树、二叉搜索树）的插入操作、查找操作、删除操作以及完整的代码实现
【二叉搜索树】二叉搜索树的用法以及实现
m0_68617301的博客
04-28 1158
二叉搜索树的用法以及实现
Java创建二叉搜索树,实现搜索,插入,删除的操作实例
08-28
Java 创建二叉搜索树、实现搜索、插入、删除的操作实例 Java 创建二叉搜索树是指通过 Java 语言实现一个二叉搜索树数据结构，该树具有查找、插入、删除等操作的功能。二叉搜索树是一种特殊的二叉树，每个节点的值...
树-98. 验证二叉搜索树-PYTHON
01-20
在二叉搜索树（Binary Search Tree，BST）中，每个节点的值必须满足以下规则：对于任意节点，其左子树中的所有节点的值都小于该节点的值，而其右子树中的所有节点的值都大于该节点的值。在给定的题目“树-98. 验证...
c代码-二叉搜索树的删除操作
07-14
在IT领域，二叉搜索树（Binary Search Tree，简称BST）是一种常见的数据结构，它具有很多优秀的特性，比如快速的查找、插入和删除操作。在实际应用中，我们经常需要对BST进行各种操作，其中删除操作是相对复杂的一个...
Python实现二叉搜索树BST的方法示例
09-18
二叉搜索树（BST，Binary Search Tree），又称为二叉查找树或二叉排序树，是一种特殊的二叉树数据结构，其每个节点的值满足以下条件： 1. 节点的左子树中所有节点的值都小于该节点的值。 2. 节点的右子树中所有节点...
C++ STL中sort函数
最新发布
weixin_43349440的博客
09-15 166
刷题中经常遇到，用于各种元素排序，可以自定义排序方式，vector、deque适用。详细讲解：https://zhuanlan.zhihu.com/p/36274119。，为避免QuickSort快排的递归调用带来过大的额外负荷，就改用。一旦分段后的数据量小于某个门槛。STL的sort算法，
C++与QML的数据交互
qq_50679120的博客
09-11 512
这里没什么好说的，在C++中组合好json后，通过信号发送到qml中，qml中是可以解析json的。通过Q_PROPERTY属性，可以轻松地在QML中读取和修改数据，并将其更新到C++中，先创建一个类。在QML接收，直接通过data.can_id这样的形式去访问结构体中的元素。这两个也没什么好说的，在C++中直接发送信号就好了，在C++中声明并注册一个结构体。然后发送信号到QML中。
CF C. Nikita and LCM
qq_74190237的博客
09-13 258
思维题.首先先对数组排序,考虑一种特殊情况,那就是如果数组最大值不能被其他数整除,这代表什么?代表其他数里面有某个质因子,最大值里面没有或者数量不管,所有最小公倍数都会大于最大值.那么其他情况的话,就可以确定所有的数都是最大数的因子,那么形成的最小公倍数也一定是最大数的因子,那么就可以枚举一下最大数的因子,就可以了.给长度为n的数组,求出最长的特殊子数组,如果子数组的最小公倍数不在原数组中,那么就是特殊的.
C和指针：标准函数库
暮色年华的博客
09-11 675
longjmp 函数:一旦在程序的其他部分遇到了 longjmp 调用，并且传入了之前 setjmp 初始化的 jmp_buf 数组以及一个非零值作为跳转值，那么程序的控制就会立即跳回到与那个 jmp_buf 关联的 setjmp 处。setjmp 函数：一个函数中调用 setjmp 并传递一个类型为 jmp_buf 的数组作为参数时，setjmp 将会保存当前程序执行环境的一个快照（包括处理器寄存器和程序计数器等状态信息）到这个 jmp_buf 数组中。如果在某个低层的函数中检测到一个错误，你可以立。
C语言从头学59——学习头文件math.h（二）
m0_72128260的博客
09-11 467
继续学习头文件的数学函数。
＜C++＞ set、map模拟实现
prodigy623的博客
09-10 904
set、map仿STL模拟实现
【C++ && Qt day11】
wzj46的博客
09-11 273
2、头文件窗口文件。
C++ Qt开发：运用QJSON模块解析数据
qq_35662333的博客
09-11 1059
转载Qt 是一个跨平台C++图形界面开发库，利用Qt可以快速开发跨平台窗体应用程序，在Qt中我们可以通过拖拽的方式将不同组件放到指定的位置，实现图形化开发极大的方便了开发效率，本章将重点介绍如何运用QJson组件的实现对JSON文本的灵活解析功能。JSON（JavaScript Object Notation）是一种轻量级的数据交换格式，它易于人阅读和编写，也易于机器解析和生成。该格式是基于JavaScript语言的一个子集，但它是一种独立于语言的数据格式，因此可以在许多不同的编程语言中使用。
C++ lambda闭包消除类成员变量
随手写下笔记和感悟
09-11 450
消除了——通过将它们闭包到lambda表达式中，然后将这个lambda存起来重复使用。如果用引用捕获，栈变量会释放导致非法访存；可以借助函数式编程思想，来消除一些不必要的类成员变量。拿到一个类，一看成员变量好几十个，就问你怕不怕？在面向对象编程时，常常要添加类成员变量。然而类成员一旦多了之后，也会带来干扰。就无法修改值捕获的变量。
C++（二）----类和对象
weixin_73579966的博客
09-11 798
众所周知，C++与C语言不同的地方就是，C++引入了类和对象，可以在兼容C语言的同时面向对象编程，同时具备了封装、继承、多态三种特点（划重点）。面向对象可以说是C++最重要的部分了，而类和对象就是面向对象的基础，所以这一节我们学习类和对象。
二叉搜索树详解及C++实现
"这篇资源提供了一份二叉搜索树的源码实现，包括基本操作如查找最小值、最大值、插入、删除以及不同顺序的遍历。" 二叉搜索树（Binary Search Tree，简称BST），是一种特殊的二叉树，每个节点的左子树只包含比它小...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值