二叉搜索树/二叉排序树（代码实现）（c++）

最新推荐文章于 2024-07-18 22:05:06 发布
最新推荐文章于 2024-07-18 22:05:06 发布
阅读量1.3k 收藏 24
点赞数 16
分类专栏： C++ 数据结构 文章标签： c++ 数据结构 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45153969/article/details/135422218
版权

BSTree

二叉排序树概念

二叉搜索树又称二叉排序树（BSTree, Binary Search Tree），它或者是一颗空树，或者是具有以下性质的二叉树：

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

在这里插入图片描述

代码部分

BSTree框架

//创建二叉树结点
template<class K>
struct BSTNode
{
	struct BSTNode<K>* _left;
	struct BSTNode<K>* _right;
	K _key;

	//构造函数
	BSTNode(const K& key)
		:_key(key)
		,_left(nullptr)
		,_right(nullptr)
	{}
};


template<class K>
class BSTree
{
	typedef BSTNode<K> Node;
	//.....
	private:
	Node* _root = nullptr;
};

查找操作

a、从根开始比较，查找，比根大往右走查找，比根小往左走。
b、最多查找高度次，走到空，还没找到，这个值就不存在。

非递归：

	//查找
	bool Find(const K& key)
	{
		Node* cur = _root;
		while (cur)
		{
			if (cur->_key > key) cur = cur->_left;
			else if (cur->_key < key) cur = cur->_right;
			else return true;
		}
		return false;
	}

递归：利用树的特性。

//暴露接口的函数
	bool EFind(const K& key)
	{
		return _EFind(_root, key);
	}
	
	bool _EFind(Node* root, const K& key)
	{
		if (root == nullptr)
			return false;
		if (root->_key > key)  
		{
			return _EFind(root->_left, key);
		}
		else if (root->_key < key)
		{
			return _EFind(root->_right, key);
		}
		else
		{
			return true;
		}
	}

插入操作

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

非递归：

	//插入
	bool Insert(const K& key)
	{
		//空
		if (nullptr == _root)
		{
			_root = new Node(key);
			return true;
		}
		//不空
		Node* cur = _root;
		Node* parent = nullptr;
		while (cur)
		{
			if (cur->_key < key)
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (cur->_key > key)
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				return false;
			}
		}
		//找到插入位置
		if (parent->_key > key)
		{
			//左边插入
			parent->_left = new Node(key);
		}
		else
		{
			//右边插入
			parent->_right = new Node(key);
		}

		return true;
	}

递归版本：利用指针的引用！！

	bool EInsert(const K& key)
	{
		return _EInsert(_root, key);
	}

	//指针的引用！！！
	bool _EInsert(Node*& root, const K& key)
	{
		if (root == nullptr)
		{
			root = new Node(key);
			return true;
		}
		if (root->_key > key)
			return _EInsert(root->_left, key);
		else if (root->_key < key)
			return _EInsert(root->_right, key);
		else  //相等
		{
			return false;
		}
	}

删除操作**

首先查找元素是否在二叉搜索树中，若不存在，则返回，否则要删除的结点可能分下面四种情况：
a. 要删除的结点无孩子结点
b.要删除的结点只有左孩子
c.要删除的结点只有右孩子
d.要删除的结点有左、右孩子结点
表面上有四种，但是实际上情况a可以与b、c情况合并，因此真正删除的情况如下：

  • 情况b：删除该节点且使被删除结点的双亲结点指向被删除结点的左孩子结点
    在这里插入图片描述

  • 情况c：删除该结点，并且使被删除结点的双亲结点指向被删除结点的右孩子结点。
    在这里插入图片描述

  • 情况d：找到被删除结点中序遍历的前一个（或者后一个）结点，将他们俩的值交换，交换后的那个结点。就变成了b\c两种情况。

在这里插入图片描述

非递归版本：

	//删除
	bool Erase(const K& key)
	{
		Node* parent = nullptr;
		Node* cur = _root;
		//先找要删除的结点
		while (cur)
		{
			if (cur->_key > key)
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (cur->_key < key)
			{
				parent = cur;
				cur = cur->_right;
			}
			else//找到了
			{
				//左右孩子都没有，就是叶子，其实可以和b、c两种情况合并
				if (cur->_left == nullptr && cur->_right == nullptr)
				{
					if (cur == _root)
					{
						_root = nullptr;
					}
					else if (parent->_left == cur)
					{
						parent->_left = nullptr;
					}
					else if (parent->_right == cur)
					{
						parent->_right = nullptr;
					}
					delete cur;
				}
				else  //不是叶子
				{
					//只有左为空
					if (cur->_left == nullptr)
					{
						if (parent == nullptr)   //防止最开始找到parent为空
						{
							_root = cur->_right;
						}
						else
						{
							if (parent->_left == cur)
							{
								parent->_left = cur->_right;
							}
							else if (parent->_right == cur)
							{
								parent->_right = cur->_right;
							}
						}

						delete cur;
					}
					//只有右为空
					else if (cur->_right == nullptr)
					{
						if (parent == nullptr)  //防止最开始找到parent为空
						{
							_root = cur->_left;
						}
						else
						{
							if (parent->_left == cur)
							{
								parent->_left = cur->_left;
							}
							else if (parent->_right == cur)
							{
								parent->_right = cur->_left;
							}
						}

						delete cur;
					}
					//左右都不为空， 找右子树的最左结点代替
					else
					{
						parent = cur;
						Node* p = cur->_right;
						while (p->_left)  //找紧挨着的结点作替换
						{
							parent = p;
							p = p->_left;
						}
						cur->_key = p->_key;
						if (parent->_left == p)
							parent->_left = p->_right;
						else if (parent->_right == p)
							parent->_right = p->_right;
						delete p;
					}
				}
				return true;
			}
		}
		return false;
	}

递归版本：该思路很巧妙，注意学习

	bool EErase(const K& key)
	{
		return _Erase(_root, key);
	}

	bool _Erase(Node*& root, const K& key)
	{
		//先找key
		if (root == nullptr)
		{
			return false;
		}

		if (root->_key > key)
		{
			return _Erase(root->_left, key);
		}
		else if (root->_key < key)
		{
			return _Erase(root->_right, key);
		}
		else
		{
			//找到了
			Node* del = root;
			if (root->_left == nullptr)
			{
				root = root->_right;
			}
			else if (root->_right == nullptr)
			{
				root = root->_left;
			}
			else
			{
				// 左右都不为空,找左子树最右边的
				Node* minNode = root->_left;
				while (minNode->_right)
				{
					minNode = minNode->_right;
				}
				swap(root->_key, minNode->_key);
				//交换完删再删除结点，精华部分
				return _Erase(root->_left, key);
			}
			delete del;
			return true;
		}
	}

默认成员函数

//构造函数
	//BSTree():_root(nullptr){}
	BSTree() = default;  //强制生成默认构造函数

//拷贝构造
	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;
	}


//赋值运算符重载
	BSTree<K>& operator=(BSTree<K> t)
	{
		swap(_root, t._root);
		return *this;
	}
	
//析构
	~BSTree()
	{
		Destory(_root);
	}
	void Destory(Node*& root)
	{
		//后续递归
		if (root == nullptr)
		{
			return;
		}
		Destory(root->_left);
		Destory(root->_right);
		delete root;
		root = nullptr;
	}

完整代码

//BSTree.h



#pragma once
//创建二叉树结点
template<class K>
struct BSTNode
{
	struct BSTNode<K>* _left;
	struct BSTNode<K>* _right;
	K _key;

	//构造函数
	BSTNode(const K& key)
		:_key(key)
		,_left(nullptr)
		,_right(nullptr)
	{}
};

template<class K>
class BSTree
{
	typedef BSTNode<K> Node;
public:

	//BSTree():_root(nullptr){}

	BSTree() = default;  //强制生成默认构造函数


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

	//赋值运算符重载
	BSTree<K>& operator=(BSTree<K> t)
	{
		swap(_root, t._root);
		return *this;
	}

	~BSTree()
	{
		Destory(_root);
	}

	//插入
	bool Insert(const K& key)
	{
		//空
		if (nullptr == _root)
		{
			_root = new Node(key);
			return true;
		}
		//不空
		Node* cur = _root;
		Node* parent = nullptr;
		while (cur)
		{
			if (cur->_key < key)
			{
				parent = cur;
				cur = cur->_right;
			}
			else if (cur->_key > key)
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				return false;
			}
		}
		//找到插入位置
		if (parent->_key > key)
		{
			//左边插入
			parent->_left = new Node(key);
		}
		else
		{
			//右边插入
			parent->_right = new Node(key);
		}

		return true;
	}
	
	bool EInsert(const K& key)
	{
		return _EInsert(_root, key);
	}



	bool EFind(const K& key)
	{
		return _EFind(_root, key);
	}



	bool EErase(const K& key)
	{
		return _Erase(_root, key);
	}


	//查找
	bool Find(const K& key)
	{
		Node* cur = _root;
		while (cur)
		{
			if (cur->_key > key) cur = cur->_left;
			else if (cur->_key < key) cur = cur->_right;
			else return true;
		}
		return false;

	}

	//删除
	bool Erase(const K& key)
	{
		Node* parent = nullptr;
		Node* cur = _root;
		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 && cur->_right == nullptr)
				{
					if (cur == _root)
					{
						_root = nullptr;
					}
					else if (parent->_left == cur)
					{
						parent->_left = nullptr;
					}
					else if (parent->_right == cur)
					{
						parent->_right = nullptr;
					}
					delete cur;
				}
				else  //不是叶子
				{
					//只有左为空
					if (cur->_left == nullptr)
					{
						if (parent == nullptr)   //防止最开始找到parent为空
						{
							_root = cur->_right;
						}
						else
						{
							if (parent->_left == cur)
							{
								parent->_left = cur->_right;
							}
							else if (parent->_right == cur)
							{
								parent->_right = cur->_right;
							}
						}

						delete cur;
					}
					//只有右为空
					else if (cur->_right == nullptr)
					{
						if (parent == nullptr)  //防止最开始找到parent为空
						{
							_root = cur->_left;
						}
						else
						{
							if (parent->_left == cur)
							{
								parent->_left = cur->_left;
							}
							else if (parent->_right == cur)
							{
								parent->_right = cur->_left;
							}
						}

						delete cur;
					}
					//左右都不为空， 找右子树的最左结点代替
					else
					{
						parent = cur;
						Node* p = cur->_right;
						while (p->_left)
						{
							parent = p;
							p = p->_left;
						}
						cur->_key = p->_key;
						if (parent->_left == p)
							parent->_left = p->_right;
						else if (parent->_right == p)
							parent->_right = p->_right;
						delete p;
					}

					


				}
				return true;

				
			}

		}
		return false;
		

	}
	void InOrder()
	{
		_InOrder(_root);
	}


protected:

	void Destory(Node*& root)
	{
		//后续递归
		if (root == nullptr)
		{
			return;
		}
		Destory(root->_left);
		Destory(root->_right);
		delete root;
		root = nullptr;
	}


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

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

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


	//指针的引用！！！
	bool _EInsert(Node*& root, const K& key)
	{
		if (root == nullptr)
		{
			root = new Node(key);
			return true;
		}
		if (root->_key > key)
			return _EInsert(root->_left, key);
		else if (root->_key < key)
			return _EInsert(root->_right, key);
		else  //相等
		{
			return false;
		}
	}



	bool _Erase(Node*& root, const K& key)
	{
		//先找key
		if (root == nullptr)
		{
			return false;
		}

		if (root->_key > key)
		{
			return _Erase(root->_left, key);
		}
		else if (root->_key < key)
		{
			return _Erase(root->_right, key);
		}
		else
		{
			//找到了
			Node* del = root;
			if (root->_left == nullptr)
			{
				root = root->_right;
			}
			else if (root->_right == nullptr)
			{
				root = root->_left;
			}
			else
			{
				// 左右都不为空,找左子树最右边的
				Node* minNode = root->_left;
				while (minNode->_right)
				{
					minNode = minNode->_right;
				}
				swap(root->_key, minNode->_key);
				//交换完删再删除结点
				return _Erase(root->_left, key);
			}
			delete del;
			return true;
		}
	}
private:
	Node* _root = nullptr;
};

BSTree性能分析

在这里插入图片描述
最好的情况如左图：插入删除效率都是O（logn）
最坏的情况如右图：插入删除效率是O（n）,这样就失去了二叉树的优点。

因此后面会介绍AVL树和红黑树！！

羊羊羊i
关注
  • 16
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉排序树(完整代码)
繁凡さん的博客
01-23 1935
目录二.二叉排序树1.二叉排序树(代码)P1087 FBI树 (建树)HDU 4707 Pet 二.二叉排序树 先序遍历：根->左->右 中序遍历：左->根->右 后序遍历：左->右->根 1.二叉排序树(代码) 输入 7 5 4 3 3 3 2 1 输出 1 2 3 3 3 4 5 //二叉排序树（左<根<右） #include<...
二叉排序树完整代码
qq_40258761的博客
04-06 1495
tree.h（存放函数声明）： #pragma once #include<vector> #include<iostream> using namespace std; typedef struct BiTree { //所用的二叉树数据结构 int key; ...
详解二叉查找树算法的实现
热门推荐
tanglinux
04-06 7万+
参考文献： 《数据结构（C语言版）》  严蔚敏 吴伟民 编著       开发平台：Ubuntu11.04     编译器：gcc version4.5.2 (Ubuntu/Linaro 4.5.2-8ubuntu4)       树（Tree）是n（n≥0）个结点的有限集。在任意一棵非空树中：（1）有且仅有一个特定的被称为根（Root）的结点；（2）当n>1时，其余结点可分为m（m>0
C++数据结构——二叉搜索树（详细图解，详细代码实现）
最新发布
Zfox的博客
07-18 1103
详细讲解了C++数据结构的二叉搜索树的实现
详解：二叉排序树（二叉查找树）的代码实现——Scala
XMZHSY的博客
09-04 2312
二叉排序树（Binary Sort Tree），又称二叉查找树（Binary Search Tree），亦称二叉搜索树。是数据结构中的一类。在一般情况下，查询效率比链表结构要高。 二叉排序树的定义 一棵空树，或者是具有下列性质的二叉树： （1）若左子树不空，则左子树上所有结点的值均小于它的根结点的值； （2）若右子树不空，则右子树上所有结点的值均大于它的根结点的值； （3）左、右子树也分别为二叉排序树； （4）没有键值相等...
二叉排序树C语言实现（超级详细代码）
nidayededaye2的博客
12-12 7242
今天来给大家讲解一下二叉排序树C语言代码实现 typedef int ElemType; // 自定义数据元素为整数。 // 二叉树的数据结构。 typedef struct BSTNode { ElemType data; // 存放结点的数据元素。 struct BSTNode* lchild; // 指向左子结点地址的指针。 struct BSTNode* rchild; // 指向右子结点地址的指针。 ..
二叉排序树C/C++代码实现
Ycy的博客
06-29 3103
二叉排序树(二叉查找树): 二叉排序树的一个重要性质：中序遍历一棵二叉 树时可以得到一个结点值递增的有序序列。 对于需要经常进行插入、 删除和查找运算的表，采用二叉排序树比较好 查找： 若二叉排序树为空，则查找失败，返回空指针。 若二叉排序树非空，将给定值key与根结点的关键字T->data.key进行比较： 1,若key等于T->data.key , 则查找成功,返回根结点地址； 2,若key小于T->data.key, 则递归查找左子树； 3,若key大于T->data.key
二叉排序树资源：可以实现排序功能，c++编写
05-29
二叉排序树（Binary Sort Tree，BST），也称为二叉查找树或二叉搜索树，是一种自平衡的二叉树数据结构，它在计算机科学中用于数据存储和检索。二叉排序树的主要特性是，每个节点的左子树只包含比当前节点值小的节点...
【数据结构】查找：动态查找表(二叉排序树/BST/二叉搜索树，平衡二叉树/AVL)
自律带来自由
08-20 3075
#笔记整理 动态查找表——基于树表的查找法 动态查找表的特点： 表结构本身在查找过程中动态生成，即对于给定值 key，若表中存在关键字等于 key 的记录，则查找成功，否则插入关键字等于 key 的记录。 动态查找表的主要运算 - 创建、销毁 - 查找、插入和删除 - 遍历 二叉排序树（二叉搜素树、二叉查找树）BST (Binary Sort Tree)/(Binary Search Tree)...
二叉排序树/平衡二叉树/哈夫曼树
chengxuyuanlee的博客
12-10 2190
本人将树相关知识总结为初、中、高三篇，本文属于树结构的中篇，主要阐述几种经典的树形结构，是继承树的基础知识之后，进行相关拓展那么本文将以三种典型的树形结构进行总结，从查找的角度来进行分析各个树型结构的区别与优势。 基础篇在：数据结构——树基础 （主要总结树、二叉树、线索二叉树、森林等基础相关知识） 二叉排序树 树表相关概念 二叉排序树定义 查找操作 插入操作 删除操作 查找效率分析 平衡二叉树 相关概念 平衡二叉树定义 平衡二叉树调整方法 创建、插入、删除 查找效率分析 ...
适合小白学习的C++二叉排序树.doc
05-29
### 适合小白学习的C++二叉排序树知识点详解 #### 一、二叉排序树简介 二叉排序树(Binary Search Tree, BST)，也称作二叉查找树或...以上内容涵盖了二叉排序树的基本概念及其在C++中的实现，希望对初学者有所帮助。
二叉查找树实现代码
12-09
二叉查找树的插入、搜索、删除、寻找前驱结点、寻找后继结点
二叉查找排序树的实现代码
05-30
最近在研究数据结构这本书，自己动手实现的一个二叉查找排序树的类BinSortTree，实现数据的插入，查找，删除，层序遍历，中序遍历等操作，熟悉数据结构的朋友都知道，根据二叉排序树的定义，中序遍历后得到的序列就是按照从小到大的顺序排列的，而最后删除二叉排序树的时候，要先删除子节点，才能删除父节点，其实就是一个后续遍历的过程。现在把代码分享一下，供大家参考学习。其实这个跟stl的set容器已经十分相似，只是set使用查找性能更优越的红黑树来实现
二叉排序树查找
11-08
第一行输入一个整数t，表示有t组测试数据 第二行起每三行表示一组数据 第1行为输入序列的元素个数：n 第2行为输入的序列：s1 s2 … sn 第3行为输入：sKey iKey dKey 第一行输出中序序列 第二行输出最小值、最大值 第三行输出查找sKey的结果 第四行输出查找后的中序序列 第五行输出插入iKey后的中序序列 第六行输出查找iKey的结果 第七行输出删除dKey后的中序序列 第八行输出查找dKey的结果 Sample Input 1 12 66 45 78 42 55 32 39 68 95 86 102 29 55 63 78 Sample Output 29 32 39 42 45 55 66 68 78 86 95 102 29 102 1 3 2 29 32 39 42 45 55 66 68 78 86 95 102 29 32 39 42 45 55 63 66 68 78 86 95 102 1 4 4 29 32 39 42 45 55 63 66 68 86 95 102 0 5 13
二叉排序树C实现代码
03-05
二叉排序树C语言的简单实现，包含如下操作： 1.创建二叉排序树； 2.销毁二叉排序树； 3.清空二叉排序树； 4.插入指点结点至二叉排序树； 5.删除二叉排序树指点结点； 5.获取二叉排序树指定结点； 6.获取二叉排序树根结点； 7.获取二叉排序树结点数； 8.获取二叉排序树高度； 9.获取二叉排序树度； 10.显示二叉排序树。
二叉排序树代码
天河水
07-01 504
<br />#include<iostream><br />#include<string><br />using namespace std;<br />const int MAX=9999;<br />class BNode<br />{<br /> public:<br />  BNode(){}<br />  BNode(int i):value(i),left(NULL),right(NULL){}<br />   ~BNode(){}<br />   <br />   BNode *left;<
二叉排序树 代码
weixin_34132768的博客
02-12 80
#include<bits_stdc++.h> #define max 50 using namespace std; typedef struct bstnode//BST结构 { int data; bstnode *lc; bstnode *rc; }bt,*bst; typedef struct avltnode//AVL { ...
二叉排序树
08-04 130
二叉排序树 Time Limit: 1000ms Memory limit: 65536K有疑问？点这里^_^ 题目描述 二叉排序树的定义是：或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 它的左、右子树也分别为二叉排序树。...
【数据结构】二叉排序树（查找+插入+删除+效率分析）完整代码+解析
m0_61628700的博客
05-13 1542
二叉排序树的定义又称二叉查找树（BST，Binary Search Tree）左子树结点值
C++实现：二叉搜索树的插入、删除与遍历
"C++实现二叉排序树，包括插入、删除和遍历操作。二叉排序树是一种特殊类型的二叉树，其中每个节点的左子树仅包含比其小的节点，而右子树包含大于它的节点。这使得在树中进行查找、插入和删除操作具有高效性。在C++...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值