C++之搜索二叉树

最新推荐文章于 2023-06-16 10:18:51 发布
最新推荐文章于 2023-06-16 10:18:51 发布
阅读量918 收藏 2
点赞数 3
分类专栏： C++知识系列 文章标签： c++ 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xjjxjy_2021/article/details/129941643
版权

文章目录

前言

本文介绍了二叉搜索树的相关概念，主要介绍了如何使用和实现搜索二叉树以及搜索二叉树具体的例题练习。

一、二叉搜索树概念

二叉搜索树也称为二叉排序树。
二叉树有以下性质：
1.空树是二叉搜索树；
2.二叉搜索树的非空左子树的所有节点小于根节点的值；
3.二叉搜索树的非空右子树的所有节点大于根节点的值；
4.二叉搜索树的左右子树也是二叉搜索树。

二、二叉搜索树操作

1.增

  1. 树为空，直接新增节点，赋值给root指针；
  2. 树不为空，根据二叉树的性质查找插入位置，插入新节点。

2.删

  1. 查找该节点是否在树中，如果不在则不进行操作；
  2. 如果在树中，则要删除该节点，分以下四种情况：
    a.无孩子，则直接删除该节点；
    b.要删除的节点无左孩子，则删除该节点，同时让该节点的父节点指向该节点的右孩子；
    c.要删除的节点无右孩子，则删除该节点，同时让该节点的父节点指向该节点的左孩子；
    d.左右孩子都有，则让该节点的右孩子的最左节点（右孩子的最小孩子）赋值给该节点，然后在右子树中删除最左节点即可。（替换删除法）
    在这里插入图片描述

3.查

  1. 从根节点出发，比根节点的值大的去它的右子树找，比根节点小的去它的左子树找；
  2. 最多查找高度次（二叉树的高度），如果走到空还没找到，说明该树没有这个值。

搜索二叉树不支持修改。

三、二叉搜索树实现

1.查

		pnode Find(K k)//查
		{
			pnode cur = _pnode;
			while (cur)
			{
				if (cur->_k > k)
				{
					cur = cur->left;
				}
				else if (cur->_k < k)
				{
					cur = cur->right;
				}
				else
				{
					return cur;
				}
			}
			return cur;
		}

2.增

		bool insert(K k)//增
		{
			pnode newnode = new node(k);
			//如果该树没有节点就直接插入新节点为根节点
			if (_pnode == nullptr)
			{
				_pnode = newnode;
				return true;
			}
			pnode cur = _pnode;
			pnode parent = cur;//记录当前节点的父节点，因为如果要插入就要插入在当前节点的父节点的左右孩子处
			while (cur)
			{
				parent = cur;
				if (cur->_k > k)
				{
					cur = cur->_left;
				}
				else if (cur->_k < k)
				{
					cur = cur->_right;
				}
				else//如果该节点已经在树中存在就插入失败
				{
					return false;
				}
			}
			//插入元素
			if (parent->_k > k) parent->_left = newnode;
			else parent->_right = newnode;
			return true;
		}

3.删

		bool erase(K k)//删
		{
			//树为空删除失败
			if (_pnode == nullptr) return false;
			pnode cur = _pnode;
			pnode parent = cur;
			while (cur)
			{
				if (cur->_k > k)
				{
					parent = cur;
					cur = cur->_left;
				}
				else if (cur->_k < k)
				{
					parent = cur;
					cur = cur->_right;
				}
				else//删除元素（cur->_k == k）
				{
					//无孩子
					if (cur->_left == nullptr && cur->_right == nullptr)
					{
						if (cur == parent->_left) parent->_left = nullptr;
						else parent->_right = nullptr;
						delete cur;
						cur = nullptr;
					}
					//有左孩子，没有右孩子
					else if (cur->_left && cur->_right == nullptr)
					{
						if (cur == parent->_left) parent->_left = cur ->_left;
						else parent->_right = cur ->_left;
						delete cur;
						cur = nullptr;
					}
					//有右孩子，没有左孩子
					else if (cur->_left == nullptr && cur->_right)
					{
						if (cur == parent->_left) parent->_left = cur->_right;
						else parent->_right = cur->_right;
						delete cur;
						cur = nullptr;
					}
					//两个孩子都有（替换删除法）
					else if (cur->_left&&cur->_right)
					{
						pnode pR = cur->_right;//cur的右子树的根节点
						pnode pRL = cur->_right;//cur的右子树的最左节点
						while (pRL->_left)
						{
							pRL = cur->_left;
						}
						K temp = pRL->_k;
						erase(temp);
						cur->_k = temp;
					}
					return true;
				}
			}
			//树中没有该元素删除失败
			return false;
		}

模拟实现搜索二叉树的完整代码在文末。

四、二叉搜索树应用

1.K模型

只有K作为关键码，结构中只需要存储K值即可，关键码即为需要搜索到的值。

例题，判断一个单词拼写是否正确？

  1. 将词库中所有单词集合中每一个单词作为K值，构建一棵二叉树；
  2. 在这个二叉树中检索是否存在这个单词，如果存在说明拼写正确，如果不存在则说明拼写错误。

2.KV模型

每一个关键码K都有一个对应的V值，即<K,V>键值对。

例如，英汉词典，通过英文可以快速找到中文，英文与中文可以构成一个键值对<English，Chinese>。
例如，计算单词出现的次数，用单词可以找到它出现的次数，单词与它出现的次数可以构成一个键值对<word，count>。

英汉词典的例子：

namespace kv
{
	template<class K,class V>
	struct BSTnode
	{
		BSTnode(const K& k = K(),const V& v = V())
		:_k(k)
		, _v(v)
		, _left(nullptr)
		, _right(nullptr)
		{}
		K _k;
		V _v;
		BSTnode<K, V>* _left;
		BSTnode<K, V>* _right;
	};

	template<class K, class V>
	class BSTree
	{
		typedef BSTnode<K,V> node;
		typedef node* pnode;
	public:
		BSTree()//构造
			:_pnode(nullptr)
		{}
		BSTree(const BSTree<K,V>& t)//拷贝构造
		{
			_pnode = Copy(t._pnode);
		}
		BSTree<K,V>& operator=(const BSTree<K,V> t)//赋值运算符重载
		{
			swap(_pnode, t._pnode);
			return *this;
		}
		~BSTree()//析构
		{
			destory(_pnode);
			_pnode = nullptr;
		}
		pnode Find(const K& k)//查
		{
			pnode cur = _pnode;
			while (cur)
			{
				if (cur->_k > k)
				{
					cur = cur->_left;
				}
				else if (cur->_k < k)
				{
					cur = cur->_right;
				}
				else
				{
					return cur;
				}
			}
			return cur;
		}
		bool insert(const K& k, const V& v)//增
		{
			pnode newnode = new node(k,v);
			//如果该树没有节点就直接插入新节点为根节点
			if (_pnode == nullptr)
			{
				_pnode = newnode;
				return true;
			}
			pnode cur = _pnode;
			pnode parent = cur;//记录当前节点的父节点，因为如果要插入就要插入在当前节点的父节点的左右孩子处
			while (cur)
			{
				parent = cur;
				if (cur->_k > k)
				{
					cur = cur->_left;
				}
				else if (cur->_k < k)
				{
					cur = cur->_right;
				}
				else//如果该节点已经在树中存在就插入失败
				{
					return false;
				}
			}
			//插入元素
			if (parent->_k > k) parent->_left = newnode;
			else parent->_right = newnode;
			return true;
		}
		bool erase(const K& k)//删
		{
			//树为空删除失败
			if (_pnode == nullptr) return false;
			pnode cur = _pnode;
			pnode parent = cur;
			while (cur)
			{
				if (cur->_k > k)
				{
					parent = cur;
					cur = cur->_left;
				}
				else if (cur->_k < k)
				{
					parent = cur;
					cur = cur->_right;
				}
				else//删除元素（cur->_k == k）
				{
					//无孩子
					if (cur->_left == nullptr && cur->_right == nullptr)
					{
						if (cur == parent->_left) parent->_left = nullptr;
						else parent->_right = nullptr;
						delete cur;
						cur = nullptr;
					}
					//有左孩子，没有右孩子
					else if (cur->_left && cur->_right == nullptr)
					{
						if (cur == parent->_left) parent->_left = cur->_left;
						else parent->_right = cur->_left;
						delete cur;
						cur = nullptr;
					}
					//有右孩子，没有左孩子
					else if (cur->_left == nullptr && cur->_right)
					{
						if (cur == parent->_left) parent->_left = cur->_right;
						else parent->_right = cur->_right;
						delete cur;
						cur = nullptr;
					}
					//两个孩子都有（替换删除法）
					else if (cur->_left&&cur->_right)
					{
						pnode pR = cur->_right;//cur的右子树的根节点
						pnode pRL = cur->_right;//cur的右子树的最左节点
						while (pRL->_left)
						{
							pRL = cur->_left;
						}
						K temp = pRL->_k;
						erase(temp);
						cur->_k = temp;
					}
					return true;
				}
			}
			//树中没有该元素删除失败
			return false;
		}
		//中序遍历
		void inorder()
		{
			_inorder(_pnode);
			cout << endl;
		}
	private:
		void destory(pnode p)
		{
			if (p == nullptr) return;
			destory(p->_left);
			destory(p->_right);
			delete p;
		}
		pnode Copy(pnode root)
		{
			if (root == nullptr) return nullptr;
			pnode newnode = new node(root->_k);
			newnode->_left = Copy(root->_left);
			newnode->_right = Copy(root->_right);
			return newnode;
		}
		void _inorder(pnode root)
		{
			if (root == nullptr) return;
			_inorder(root->_left);
			cout << '<'<<root->_k<<','<<root->_v<<'>' << "  ";
			_inorder(root->_right);
		}
		pnode _pnode;
	};
	void test()
	{
		kv::BSTree<string, string> dict;
		dict.insert("sort", "排序");
		dict.insert("string", "字符串");
		dict.insert("left", "左边");
		dict.insert("right", "右边");
		string str;
		while (cin >> str)
		{
			kv::BSTnode<string, string>* ret = dict.Find(str);
			if (ret)
			{
				cout << ret->_v << endl;
			}
			else
			{
				cout << "无此单词" << endl;
			}
		}
	}
}

测试运行结果：
在这里插入图片描述

五、二叉搜索树性能

二叉树的插入和删除都需要先进行查找，因此查找的效率代表着二叉树的性能。
对有n个节点的二叉树，若每个元素的查找概率相同，那么二叉搜索树平均查找次数是二叉树的高度次，即二叉树越高比较次数越多。
但对于同一个关键码的集合，如果各个关键码的插入次序不同，所得到的二叉树的结构可能不同。
在这里插入图片描述
二叉搜索树性能最好是它的结构为完全二叉树（或接近完全二叉树），它的平均比较次数为 l o g 2 N log_2 N log2​N；
二叉搜索树性能最差是他的结构退化成单支，如图中右边的二叉树，它的平均比较次数为 N 2 \frac{N}{2} 2N​。
如果搜索二叉树退化成单支，那么它的性能就丢失了，如何对其进行改进呢？这就涉及我们之后介绍的AVL树和红黑树。

六、模拟实现搜索二叉树

namespace Jinger
{
	template<class K>
	struct BSTnode
	{
		BSTnode(const K& k = K())
		:_k(k)
		,_left(nullptr)
		, _right(nullptr)
		{}
		K _k;
		BSTnode<K>* _left;
		BSTnode<K>* _right;
	};

	template<class K>
	class BSTree
	{
		typedef BSTnode<K> node;
		typedef node* pnode;
	public:
		BSTree()//构造
			:_pnode(nullptr)
		{}
		BSTree(const BSTree<K>& t)//拷贝构造
		{
			_pnode = Copy(t._pnode);
		}
		BSTree<K>& operator=(const BSTree<K> t)//赋值运算符重载
		{
			swap(_pnode,t._pnode);
			return *this;
		}
		~BSTree()//析构
		{
			destory(_pnode);
			_pnode = nullptr;
		}
		pnode Find(const K& k)//查
		{
			pnode cur = _pnode;
			while (cur)
			{
				if (cur->_k > k)
				{
					cur = cur->left;
				}
				else if (cur->_k < k)
				{
					cur = cur->right;
				}
				else
				{
					return cur;
				}
			}
			return cur;
		}
		bool insert(const K& k)//增
		{
			pnode newnode = new node(k);
			//如果该树没有节点就直接插入新节点为根节点
			if (_pnode == nullptr)
			{
				_pnode = newnode;
				return true;
			}
			pnode cur = _pnode;
			pnode parent = cur;//记录当前节点的父节点，因为如果要插入就要插入在当前节点的父节点的左右孩子处
			while (cur)
			{
				parent = cur;
				if (cur->_k > k)
				{
					cur = cur->_left;
				}
				else if (cur->_k < k)
				{
					cur = cur->_right;
				}
				else//如果该节点已经在树中存在就插入失败
				{
					return false;
				}
			}
			//插入元素
			if (parent->_k > k) parent->_left = newnode;
			else parent->_right = newnode;
			return true;
		}
		bool erase(const K& k)//删
		{
			//树为空删除失败
			if (_pnode == nullptr) return false;
			pnode cur = _pnode;
			pnode parent = cur;
			while (cur)
			{
				if (cur->_k > k)
				{
					parent = cur;
					cur = cur->_left;
				}
				else if (cur->_k < k)
				{
					parent = cur;
					cur = cur->_right;
				}
				else//删除元素（cur->_k == k）
				{
					//无孩子
					if (cur->_left == nullptr && cur->_right == nullptr)
					{
						if (cur == parent->_left) parent->_left = nullptr;
						else parent->_right = nullptr;
						delete cur;
						cur = nullptr;
					}
					//有左孩子，没有右孩子
					else if (cur->_left && cur->_right == nullptr)
					{
						if (cur == parent->_left) parent->_left = cur ->_left;
						else parent->_right = cur ->_left;
						delete cur;
						cur = nullptr;
					}
					//有右孩子，没有左孩子
					else if (cur->_left == nullptr && cur->_right)
					{
						if (cur == parent->_left) parent->_left = cur->_right;
						else parent->_right = cur->_right;
						delete cur;
						cur = nullptr;
					}
					//两个孩子都有（替换删除法）
					else if (cur->_left&&cur->_right)
					{
						pnode pR = cur->_right;//cur的右子树的根节点
						pnode pRL = cur->_right;//cur的右子树的最左节点
						while (pRL->_left)
						{
							pRL = cur->_left;
						}
						K temp = pRL->_k;
						erase(temp);
						cur->_k = temp;
					}
					return true;
				}
			}
			//树中没有该元素删除失败
			return false;
		}
		//中序遍历
		void inorder()
		{
			_inorder(_pnode);
			cout<<endl;
		}
	private:
		void destory(pnode p)
		{
			if (p == nullptr) return;
			destory(p->_left);
			destory(p->_right);
			delete p;
		}
		pnode Copy(pnode root)
		{
			if (root == nullptr) return nullptr;
			pnode newnode = new node(root->_k);
			newnode->_left = Copy(root->_left);
			newnode->_right = Copy(root->_right);
			return newnode;
		}
		void _inorder(pnode root)
		{
			if (root == nullptr) return;
			_inorder(root->_left);
			cout << root->_k << "  ";
			_inorder(root->_right);
		}
		pnode _pnode;
	};
	//测试插入和删除
	void test1()
	{
		int a[] = { 8, 3, 1, 10, 6, 4, 7, 14, 13 };
		BSTree<int> t;
		for (auto e : a)
		{
			t.insert(e);
		}
		t.inorder();
		t.erase(3);
		t.inorder();
		t.erase(13);
		t.inorder();
	}
}

总结

以上就是今天要讲的内容，本文介绍了二叉搜索树的相关概念。本文作者目前也是正在学习C++相关的知识，如果文章中的内容有错误或者不严谨的部分，欢迎大家在评论区指出，也欢迎大家在评论区提问、交流。
最后，如果本篇文章对你有所启发的话，希望可以多多支持作者，谢谢大家！

codeJinger
关注
  • 3
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
C++实现二叉树搜索树
12-18
功能：插入、查找、删除、清除整个树、返回最大值、返回最小值、前序遍历、中序遍历、后序遍历。 注：此二叉树允许插入相同的值
【C++】二叉搜索树
m0_62179366的博客
10-24 1918
二叉搜索树的简单应用及实现。
C++搜索二叉树
RXY24601的博客
05-27 1211
C++搜索二叉树，包括搜索二叉树的增删查，key-value模型的介绍及实现，搜索二叉树效率分析
C++的数据结构与算法(六)二叉树搜索算法学习
蒋成的博客
07-14 732
文章目录1.二分搜索树原理1.1 理论介绍1.2代码实现2.二分搜索树的节点插入3.二分搜索树的查找4.二分搜索树的遍历(深度优先遍历)5.层序遍历(广度优先遍历)6.删除最大值，最小值、删除节点7.二分搜索树的顺序性8.二分搜索树的顺序性9.二分搜索树的局限性 1.二分搜索树原理 1.1 理论介绍 同上篇文章介绍的二叉堆本质上类似，都是一个二叉树。选择什么特征的二叉树是根据具体问题来决定的，了解...
二叉搜索树（Binary Search Tree）--C++
qq_63412763的博客
07-29 387
二叉搜索树又叫二叉排序树，是二叉树的一种特殊情况。树的每个节点的值都满足一定的规律，同样是以结构体为节点创造树。1.对于根节点有“左小右大”。2.对于左右子树节点有“左小右大”。呼~，总算是把二叉搜索树的主要内容讲完了，重点还在于二叉搜索树的操作那一部分，对于删除的情况分析以及递归的实现都能使我们更加了解二叉搜索树的整体结构。关于树形数据结构的知识现阶段我还在学习中，往后会继续更新相关知识的博客。👋httpshttpshttpshttpshttpshttpshttpshttps。...
二叉搜索树
热门推荐
2021dragon的博客
11-04 1万+
文章目录二叉搜索树的概念二叉搜索树的实现二叉搜索树的应用二叉搜索树的性能分析 二叉搜索树的概念 二叉搜索树的实现 二叉搜索树的应用 二叉搜索树的性能分析
数据结构之二叉搜索树（C++实现）
CHAKMING1的博客
01-12 475
介绍了二叉树中的二叉搜索树，从概念到具体实现，是使用C++完成的。最后，对二叉搜索树的效率进行分析已经响应的二叉树的练习题目。
二叉搜索树详解（C++实现）
沐白白的博客
04-14 1190
二叉搜索树的定义 二叉搜索树，也称有序二叉树,排序二叉树，是指一棵空树或者具有下列性质的二叉树： 若任意节点的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若任意节点的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 任意节点的左、右子树也分别为二叉查找树。 没有键值相等的节点。 二叉搜索数中序遍历为有序数组 一、查找二叉搜索树中的某个元素 在二叉搜索树b中查找x的过程为： 若b是空树，则搜索失败，否则： 若x等于b的根节点的数据域之值，则查找成功；否则： 若x小于b的根节点的
【数据结构】二叉搜索树/搜索二叉树(C++实现)
Brant_zero的博客
11-05 2112
二叉搜索树的概念、二叉搜索树的实现，二叉搜索树的插入、二叉搜索树的删除、二叉搜索树的查找、二叉搜索树性能分析，二叉搜索树key模型、二叉搜索树key-value模型
【C++详解】——搜索二叉树
weixin_69519040的博客
04-22 550
本文介绍了搜索二叉树的原理，并且模拟实现了一个搜索二叉树，其中插入、删除、查找功能分别使用了递归和非递归两种实现方式。本文还介绍了两种搜索二叉树的应用场景，根据相应的应用场景将搜索二叉树改造成了KV结构。 本文详细代码链接：https://gitee.com/hrimkn
二叉树-基于C++实现的二叉搜索树.zip
最新发布
04-26
二叉树 二叉树_基于C++实现的二叉搜索树
数据结构搜索二叉树.rar
07-16
二叉查找树（Binary Search Tree），（又：二叉搜索树，二叉排序树）它或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树...
二叉树的广度搜索遍历
12-19
适合大学生，学生党学习c++的二叉树的广度搜索遍历的c++程序。
C++实现二叉树、搜索二叉树、AVL树
12-01
C++实现类模板 包括二叉树、搜索二叉树、AVL树及它们的各种算法实现（包括建立、输出、前序遍历、中序遍历、后序遍历、插入、删除、搜索、重构、求树高、统计叶子总数等等）
C++进阶——二叉搜索树
weixin_51885188的博客
03-03 957
二叉搜索树 这篇文章主要为大家介绍二叉树搜索树的概念、操作、实现以及它的应用。同时学习二叉搜索树也是在为我们后面学习map与set做铺垫，当我们了解了二叉搜索树的特性后，后面将有助于我们更好的理解map和set的特性 二叉搜索树的概念（特征） 二叉搜索树也称二叉排序树，它或是一棵空树，或者是具有以下性质的二叉树： 若它的左子树不为空，则左子树上所有的节点值都小于根节点的值 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值 它的左右子树也分别为二叉搜索树 int arr[] = {5,3,
【C++ STL】-- 二叉搜索树
weixin_64609308的博客
11-25 2075
详细配图讲解：搜索二叉树的构建与函数接口实现
二叉搜索树详解以及C++实现二叉搜索树（递归和非递归）
qq_61635026的博客
07-26 760
二叉搜索树详解以及C++实现二叉搜索树（递归和非递归）
二叉树遍历查找
心猿意碼
05-08 335
1)前序遍历:先输出父节点，再遍历左子树和右子树 2)中序遍历:先遍历左子树，再输出父节点，再遍历右子树 3)后序遍历:先遍历左子树，再遍历右子树，最后输出父节点 4)小结:看输出父节点的顺序，就确定是前序，中序还是后序 package com.atguigu.tree; public class BinaryTreeDemo { public static void mai...
C++ 搜索二叉树
异样旧日的博客
06-16 376
搜索二叉树的介绍与模拟实现
C++实现搜索二叉树
05-30
可以使用结构体和指针来实现搜索二叉树，具体实现方法如下： ```c++ #include using namespace std; // 定义二叉树节点结构体 struct TreeNode { int val; TreeNode* left; TreeNode* right; TreeNode(int x)...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

codeJinger

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

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

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

打赏作者

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

抵扣说明：

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

余额充值