c++修炼之路之二叉搜索树

最新推荐文章于 2024-11-09 20:38:27 发布
最新推荐文章于 2024-11-09 20:38:27 发布
阅读量1k 收藏 20
点赞数 16
分类专栏： c++ 数据结构 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Miwll/article/details/140753211
版权

目录

前言

一：二叉搜索树的介绍

 二：二叉搜索树的实现 

1.查找

2.insert(插入)

3.erase(删除)

4.析构函数

5.拷贝构造 

6.赋值重载

7.插入，删除，查找的递归版本 

三：二叉搜索树的应用

四：二叉搜索树的性能

接下来的日子会顺顺利利，万事胜意，生活明朗-----------林辞忧 

前言

对于普通的二叉树去存储管理数据等方面是不如一些容器的，所以学习二叉搜索树这样特殊的树是很有必要的

一：二叉搜索树的介绍

二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树:

   1.若它的左子树不为空，则左子树上所有节点的值都小于根节点的值

    2.若它的右子树不为空，则右子树上所有节点的值都大于根节点的值

   3.它的左右子树也分别为二叉搜索树

 二：二叉搜索树的实现 

1.查找

如二叉树一样依次循环往下找，直至为空

template<class K>
struct BSTreeNode
{
	BSTreeNode<K>* _left;
	BSTreeNode<K>* _right;
	K _key;

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

template<class K>
class BSTree
{
public:
	typedef BSTreeNode<K> Node;
    Node* _root=nullptr;

bool 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 false;
}

2.insert(插入)

a. 树为空，则直接新增节点，赋值给root指针

b. 树不空，按二叉搜索树性质查找插入位置，插入新节点

 

bool insert(const K& key)
{
	if (_root == nullptr)
	{
		_root = new Node(key);
		return true;
	}
	//寻找插入位置
	Node* cur = _root;
	Node* parent = nullptr;
	while (cur)
	{
		if (cur->_key > key)
		{
			parent = cur;
			cur = cur->_left;
		}
		else if (cur->_key < key)
		{
			parent = cur;
			cur = cur->_right;
		}
		else
		{
			return false;
		}
	}
	cur = new Node(key);
	//确定左右位置进行链接
	if (parent->_key > cur->_key)
	{
		parent->_left = cur;
	}
	else
	{
		parent->_right = cur;
	}

	return true;
}

3.erase(删除)

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

      a. 要删除的结点无孩子结点
      b. 要删除的结点只有左孩子结点
      c. 要删除的结点只有右孩子结点
      d. 要删除的结点有左、右孩子结点 

 

 

 

 

bool erase(const K& key)
{
	//找到删除位置
	Node* cur = _root;
	Node* parent = nullptr;
	while (cur)
	{
		if (cur->_key > key)
		{
			parent = cur;
			cur = cur->_left;
		}
		else if (cur->_key < key)
		{
			parent = cur;
			cur = cur->_right;
		}
		else
		{
			//找到了开始删除
			if (cur->_left == nullptr)//左为空
			{
				if (parent == nullptr)
				{
					_root = cur->_right;
				}
				else
				{
					if (parent->_left == cur)
					{
						parent->_left = cur->_right;
					}
					else
					{
						parent->_right = cur->_right;
					}
				}
				delete cur;
			}
			else if (cur->_right == nullptr)//右为空
			{
				if (parent == nullptr)
				{
					_root = cur->_left;
				}
				else
				{
					if (parent->_left == cur)
					{
						parent->_left = cur->_left;
					}
					else
					{
						parent->_right = cur->_left;
					}
				}
				delete cur;
			}
			else if (cur->_left && cur->_right)//左右都不为空--替换法
			{
				//寻找右子树的最左节点
				Node* SubR = cur->_right;
				parent = cur;
				while (SubR->_left)
				{
					parent = SubR;
					SubR = SubR->_left;
				}
				//交换值
				swap(cur->_key, SubR->_key);
				if (parent->_left == SubR)
					parent->_left = SubR->_right;
				else
					parent->_right = SubR->_right;
				delete SubR;
			}
			return true;
		}
	}
	return false;
}

4.析构函数

~BSTree()
{
	Destroy(_root);
}
void Destroy(Node* root)
{
	//后序析构
	if (root == nullptr)
		return;
	Destroy(root->_left);
	Destroy(root->_right);
	delete root;
}

5.拷贝构造 

//拷贝构造
//b1(b2)
BSTree(const BSTree<K>& t)
{
	_root = Copy(t._root);
}

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

		Node* NewRoot = new Node(root->_key);
		NewRoot->_left = Copy(root->_left);
		NewRoot->_right = Copy(root->_right);

		return NewRoot;
	}

6.赋值重载

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

7.插入，删除，查找的递归版本 

bool InsertR(const K& key)
{
	return _InsertR(_root, key);
}
bool FindR(const K& key)
{
	return _FindR(_root, key);
}
bool EraseR(const K& key)
{
	return _EraseR(_root, key);
}

bool _FindR(Node* root, const K& key)
{
	if (root)
	{
		if (key > root->_key)
		{
			return _FindR(root->_right, key);
		}
		else if (key < root->_key)
		{
			return _FindR(root->_left, key);
		}
		else
			return true;
	}
	return false;
}

bool _InsertR(Node*& root, const K& key)
{
	if (root)
	{
		if (key > root->_key)
		{
			return  _InsertR(root->_right, key);
		}
		else if (key < root->_key)
		{
			return  _InsertR(root->_left, key);
		}
		else
		{
			return false;
		}
	}
	root = new Node(key);
	return true;
}

bool _EraseR(Node*& root, const K& key)
{
	if (root)
	{
		if (key > root->_key)
		{
			return _EraseR(root->_right, key);
		}
		else if (key < root->_key)
		{
			return _EraseR(root->_left, key);
		}
		else
		{
			if (root->_left == nullptr)//左为空
			{
				Node* del = root;
				root = root->_right;
				delete del;
			}
			else if (root->_right == nullptr)//右为空
			{
				Node* del = root;
				root = root->_left;
				delete del;
			}
			else//左右都不为空
			{
				Node* SubLeft = root->_right;
				while (SubLeft->_left)
				{
					SubLeft = SubLeft->_left;
				}
				swap(SubLeft->_key, root->_key);

				return _EraseR(root->_right, key);
			}
			return true;
		}
	}
	return false;
}

三：二叉搜索树的应用

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

改造一份key_value型的二叉搜索树

	template<class K,class V>
	class BSTree
	{
	public:
		typedef struct BSTreeNode<K,V> Node;
		//插入数据
		bool Insert(const K& key,const V& value)
		{
			if (_root == nullptr)
			{
				_root = new Node(key,value);
				return true;
			}
			//找对应位置插入
			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 (parent->_key < cur->_key)
			{
				parent->_right = cur;
			}
			else
			{
				parent->_left = cur;
			}
			return true;
		}
		Node* Find(const K& key)
		{
			if (_root == nullptr)
				return nullptr;

			Node* cur = _root;
			while (cur)
			{
				if (key > cur->_key)
				{
					cur = cur->_right;
				}
				else if (key < cur->_key)
				{
					cur = cur->_left;
				}
				else
					return cur;
			}
			return nullptr;
		}
		bool Erase(const K& key)
		{
			if (_root == nullptr)
				return false;

			//查找位置删除
			Node* cur = _root;
			Node* parent = nullptr;
			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 = _root->_right;
						}
						else
						{
							//判断parent与cur的位置关系
							if (parent->_left == cur)
							{
								parent->_left = cur->_right;
							}
							else
							{
								parent->_right = cur->_right;
							}
						}
						delete cur;
					}
					else if (cur->_right == nullptr)//右为空
					{
						if (cur == _root)
						{
							_root = _root->_left;
						}
						else
						{
							//判断parent与cur的位置关系
							if (parent->_left == cur)
							{
								parent->_left = cur->_left;
							}
							else
							{
								parent->_right = cur->_left;
							}
						}
						delete cur;
					}
					else//左右都不为空 --替换法->寻找右子树的最左节点替换删除
					{
						Node* parent = cur;
						Node* SubLeft = cur->_right;
						while (SubLeft->_left)
						{
							parent = SubLeft;
							SubLeft = SubLeft->_left;
						}
						swap(cur->_key, SubLeft->_key);

						if (parent->_left == SubLeft)
						{
							parent->_left = SubLeft->_right;
						}
						else
						{
							parent->_right = SubLeft->_right;
						}
						delete SubLeft;
					}
					return true;
				}
			}
			return false;
		}
		//中序遍历
		void InOrder()
		{
			_InOrder(_root);
			cout << endl;
		}
	private:
		void _InOrder(Node* root)
		{
			if (root == nullptr)
				return;

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

四：二叉搜索树的性能

林辞忧
关注
专栏目录
【架构师修炼之路】Redis 极简教程 : 基本数据结构, 跳表原理, Spring Boot 项目使用实例
AI天才研究院
11-10 8856
引言 本文主要介绍 Spring Boot 应用中使用 Redis 的基础知识. Redis 是什么 Redis: REmote DIctionary Server Redis is an in-memory database that persists on disk. The data model is key-value, but many different kind of valu...
【C++修炼之路】17.二叉搜索树
Q1697354625
02-07 676
二叉搜索树。
【C++修炼之路：二叉搜索树】
m0_69787428的博客
05-07 433
问题：如果退化成单支树，二叉搜索树的性能就失去了。那能否进行改进，不论按照什么次序插入关键码，二叉搜索树的性能都能达到最优？对有n个结点的二叉搜索树，若每个元素查找的概率相等，则二叉搜索树平均查找长度是结点在二叉搜索树的深度的函数，即结点越深，则比较次数越多。套一层：由于根是私有的调不动需要写一个子函数，让子函数去递归,因此我们需要套一层，也可以自己写一个getroot。1.若它的左子树不为空，则左子树上所有节点的值都小于根节点的值。2.若它的右子树不为空，则右子树上所有节点的值都大于根节点的值。
c++修炼之路之AVL树与红黑树
Miwll的博客
09-12 1118
AVL与红黑树的实现
【C++修炼之路】19.AVL树
Q1697354625
02-20 573
前面对map/multimap/set/multiset进行了简单的介绍，在其文档介绍中发现，这几个容器有个共同点是：其底层都是按照二叉搜索树来实现的，但是二叉搜索树有其自身的缺陷，假如往树中插入的元素有序或者接近有序，二叉搜索树就会退化成单支树，时间复杂度会退化成O(N)，因此map、set等关联式容器的底层结构是对二叉树进行了平衡处理，即采用平衡树来实现。平衡树有AVL树、红黑树，本篇就来了解一下AVL树。对于AVL树，相比普通的二叉搜索树，最主要的就是多了一个平衡因子保持AVL高度平衡的结构。
【C++修炼之路】20.手撕红黑树
Q1697354625
02-20 3160
在上一节中我们学到了AVL树的结构及其相关性质，对于平衡树来说，AVL无疑是最完美的结构，但实际上AVL树由于完美的结构因此也要花费一定的代价，由于AVL树的结构很敏感，查找虽然最快，但插入节点后一旦偏离AVL结构就会进行旋转，而旋转就会花费一定的性能。因此我们提到的map和set的底层为了防止这种性能上的缺失，即便AVL是非常完美的结构，也不采用AVL。而是采用我们这节所要描述的红黑树。相比较AVL树，红黑树的结点仍是三叉链这个结构，为后续不满足结构的条件旋转做准备。
c++修炼之路之STL_map,set
Miwll的博客
07-29 889
set && map
【C++修炼之路】18.map和set
Q1697354625
02-20 728
set的底层为二叉搜索树，也就是上一节中所实现的，不过在此之上，set作为容器来说，封装了和以前的vector、list、deque相关的迭代器、运算符重载等，方便我们去进行一系列的操作。可以发现，这与之前我们所学的容器的方法几乎差不多。set是按照一定次序存储元素的容器在set中，元素的value也标识它(value就是key，类型为T)，并且每个value必须是唯一的。set中的元素不能在容器中修改(元素总是const)，但是可以从容器中插入或删除它们。
程序员修炼之路-(4)搜索(中)：二叉查找树
西代零零发
04-12 3344
2 查找：鱼与熊掌前面已经介绍了线程查找和二分查找的符号表（symbol table）实现，但现代应用的特点是查找与插入或删除操作交叉在一起，无法预测，并且表非常巨大。因此问题的关键就是我们能否设计出具有对数性能的search和insert/delete操作的数据结构和算法？为了实现高效的插入，我们需要链表结构。但是单链表却又阻止了二分查找的使用，因为二分查找依赖数组的快速访问才能快速定位到每次迭
程序员修炼之路
西代零零发
02-10 6929
0.前言：在路上，再上路在前言《程序员修炼之路-(0)前言：在路上, 再上路》中已经对知识体系进行了梳理，主要分为问题定义、算法与数据结构、系统平台API、编程语言实现、代码设计、测试验证等等。目前集中精力编写算法与数据结构部分，这可能也是最艰难的一部分。其他部分之前零零散散有所涉及，之后再慢慢补充。1.计算机数学离散数学与具体数学。2.算法分析设计对于这一部分的内容编排，主要以《算法设计与分析基础
【架构师修炼之路】Redis 极简教程 : 基本数据结构, 跳表原理, Spring Boot 项目使用实例...
AI天才研究院
11-10 8854
引言 本文主要介绍 Spring Boot 应用中使用 Redis 的基础知识. Redis 是什么 Redis: REmote DIctionary Server Redis is an in-memory database that persists on disk. The data model is key-value, but many differen...
嵌入式工程师成长之路（7）——算法学习
热门推荐
云轩阁
07-21 2万+
算法大全1、风仲达——算法笔记2、坐在马桶上学算法3、啊哈算法4、深度强化学习实验室。
应届生怎么走Linux下C++后台服务器开发路线，工作3-5年的知识体系
Linuxhus的博客
08-05 691
1. 前言 　　给最近正在准备秋招的同学或者是想转行，目标岗位是C++后端开发工程师，这个岗位对开发者的要求也比较高，需要的基础知识非常多，刚刚开始准备的时候，感觉也是不知从何入手，现在经过了一段时间的学习，感觉比刚开始的时候好了一些，但是在很多方面还有欠缺，所以写下这篇文章，给你们进行一个总结，也希望能帮助到你们在这条路上不断前行的人。 2. 服务器开发与后台开发的联系和区别 　　服务器是一种高性能的计算机，相对于普通的个人电脑，它的性能往往更强，但是功能也更加单一。服务器开发，就是在服务器上面开发
服务器开发设计之算法宝典
腾讯技术工程
12-27 3701
作者：lynhlzou，腾讯 IEG 后台开发工程师孙子云：“上兵伐谋，其次伐交，其次伐兵，其下攻城”，最上乘行军打仗的方式是运用谋略，下乘的方式才是与敌人进行惨烈的厮杀。同样的，在程序设...
C++——C++11新语法（中）
Wangx_wang的博客
11-06 1024
介绍了C++11中的引用折叠、可变模板参数、类的新功能、lambda
STL set
最新发布
hls0611的博客
11-09 205
练习题：P1059 [NOIP2006 普及组] 明明的随机数。
C++_用 using 语句继承基类的构造函数
学海无涯
11-09 138
**默认情况下**，派生类会继承基类的所有成员，包括数据成员和函数成员，但不会继承基类的**构造函数和析构函数**，因为构造函数和析构函数的作用是创建和销毁对象，派生类通常需要有自己的构造和析构的逻辑。C++11 引入了using语句，使得派生类可以通过 using 关键字使用基类的构造函数，更方便地复用基类的构造逻辑。
C 学习（4）
search7的博客
11-05 831
C语言学习，每个模块来自工作中的？？？
常用的c++特性--＞day02
m0_69093426的博客
11-06 573
C++11中为我们提供了一个模板类叫做std::enable_shared_from_this，这个类中有一个方法叫做shared_from_this()，通过这个方法可以返回一个共享智能指针，在函数的内部就是使用weak_ptr来监测this对象，并通过调用weak_ptr的lock()方法返回一个shared_ptr对象。通过打印的结果可以知道，虽然弱引用智能指针wp3、wp4、wp5监测的资源是同一个，但是它的引用计数并没有发生任何的变化，也进一步证明了weak_ptr只是监测资源，并不管理资源。
C++实现的二叉搜索树深入解析
资源摘要信息:"二叉树-基于C++实现的二叉搜索树.zip" 知识点一：二叉树基础概念 二叉树是每个节点最多有两个子树的树结构，通常子树被称作“左子树”和“右子树”。二叉树在计算机科学中有广泛的应用，比如用于构建...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值