C++数据结构：二叉搜索树的原理以及实现

最新推荐文章于 2024-10-22 21:45:02 发布
原创 最新推荐文章于 2024-10-22 21:45:02 发布 · 441 阅读 · 5 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#数据结构 #KV模型 #二叉搜索树

本文深入探讨了二叉搜索树的基本概念、实现方法及其在K模型和KV模型中的应用，同时分析了二叉搜索树的性能特点。
前言

我们今天在二叉树的基础上来梳理学习二叉搜索树的相关知识点，二叉搜索树也常被归类为一种搜索算法，并且在后续map和set的学习中需要二叉搜索树作为铺垫，有助于我们理解map和set的特性，不仅如此，二叉搜索树自身也是有着非常多的特性和优势。

一：二叉搜索树的概念

二叉搜索树（Binary Search Tree）又称二叉排序树和二叉查找树。它可以是一颗空树，也可以是具有以下性质的二叉树：

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

图解：

在这里插入图片描述

二：二叉搜索树的实现

BST.hpp：

实现了二叉搜索树的插入、查找、删除等功能，具体注意的点：

#pragma once
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{
	typedef BSTreeNode<K> Node;
public:
	bool Insert(const K& key){
		if (_root == nullptr){
			_root = new Node(key);
			return true;
		}
		// parent起到连接新结点的作用
		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);
		// 连接
		if (parent->_key < key){
			parent->_right = cur;
		}
		else{
			parent->_left = cur;
		}
		return true;
	}

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

	// 删除的结点存在左右孩子
	// 则找左子树的最右结点或右子树的最左结点进行替代
	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{
				// 找到了需要删除的结点
				// 需要判断cur是parent的左孩子还是右孩子
				if (cur->_left == nullptr){
					// 被删除的结点是根结点
					if (cur == _root){
						_root = cur->_right;
					}
					// 被删除的结点存在父结点
					else{
						if (parent->_right == cur){
							parent->_right = cur->_right;
						}
						else{
							parent->_left = cur->_right;
						}
					}
					delete cur;
				}
				else if (cur->_right == nullptr){
					if (cur == _root){
						_root = cur->_left;
					}
					else{
						if (parent->_right == cur){
							parent->_right = cur->_left;
						}
						else{
							parent->_left = cur->_left;
						}
					}
					delete cur;
				}
				else{
					// 替代
					Node* rightMinParent = cur;
					Node* rightMin = cur->_right;
					// 若while循环没有进入则Parent就会为nullptr
					// 初始化时Parent就为cur
					while (rightMin->_left){
						rightMinParent = rightMin;
						rightMin = rightMin->_left;
					}
					// 替代删除结点
					cur->_key = rightMin->_key;
					// 删除rightMin
					// 右子树的最左结点可能是父结点的右孩子
					if (rightMin == rightMinParent->_left){
						rightMinParent->_left = rightMin->_right;
					}
					else{
						rightMinParent->_right = rightMin->_right;
					}
					delete rightMin;
				}
				return true;
			}
		}
		return false;
	}

	void _Inorder(Node* root){
		if (root == nullptr){
			return;
		}
		_Inorder(root->_left);
		cout << root->_key << " ";
		_Inorder(root->_right);
	}

	void Inorder(){
		_Inorder(_root);
		cout << endl;
	}
private:
	Node* _root = nullptr;
};

void TestBSTree(){
	BSTree<int> tree;
	int array[] = { 5, 3, 4, 1, 7, 8, 2, 6, 0, 9 };
	for (const auto& e : array){
		tree.Insert(e);
	}
	tree.Inorder();
	tree.Erase(7);
	tree.Inorder();
}

三：二叉搜索树的应用

3.1 K模型

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

比如：给一个单词word，判断该单词是否拼写正确，具体方式如下：

  1. 以单词集合中的每个单词作为key，构建一棵二叉搜索树。
  2. 在二叉搜索树中检索该单词是否存在，存在则拼写正确，不存在则拼写错误。
3.2 KV模型

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

比如：实现一个简单的英汉词典，可以通过英文找到与其对应的中文，具体实现方式如下：

  1. <英文单词，中文含义>为键值对构造二叉搜索树。
  2. 查询英文单词时，只需给出英文单词，就可快速找到与其对应的中文含义。

KV模型的实现：

#pragma once
template<class K,class V>
struct BSTreeNode{
	BSTreeNode<K,V>* _left;
	BSTreeNode<K,V>* _right;
	K _key;
	V _value;

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

template<class K, class V>
class BSTree{
	typedef BSTreeNode<K, V> Node;
public:
	bool Insert(const K& key, const V& value){
		if (_root == nullptr){
			_root = new Node(key,value);
			return true;
		}
		// parent起到连接新结点的作用
		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;
	}

	// 删除的结点存在左右孩子
	// 则找左子树的最右结点或右子树的最左结点进行替代
	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{
				// 找到了需要删除的结点
				// 需要判断cur是parent的左孩子还是右孩子
				if (cur->_left == nullptr){
					// 被删除的结点是根结点
					if (cur == _root){
						_root = cur->_right;
					}
					// 被删除的结点存在父结点
					else{
						if (parent->_right == cur){
							parent->_right = cur->_right;
						}
						else{
							parent->_left = cur->_right;
						}
					}
					delete cur;
				}
				else if (cur->_right == nullptr){
					if (cur == _root){
						_root = cur->_left;
					}
					else{
						if (parent->_right == cur){
							parent->_right = cur->_left;
						}
						else{
							parent->_left = cur->_left;
						}
					}
					delete cur;
				}
				else{
					// 替代
					Node* rightMinParent = cur;
					Node* rightMin = cur->_right;
					// 若while循环没有进入则Parent就会为nullptr
					// 初始化时Parent就为cur
					while (rightMin->_left){
						rightMinParent = rightMin;
						rightMin = rightMin->_left;
					}
					// 替代删除结点
					cur->_key = rightMin->_key;
					// 删除rightMin
					// 右子树的最左结点可能是父结点的右孩子
					if (rightMin == rightMinParent->_left){
						rightMinParent->_left = rightMin->_right;
					}
					else{
						rightMinParent->_right = rightMin->_right;
					}
					delete rightMin;
				}
				return true;
			}
		}
		return false;
	}

	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;
	}
private:
	Node* _root = nullptr;
};

void TestBSTree(){
	BSTree<string, string> dict;
	dict.Insert("sort", "排序");
	dict.Insert("string", "字符串");
	dict.Insert("tree", "树");
	dict.Insert("insert", "插入");

	string str;
	while (cin >> str){
		// 查找
		BSTreeNode<string, string>* ret = dict.Find(str);
		if (ret != nullptr){
			cout << ret->_value << endl;
		}
		else{
			cout << "未找到" << endl;
		}
	}

	// 统计水果出现的次数
	string strArray[] = { "西瓜", "苹果", "樱桃", "西瓜", "樱桃" };
	BSTree<string, int> countTree;
	for (auto str: strArray){
		BSTreeNode<string, int>* ret = countTree.Find(str);
		if (ret == nullptr){
			countTree.Insert(str, 1);
		}
		else{
			ret->_value++;
		}
	}
	countTree.Inorder();
}

四：二叉搜索树的性能

若插入的数据是有序或者接近有序时，二叉搜索树会从普通的二叉树结构化为单支树的形式，这样二叉搜索树的效率就没有办法保证。

最优情况下，二叉搜索树为完全二叉树，其平均比较次数为：log2^N

最差情况下，二叉搜索树退化为单支树，其平均比较次数为：N/2

注意：二叉搜索树中Key是不允许修改的，可能会破坏二叉搜索树的性质。

数据结构与算法——二叉查找树类的C++实现
Be The Best！
04-07 3390
二叉树的平均深度为O(logN)； 二叉查找树在二叉树的基础上，增加的性质为：对于树中每一个结点X，它的左子树中所有项的值小于X中的项，而它的右子树中
C++ 实现二叉排序树（二叉查找树）
qq_41220807的博客
06-15 3740
C++ 实现二叉排序树（二叉查找树） 二叉排序树( Binary Sort Tree)，又称为二叉查找树。它或者是一棵空树，或者是具有下列性质的二叉树。 若它的左子树不空，则左子树上所有结点的值均小于它的根结构的值; 若它的右子树不空，则右子树上所有结点的值均大于宫的根结点的值; 它的左、右子树也分别为二叉排序树。 查找、插入与生成操作 #include <iostream&...
C++ 数据结构 二叉排序树/二叉查找树
weixin_44062380的博客
06-16 3475
数据结构 二叉排序树前言概念介绍二叉排序树存在意义的思考操作以及代码展示插入元素查找元素删除元素二叉排序树的优缺点及解决方法优点缺点解决方案 前言 今天在学习红黑树的时候，看到了引导课拿二叉排序树举例，想到之前还没写过二叉排序树的代码，所以这次特地写了一下，这里把二叉排序树的性质和写代码时出现的问题做一个分享。 概念 介绍 在写之前，要先了解什么是二叉排序树 二叉查找树，它有一个根节点，且每个节点下最多有只能有两个子节点，左子节点的值小于其父节点，右子节点的值大于其父节点。 我们依次插入数据：43,98,
[源码和文档分享]基于C++实现的二叉排序树
qq_38474647的博客
12-11 275
一、使用说明 1.1 项目简介 依次输入关键字并建立二叉排序树，实现二叉排序树的插入和查找功能。 1.2 项目功能要求 二叉排序树就是指将原来已有的数据根据大小构成一棵二叉树，二叉树中的所有结点数据满足一定的大小关系，所有的左子树中的结点均比根结点小，所有的右子树的结点均比根结点大。 二叉排序树查找是指按照二...
二叉搜索树基本操作原理与C++实现
u013482632的博客
02-23 196
二叉搜索树 二叉搜索树为一种特殊的二叉树，除二叉树的性质外，其特有的性质为： 对于树中每个节点X，其左子树中所有项的值均小于X项中的值，且其右子树中所有项的值均大于X中的值。 二叉搜索树除二叉树的遍历操作外，还需掌握的操作有：查找节点、插入节点和删除节点。查找节点包括查找一棵树的最大值、最小值、指定值。二叉树的四种遍历方式的介绍与实现想了解的小伙伴儿们可以参看我之前的博客二叉树遍历原理及C++实现...
C++：二叉搜索树模拟实现（KV模型）
Zhenyu_Coder的博客
02-08 4017
二叉搜索树又称二叉排序树，作为map、set以及红黑树的底层数据结构基础，对于后续模拟实现封装相关解决具体重要意义。同时二叉搜索树分为Key模型和KV模型，在生活中也具有广泛应用，比如英汉字典，通过英文查找对应中文等等。本篇博客将着手二叉搜索树的底层原理，模拟实现二叉搜索树。
【C++、数据结构】二叉排序树（二叉查找树、二叉搜索树）（图解+完整代码）
最新发布
金哥的博客
10-22 2321
二叉搜索树/二叉排序树/二叉查找树：创建、插入、查找、删除（非递归以及递归版本代码），以及超详细步骤图解
C++实现数据结构：深入二叉搜索树算法解析
在C++中实现二叉搜索树，通常需要定义一个树节点的结构体，并为二叉搜索树定义基本的操作函数。以下是一个简单的结构体和插入函数的示例： ```cpp struct TreeNode { int value; // 节点存储的值 TreeNode* left;...
C++：二叉搜索树
2302_79054145的博客
06-06 1064
关于数据结构中的树，想必都不会很陌生，今天，主要给大家一起学习搜索二叉树（BST）前面，我们掌握学习过二叉树的三种遍历方式（前序，中序，后序的递归版本），以及我们实现过顺序结构的树（堆），前面的树在储存数据方面，并没有多大的意义，而今天所说的二叉搜索树在数据存储方面就有了很大的意义。
二叉搜索树查找算法【实现】.rar_C++_C++ 二叉搜索树_organizationzme
09-23
C++实现二叉搜索树查找算法主要涉及以下几个核心概念： 1. **节点定义**：首先，我们需要定义一个二叉搜索树的节点结构。这个结构通常包括键值、指向左右子节点的指针以及可能的额外信息，如指向父节点的指针等。 ...
C++实现二叉排序树
Jinyao的博客
12-20 1087
C++实现二叉排序树 1.定义 二叉排序树（Binary Sort Tree），又称二叉查找树（Binary Search Tree），亦称二叉搜索树。 二叉排序树或者是一棵空树，或者是具有下列性质的二叉树： （1）若左子树不空，则左子树上所有结点的值均小于它的根结点的值； （2）若右子树不空，则右子树上所有结点的值均大于它的根结点的值； ...
C++数据结构 之 二叉搜索树_Binary Search Tree
liu798675179的专栏
08-18 926
C++数据结构 之 二叉搜索树_Binary Search Tree源代码只包含头文件注：需要C++11的支持
数据结构——二叉树：二叉搜索树（C++）
Hodge_Z的博客
12-30 409
内容概要： 二叉搜索树的相关概念 实现二叉搜索树时注意事项 code:Node类，BST类，测试函数 一、相关概念 二叉搜索树（Binary Search Tree，简称BST）：也称二叉查找树，二叉排序树等。特点：对于其中的任一节点，设其值为k，该节点左子树任一节点的值都小于k；该节点右子树任一节点的值都大于或等于k（也有版本认为BST中不存在键值相等的节点）。 节点的前驱：是该节点的...
java二叉搜索树原理与实现
MojxTang_Blog
12-15 371
计算机里面的数据结构 树 在计算机存储领域应用作用非常大，我之前也多次强调多磁盘的存取速度是目前计算机飞速发展的一大障碍，计算机革命性的的下一次飞跃就是看硬盘有没有质的飞跃，为什么这么说？因为磁盘是永久性存储设备（在相当长的时间内都可以用），就这一点虽然内存在性能方面优势巨大但是保存信息和数据还是要靠磁盘。 数最成功的要数B+tree和LSM-tree了，在关系型数据库和非关系型数据库（Nosq...
数据结构之二叉搜索树的简单实现(C++实现）
qq_41041406的博客
12-23 251
功能 插入：insert() 查找：search() 删除：erase()（用erase命名感觉用意不太符合，但方便以后添加一个删除多个值的重载函数） 清除整个树：clear() 最大值：max() 最小值：min() 前序遍历：PreOrder() 中序遍历：InOrder() 后序遍历：PostOrder() 注：此二叉树允许插入相同的值，且默认将其放在右子树，因此以后会考虑写unique()...
构造二叉搜索树C++
繁小华的专栏
04-08 1120
构造一颗二叉搜索树，树的结构如图（a），下面上代码（最后输出是中序遍历输出的） #include using namespace std; typedef struct BSTree { char node_value; struct BSTree *left; struct BSTree *right; } Tree; /*****构造二叉查找树*******************
C++实现二叉搜索树
weixin_44132627的博客
07-14 2207
一、 概念 1. 性质 二叉搜索树是数据结构中树形结构一种。它或者是一棵空树，或者具有以下特性： a.若它的左子树不为空，则左子树上所有节点的值都小于根节点的值 b.若它的右子树不为空，则右子树上所有节点的值都大于根节点的值 c.它的左、右子树也分别为二叉搜索树 下图1 为一个搜索二叉树： 图1 二叉搜索树实例 对这个二叉树进行中序遍历的结果为：0 1 2 3 ...
使用C++实现二叉搜索树的数据结构
weixin_30535843的博客
03-29 1843
需要注意的地方： ①二叉搜索树删除一个指定结点R，若R为叶子结点，则将R的父结点中指向R的指针改为指向nullptr；若R的左右子结点一个为空，一个非空，则将R的父结点中指向R的指针改为指向R的非空子结点；若R有两个非空子结点，则找出R的右子树中的最小值结点，将其删除并将R的值置为该最小值结点的值。 ②对二叉搜索树进行中序遍历，将得到按升...
二叉搜索树原理及操作
H48530的博客
04-09 654
二叉搜索树原理构建二叉搜索树查找插入删除 原理 二叉搜索树（Binary Search Tree BST） 又称为二叉排序树，它是一颗空树或者具有以下性质： 它的左子树不为空，则左子树上所有节点的值都小于根节点的值 它的右子树不为空，则右子树上所有节点的值都大于根节点的值 它的左右子树也是二叉搜索树 简单来说： 每个结点， 节点左子树中所有的key值，都小于节点的key值； 节点右子树中所有的key值，都大于节点的key值 所以：二叉搜索树的中序遍历，一定有序 构建二叉搜索树 节点： publi
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值