补充二叉搜索树C++版实现(建议看这)和应用

最新推荐文章于 2023-11-03 09:13:13 发布
最新推荐文章于 2023-11-03 09:13:13 发布
阅读量311 收藏 1
点赞数
分类专栏： C++ 文章标签： c++ 数据结构 二叉搜索树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_57023347/article/details/120013539
版权

目录

一.实现二叉搜索树

二. 二叉搜索树的应用

2.1 排序

2.2 搜索

2.2.1 K模型

2.2.2 KV模型(常用)

 三.二叉搜索树的性能分析

一.实现二叉搜索树

这里再简单介绍一下二叉搜索树：

        首先二叉搜索树是一个二叉树，具有的性质为，左子树的结点值比父节点值小，右子树结点值比父节点值大，并且左右子树同样符合这种性质。

        实现的二叉树的功能有：增加一个结点，查找一个结点，删除一个结点，和中序遍历。

        为什么没有修改一个结点，一般二叉搜索树的结点值不要轻易修改，不然可能不符合二叉搜索树的性质了。但是KV模型可以修改val的值，下面有说明。

        为什么要加一个中序遍历：因为二叉搜索树的中序遍历是有序的。

具体细节可以看这篇博客，里面有详细说明如何实现：数据结构——二叉搜索树(干货满满)

这里还再强调一下二叉搜索树的删除：

        删除分为四种情况：

                左结点和右节点为空，直接删除。注意：只有一个结点的情况

                左节点不为空，右节点为空，将左节点连接到当前节点的父节点

                左节点为空，右节点不为空，将右节点连接到当前节点的父节点

                左右结点都不为空，使用替换法，找到右子树中的最小值，将该值替换掉要删除结点的值。再将右子树的最小值删除。或者找到左子树中的最大值，将该值替换掉要删除结点的值。再将右左子树的最大值删除。

下面是实现代码：

注意：当只有一个节点，删除节点时，直接删除节点皆可，还需要将头节点指控，避免野指针。

                //只有一个结点
					if (prev == nullptr){
						delete cur;
						//要将这个置空，不让就会是野指针
						_root = nullptr;
						return true;
					}

 删除节点要考虑空树的情况。

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


//模板不要与实现分开

template<class K>
struct BSTreeNode{
	BSTreeNode(K val)
	:_left(nullptr)
	, _right(nullptr)
	, _val(val)
	{}

	BSTreeNode *_left;
	BSTreeNode *_right;

	K _val;
};

template<class K>
class BSTree
{
	typedef BSTreeNode<K> Node;
public:
	//插入
	bool Insert(K val){
		//判断_root
		if (_root == nullptr){
			_root = new Node(val);
			return true;
		}
		Node *cur = _root;
		//找插入位置，一定作为叶节点插入
		Node *prev = nullptr;//记录要插入的结点，就是要插入结点的父节点
		while (cur){
			if (val > cur->_val){
				prev = cur;
				cur = cur->_right;
			}
			else if (val < cur->_val){
				prev = cur;
				cur = cur->_left;
			}
			else{
				cout << "已存在" << endl;
				return false;
			}
		}
		//找到
		cur = new Node(val);
		//判断插入结点的左边还是右边
		if (prev->_val > val){
			prev->_left = cur;
		}
		else if (prev->_val < val){
			prev->_right = cur;
		}
		else{

		}
		return true;
	}

	//找结点
	Node *FindNode(K val){
		if (_root == nullptr){
			cout << "不存在" << endl;
			return nullptr;
		}
		Node *cur = _root;
		while (cur){
			if (val > cur->_val){
				cur = cur->_right;
			}
			else if (val < cur->_val){
				cur = cur->_left;
			}
			else{
				
				return cur;
			}
		}
		cout << "不存在" << endl;
		return nullptr;
	}
	//删除
	bool Erase(K val){
		if (_root == nullptr){
			return false;
		}
		//找结点
		Node *cur = _root;
		Node *prev = nullptr;
		while (cur){
			if (val > cur->_val){
				prev = cur;
				cur = cur->_right;
			}
			else if (val < cur->_val){
				prev = cur;
				cur = cur->_left;
			}
			else{
				//找到
				if (cur->_left == nullptr&&cur->_right == nullptr){
					//只有一个结点
					if (prev == nullptr){
						delete cur;
						//要将这个置空，不让就会是野指针
						_root = nullptr;
						return true;
					}

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

					}
					delete cur;
					return true;
				}
				if (cur->_left&&cur->_right == nullptr){
					if (prev->_left == cur){
						prev->_left = cur->_left;
					}
					else if (prev->_right == cur){
						prev->_right = cur->_left;
					}
					else{

					}
					delete cur;
					return true;
				}
				if (cur->_left==nullptr&&cur->_right){
					if (prev->_left == cur){
						prev->_left = cur->_right;
					}
					else if (prev->_right == cur){
						prev->_right = cur->_right;
					}
					else{

					}
					delete cur;
					return true;
				}
				if (cur->_left&&cur->_right){
					//找右子树最小值
					
					Node *tail = cur;
					tail = tail->_right;
					Node *MinRightParent = cur;
					while (tail->_left){
						MinRightParent = tail;
						tail = tail->_left;
					}
					K MinRight = tail->_val;
					//删除右子树最小值结点，左子树肯定为nullptr
					if (MinRightParent->_left == tail){
						MinRightParent->_left = tail->_right;
					}
					else if (MinRightParent->_right == tail){
						MinRightParent->_right = tail->_right;
					}
					else{

					}
					
					delete tail;
					//值替换
					cur->_val = MinRight;
					
					return true;

				}

				
			}
		}
		//没找到
		return false;
	}


	//中序遍历
	void _InNode(Node *root){
		if (root){
			_InNode(root->_left);
			cout << root->_val;
			_InNode(root->_right);
		}
	}
    //类外调用InNode时传入this指针，不好递归，所以调用_InNode
	void InNode(){
		_InNode(_root);
		cout << endl;
	}

private:
	Node *_root = nullptr;
};

二. 二叉搜索树的应用

2.1 排序

        这个排序很简单，一个二叉搜索树，中序遍历后就是有序的。

例如：

        2.2 搜索

        2.2.1 K模型

        K模型：结构体中只有一个有效值Key，即只有Key最为关键码，关键码就是要找的值。主要功能是判断在不在或者正不正确的问题。

        例如：给一个单词，判断该单词是否拼写正确。

                1.以单词集合的每一个单词构建一颗二叉搜索树

                2.再二叉搜索树中查找单词是否存在，找出后，查看单词是否拼写正确。

上面写的结构体中只有一个Key的二叉搜索树就可以应用再K模型里。

        2.2.2 KV模型(常用)

        KV模型：每一个关键码都会有与之对应的value，即<key,value>键值对。二叉搜索树的构建依然是以key构建，通过查找key来得到需要的信息value。一般这个模型的结构体中有两个有效值key和value。

        例如：中英词典，通过中文来找英文。

                1.以单词集合中的中文key来构建一颗二叉搜索树。

                2.通过中文，再二叉搜索树里查找是否存在，找出后，得到相应的英文value。

代码实现KV模型，实际就是再上面的基础上，结点所里一个值。

#pragma once

#include<iostream>
using namespace std;

template<class K,class V>
struct BSTreeNode{
	BSTreeNode(K key,V value)
	:_left(nullptr)
	, _right(nullptr)
	, _key(key)
	, _value(value)
	{}
	BSTreeNode *_left;
	BSTreeNode *_right;
	K _key;
	V _value;
};

template<class K,class V>
class KVBSTtree
{
	typedef BSTreeNode<K,V> Node;
public:
	bool Insert(K key, V value){
		if (_root == nullptr){
			_root = new Node(key, value);
			return true;
		}
		Node *cur = _root;
		Node *curparent = nullptr;
		while (cur){
			if (key > cur->_key){
				curparent = cur;
				cur = cur->_right;
			}
			else if (key < cur->_key){
				curparent = cur;
				cur = cur->_left;
			}
			else{
				cout << "已存在" << endl;
				return false;
			}
		}
		//找到插入位置
		cur = new Node(key, value);
		//判断插入父亲的左边还是右边
		if (curparent->_key < key){
			curparent->_right = cur;
		}
		else if (curparent->_key>key){
			curparent->_left = cur;
		}
		else{

		}
		return true;

	}

	Node *Find(K key){
		if (_root == nullptr){
			//cout << "没找到" << endl;
			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(K key){
		if (_root == nullptr){
			return false;
		}
		Node *curparent = nullptr;
		Node *cur = _root;
		while (cur){
			if (key > cur->_key){
				curparent = cur;
				cur = cur->_right;
			}
			else if (key < cur->_key){
				curparent = cur;
				cur = cur->_left;
			}
			else{
				if (cur->_left == nullptr&&cur->_right == nullptr){
					//只有一个节点
					if (curparent == nullptr){
						delete cur;
						_root = nullptr;
						return true;
					}
					
					if (curparent->_left == cur){
						curparent->_left = nullptr;
					}
					else{
						curparent->_right = nullptr;
					}
					//先删除结点再释放，先释放即找不到了
					delete cur;
				}
				else if (cur->_left == nullptr&&cur->_right){
					if (curparent->_left == cur){
						curparent->_left = cur->_right;
					}
					else{
						curparent->_right = cur->_right;
					}
					delete cur;
				}
				else if (cur->_left &&cur->_right == nullptr){
					if (curparent->_left == cur){
						curparent->_left = cur->_left;
					}
					else{
						curparent->_right = cur->_left;
					}
					delete cur;
				}
				else{
					Node *Minparent = cur;
					//找右子树最小值
					Node *tail = cur->_right;
					while (tail->_left){
						Minparent = tail;
						tail=tail->_left;
					}
					K tmpkey = tail->_key;
					V tmpvalue = tail->_value;
					cur->_key = tmpkey;
					cur->_value = tmpvalue;
					//删除右子树最小值
					if (Minparent->_left == tail){
						Minparent->_left = tail->_right;
					}
					else{
						Minparent->_right = tail->_right;
					}
					delete tail;

				}
				return true;


			}
		

		}
		return false;

	}
	void _InNode(Node *root){
		if (root){
			_InNode(root->_left);
			cout << root->_key << "->" << root->_value << ' ';
			_InNode(root->_right);
		}
	}

	void InNode(){
		_InNode(_root);
		cout << endl;
	}

private:
	Node *_root = nullptr;
};

简易实现一个电子词典 

给定单词，找到出现次数

 三.二叉搜索树的性能分析

        二叉搜索树插入和删除前都必须先查找，查找效率代表了二叉搜索树中的各个操作的效率。

         对于二叉搜索树的查找效率和树的高度有关。但是树的高度又和加入集合的数值顺序有关。不同的顺序可以得到不同的二叉搜索树。并且对于有序序列，形成的二叉搜索树会变成一个链状结构，效率大大降低。

如一个集合：int arr[] = { 3, 4, 5, 6, 7, 8, 9 }；形成的二叉搜索树为：

 查找效率最坏情况为O(n)。

总结：

最好情况下，二叉搜索树为完全二叉树，时间复杂度为O(logN)。

最坏情况，有序，二叉搜索树为单支树，时间复杂度为O(N)。

两片空白
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉树C++源代码，模板实现，可用于各种类型
12-04
在IT领域，二叉树是一种基础且重要的数据结构，它在计算机科学中有着广泛的应用，如搜索、排序、图形算法等。本项目提供了一套完整的C++源代码，旨在实现一个通用的二叉树模板，使得它能适用于处理各种类型的数据。 ...
数据结构C++边学边做--二叉树的应用--求二叉树的最小深度
qq_39400324的博客
02-14 1122
求二叉树的最小深度一、求二叉树的最小深度二、求二叉树最小深度实现1.SmallestDepth类文件2.SmallestDepth类方法三、求二叉树最小深度代码测试1.主函数2.输出结果四、源代码获取（免积分） 一、求二叉树的最小深度   在前文二叉链表的实现的基础上添加一个求二叉树的最小深度的方法：SmallestDepth。二叉树的最小深度指的是从根节点到最近的叶子结点的距离。   当二叉树为空时，返回0；   当二叉树的左子树为空时返回右子树的最小深度+1；   当二叉树的右子树为空时返回左子树的深度
【C++】二叉搜索树（概念、实现、应用）
ZZZCCC的博客
04-24 423
在分块讲解前，我们要明白，递归要传根节点，但是用户平常使用这些借口并不会传根节点，而是直接调用，所以我们嵌套一层，这样就可以满足双方的需求了。可以在递归的参数中多一个父亲结点，每次递归都更新一下Parent，然后再带到下一层递归。由于没有二叉搜索树的官方库，我们增删查改的实现需要我们自己来完成，见下面的模拟实现。递归这种思想我么你还需要多加理解，下一章将详细讲解OJ题目，加深我们对于递归的理解！采用递归方式的缺点就是如果数的结点个数足够多的时候，就会有爆栈的风险！当出现单边树的情况时，就是〇（N）的情况。
二叉搜索树的应用（C++实现 附源码）
LS_Alice_0820的博客
05-17 230
二叉排序树的构建，查找，删除
c++ 数据结构——二叉树的构建及其应用，实现左右子树交换并输出前序递归结果
Arana的博客
04-06 3281
数据结构实习——二叉树及其应用 一、实习题目及要求 1、题目： 二叉树基本算法的实现 2、功能要求： （1）键盘输入二叉树结点前序序列，创建一棵二叉树； （2）实现SwapTree方法，以根结点为参数，交换每个结点的左子树和右子树（提示：前序递归）； （3）实现Find方法，查找值为key的结点，并输出该结点的所有祖先结点。 3、创建要求： （1）要求键盘输入二叉树前序序列（程序5.12） （2...
二叉树的遍历及其应用C/C++代码实现
Ycy的博客
06-08 8099
二叉树的存储结构： 顺序存储：只适合完全二叉树。 链式存储：利用这种结点结构所得二叉树的存储结构分别称之为二叉链表和三叉链表。 二叉树的遍历： 规定先左后右，按照根结点的访问次序可分为先（根） 序遍历、中（根） 序遍历和后（根） 序遍历。 先序遍历序列：ABCDEGF 中序遍历序列：CBEGDFA 后序遍历序列：CGEFDBA 注意： 另外由二叉树的先序序列和中序序列，或由其后序序列和中序序列均能唯一地确定一棵二叉树。 但先序序列和后序序列不能唯一确定一棵二叉树。 遍历的应用： 1，建立二叉链表 2，复
数据结构英文版教案（c++）
11-19
本教程是英文版的数据结构教案，基于C++编程语言，旨在帮助学生和开发者深入理解各种数据结构及其应用。以下是教程涵盖的主要知识点： 1. **栈**：栈是一种后进先出（LIFO）的数据结构，类似于一个堆叠的盘子。它...
《数据结构（C++版）》的配套盘
07-17
这个压缩包包含了丰富的材料，旨在帮助读者更好地掌握数据结构的基本概念、设计和实现，以及如何用C++语言进行有效表达。 首先，我们来看“算法分析”部分。这部分可能包含了一系列关于数据结构核心算法的详细解释...
C++数据结构第三版
01-24
红黑树是一种自平衡的二叉查找树，能保证在最坏情况下的搜索、插入和删除操作的效率。 3. **图**：图结构用于表示对象之间的复杂关系，如邻接矩阵和邻接表是常见的图存储方式。遍历算法如深度优先搜索（DFS）和广度...
tree(c++ tree容器)
12-04
标题提到的"tree(c++ tree容器)"是一个第三方实现，旨在为C++开发者提供一个类似于STL接口的树容器，方便用户在项目中构建和操作树形数据。 这个源码库的亮点在于它的用法与C++标准库中的其他容器类似，如vector和...
C++实现二叉搜索树
Ly的博客
04-30 1168
二叉搜索树是一种特别有用的数据结构，AVL树，红黑树的原型都是二叉搜索树。本文将会对二叉搜索树进行初步介绍，从而入门二叉搜索树，为以后深入学习AVL树和红黑树打下基础。
C++二叉搜索树BinarySearchTree
最新发布
学习C++的小陈同学
11-03 123
本章介绍了搜索二叉树的特性，并且用C++模拟实现，详细分析了代码思路
二叉搜索树(C++实现)
qq_56628506的博客
08-22 2697
二叉搜索树初探
C++搜索二叉树
RXY24601的博客
05-27 1274
C++搜索二叉树，包括搜索二叉树的增删查，key-value模型的介绍及实现，搜索二叉树效率分析
【C++】二叉搜索树
m0_62179366的博客
10-24 1946
二叉搜索树的简单应用及实现。
C++——二叉搜索树
weixin_49449676的博客
11-30 1891
若要删除8，这里采用右树最左节点的替换法，右树的最左节点就是10自己，如果这样写会有错误，while循环都不会进去，minparent就是空，而后面minParent->_left = min->_right;用左子树的最大节1点或右子树的最小节点4，若采用右树的最小节点，交换3和4删除4之后，删除3，但还有一个子节点5，我们让5成为6的左节点。若果要删除跟节点，而且左为空，若要删除8，我们更新根节点即可，让根节点指向10。若果要删除跟节点，而且右为空，若要删除8，让根节点指向3即可。
二叉搜索树详解（C++实现）
沐白白的博客
04-14 1206
二叉搜索树的定义 二叉搜索树，也称有序二叉树,排序二叉树，是指一棵空树或者具有下列性质的二叉树： 若任意节点的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若任意节点的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 任意节点的左、右子树也分别为二叉查找树。 没有键值相等的节点。 二叉搜索数中序遍历为有序数组 一、查找二叉搜索树中的某个元素 在二叉搜索树b中查找x的过程为： 若b是空树，则搜索失败，否则： 若x等于b的根节点的数据域之值，则查找成功；否则： 若x小于b的根节点的
【C++ STL】-- 二叉搜索树
weixin_64609308的博客
11-25 2131
详细配图讲解：搜索二叉树的构建与函数接口实现
二叉搜索树 c++怎么实现
03-29
二叉搜索树（Binary Search Tree，BST）可以通过链式存储结构实现。其节点结构体定义如下： ``` typedef struct TreeNode{ int data; struct TreeNode *left; struct TreeNode *right; }TreeNode; ``` 其中，`...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值