二叉搜索树（BST）的模拟实现

最新推荐文章于 2024-08-27 20:47:22 发布
最新推荐文章于 2024-08-27 20:47:22 发布
阅读量685 收藏 8
点赞数 8
分类专栏： 数据结构与算法 文章标签： 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_56069910/article/details/132053956
版权

序言：

构造一棵二叉排序树的目的并不是为了排序，而是为了提高查找效率、插入和删除关键字的速度，同时二叉搜索树的这种非线性结构也有利于插入和删除的实现。

二叉搜索树的表示及相关算法_雨纷飞-CSDN博客

目录

（一）BST的定义

（二）二叉搜索树操作

1、BST的查找

2、BST的插入

3、BST的删除

（三）二叉排序树的实现（非递归）

1、查找实现

2、插入实现

3、删除实现

（四）二叉排序树的实现（递归）

1、查找操作

2、插入操作

3、删除操作

（五）其他操作

1、析构

2、构造和拷贝构造

3、赋值重载

（六）总结

（一）BST的定义

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

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

（二）二叉搜索树操作

我以下图这棵二叉树为例，给大家进行有关二叉树操作的讲解：

1、BST的查找

思想：

  1. 二叉搜索树的查找是从根节点开始的，沿某个分支逐层的向下比较的过程；
  2. 若二叉排序树非空，先将给定值与根节点的关键字进行比较，若相等则查找成功；
  3. 若不等，如果小于根节点的关键字，则在根节点的左子树上进行查找；
  4. 否则，就在根节点的右侧进行查找。这显然是一个递归的过程！！

举例：

  1. 例如，对于上述二叉树我想要查找值为【6】的结点。
  2. 首先 6 与根节点 8 进行比较，由于 6<8 ，因此需要在根节点8的左子树中继续查找；
  3. 由于 3<6，因此在结点 3 的右子树中进行查找，最后查询成功。

2、BST的插入

二叉排序树作为一种动态树表，其特点是树的结构通常不是一次生成的，而是在查找过程中存在关键字值等于给定值的结点时再进行插入的。

插入结点的过程如下：

  1. 若原二叉排序树为空，则直接插入；
  2. 否则，若关键字 k 小于根结点值左子树；
  3. 若关键字 k 大于根结点值，则插入到右子树；

插入的结点一定是一个新添加且是查找失败时的查找路径上访问的最后一个结点的左孩子或右孩子。

3、BST的删除

在二叉排序树中删除一个结点时，不能把以该结点为根的子树上的结点都删除，必须先删除结点从存储二叉排序树的链表上摘下，将因删除结点而断开的二叉链表重新链接起来，确保二叉排序树的性质不会丢失。

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

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

看起来有待删除节点有4中情况，实际情况a可以与情况b或者c合并起来，因此真正的删除过程
如下

  • 情况b：删除该结点且使被删除节点的双亲结点指向被删除节点的左孩子结点--直接删除
  • 情况c：删除该结点且使被删除节点的双亲结点指向被删除结点的右孩子结点--直接删除
  • 情况d：在它的右子树中寻找中序下的第一个结点(关键码最小)，用它的值填补到被删除节点中，再来处理该结点的删除问题--替换法删除

（三）二叉排序树的实现（非递归）

1、查找实现

代码如下:

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

2、插入实现

代码如下:

    //插入操作
	bool Insert(const K& key)
	{
		if (_root == nullptr)
		{
			_root = new Newnode(key);
			return true;
		}

		Newnode* parent = nullptr;
		Newnode* 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 Newnode(key);
		if (parent->_key < key)
		{
			parent->_right = cur;
		}
		else
		{
			parent->_left = cur;
		}

		return true;
	}

3、删除实现

代码如下:

//删除操作
	bool Erase(const K& key)
	{
		Newnode* parent = nullptr;
		Newnode* cur = _root;

		while (cur)
		{
			//存在左右结点的情况
			if (cur->_key < key) 
			{
				parent = cur;
				cur = cur->_right;
			}

			else if (cur->_key > key) 
			{
				parent = cur;
				cur = cur->_left;
			}

			else {
				//不存在左
				if (cur->_left == nullptr){
					if (cur == _root)
					{
						_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 (cur == _root)
					{
						_root = cur->_left;
					}
					else {
						if (parent->_left = cur)
						{
							parent->_left = cur->_left;
						}
						else
						{
							parent->_right = cur->_left;
						}
					}
					delete cur;
				}
				//左右均存在
				else {
					// 找右树最小节点替代，也可以是左树最大节点替代
					Newnode* pminRight = cur;
					Newnode* minRight = cur->_right;
					while (minRight->_left)
					{
						pminRight = minRight;
						minRight = minRight->_left;
					}

					cur->_key = minRight->_key;

					if (pminRight->_left == minRight) {
						pminRight->_left = minRight->_right;
					}
					else {
						pminRight->_right = minRight->_right;
					}
					delete minRight;
				}
				return true;
			}
		}
		return false;
	}

（四）二叉排序树的实现（递归）

递归实现都比较容易，只要大家掌握到了思想，我相信实现起来就是很容易的。

1、查找操作

    //查找操作
	bool _FindR(Newnode* root, const K& key)
	{
		if (root == nullptr)
			return false;

		if (root->_key == key)
			return true;

		if (root->_key < key)
			return _FindR(root->_right, key);
		else
			return _FindR(root->_left, key);
	}

2、插入操作

        //插入操作
		bool _InsertR(Newnode*& root, const K& key)
		{
			if (root == nullptr) {
				root = new Newnode(key);
				//root = new BSTree<K>(key);
				return true;
			}

			if (root->_key < key) {
				return _InsertR(root->_right, key);
			}
			else if (root->_key > key) {
				return _InsertR(root->_left, key);
			}
			else {
				return false;
			}
		}

验证操作：

3、删除操作

        //删除操作
		bool _EraseR(Newnode*& root,const K& key)
		{
			if (root == nullptr) {
				root = new Newnode(key);
				return true;
			}

			if (root->_key < key)
			{
				return _EraseR(root->_right, key);
			}
			else if (root->_key > key)
			{
				return _EraseR(root->_left, key);
			}
			else
			{
				Newnode* del = root;

				if (root->_left == nullptr)
				{
					root = root->_right;
				}
				else if (root->_right == nullptr)
				{
					root = root->_left;
				}
				else
				{
					Newnode* maxleft = root->_left;
					while (maxleft->_left)
					{
						maxleft = maxleft->_right;
					}
					swap(root->_key, maxleft->_key);

					return _EraseR(root->_left, key);
				}
				delete del;

				return true;
			}
		}

验证操作：

（五）其他操作

1、析构

析构同样的使用递归来进行解决（当然也可以使用循环）。具体如下

代码实现：

    //销毁操作
	void Destroy(Newnode*& root)
	{
		if (root == nullptr)
			return;

		Destroy(root->_left);
		Destroy(root->_right);

		delete root;
		root = nullptr;
	}

2、构造和拷贝构造

首先如果我想在搜索二叉树的对象进行拷贝构造能够实现吗？具体如下：

 【说明】

  1. 我们发现是可以的，虽然我们没写；
  2. 这是因为拷贝构造属于默认成员函数，编译器会自动生成（注意;默认生成是属于浅拷贝）

【注意】 

  • 需要注意：当我们写了析构函数之后程序就会出问题；
  • 因为搜索二叉树涉及资源申请，如果是浅拷贝，在析构的时候就会对一块空间析构两次

所以此时就需要写一个深拷贝的拷贝构造函数（递归版本）

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

	Newnode* newRoot = new Newnode(root->_key);
	newRoot->_left = Copy(root->_left);
	newRoot->_right = Copy(root->_right);
	return newRoot;
}

 此时因为有了拷贝构造，编译器就不会生成默认的构造函数了，就需要我们自己写（C++11提供了一个关键字——default，可以强制编译器生成默认构造）

BinarySearchTree() = default; // 制定强制生成默认构造

此时，它就会走初始列表用缺省值去初始化：

3、赋值重载

  • 最后实现一下赋值重载的操作：
BinarySearchTree<K>& operator=(BinarySearchTree<K> t)
{
	swap(_root, t._root);
	return *this;
}

代码演示：

【代码总结】

  • BSTree.h：
#pragma once

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

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


	template<class K>
	class BinarySearchTree
	{
		typedef BSTree<K> Newnode;
	public:

		BinarySearchTree() = default; // 制定强制生成默认构造

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

		BinarySearchTree(const BinarySearchTree<K>& t)
		{
			_root = Copy(t._root);
		}

		~BinarySearchTree()
		{
			Destroy(_root);
		}

		//插入操作
		bool Insert(const K& key)
		{
			if (_root == nullptr)
			{
				_root = new Newnode(key);
				return true;
			}

			Newnode* parent = nullptr;
			Newnode* 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 Newnode(key);
			if (parent->_key < key)
			{
				parent->_right = cur;
			}
			else
			{
				parent->_left = cur;
			}

			return true;
		}

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

		//删除操作
		bool Erase(const K& key)
		{
			Newnode* parent = nullptr;
			Newnode* cur = _root;

			while (cur)
			{
				//存在左右结点的情况
				if (cur->_key < key)
				{
					parent = cur;
					cur = cur->_right;
				}

				else if (cur->_key > key)
				{
					parent = cur;
					cur = cur->_left;
				}

				else {
					//不存在左
					if (cur->_left == nullptr) {
						if (cur == _root)
						{
							_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 (cur == _root)
						{
							_root = cur->_left;
						}
						else {
							if (parent->_left = cur)
							{
								parent->_left = cur->_left;
							}
							else
							{
								parent->_right = cur->_left;
							}
						}
						delete cur;
					}
					//左右均存在
					else {
						// 找右树最小节点替代，也可以是左树最大节点替代
						Newnode* pminRight = cur;
						Newnode* minRight = cur->_right;
						while (minRight->_left)
						{
							pminRight = minRight;
							minRight = minRight->_left;
						}

						cur->_key = minRight->_key;

						if (pminRight->_left == minRight) {
							pminRight->_left = minRight->_right;
						}
						else {
							pminRight->_right = minRight->_right;
						}
						delete minRight;
					}
					return true;
				}
			}
			return false;
		}

		///
		// 递归版本

		bool FindR(const K& key)
		{
			return _FindR(_root, key);
		}

		bool InsertR(const K& key)
		{
			return _InsertR(_root, key);
		}

		bool EraseR(const K& key)
		{
			return _EraseR(_root, key);
		}

		void InOrder()
		{
			_Inorder(_root);
			cout << endl;
		}

		protected:

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

				Newnode* newRoot = new Newnode(root->_key);
				newRoot->_left = Copy(root->_left);
				newRoot->_right = Copy(root->_right);
				return newRoot;
			}
			//销毁操作
		void Destroy(Newnode*& root)
		{
			if (root == nullptr)
				return;

			Destroy(root->_left);
			Destroy(root->_right);

			delete root;
			root = nullptr;
		}

		

		//查找操作
		bool _FindR(Newnode* root, const K& key)
		{
			if (root == nullptr)
				return false;

			if (root->_key == key)
				return true;

			if (root->_key < key)
				return _FindR(root->_right, key);
			else
				return _FindR(root->_left, key);
		}

		
		//插入操作
		bool _InsertR(Newnode*& root, const K& key)
		{
			if (root == nullptr) {
				root = new Newnode(key);
				return true;
			}

			if (root->_key < key) {
				return _InsertR(root->_right, key);
			}
			else if (root->_key > key) {
				return _InsertR(root->_left, key);
			}
			else {
				return false;
			}
		}


		//删除操作
		bool _EraseR(Newnode*& root, const K& key)
		{
			if (root == nullptr) {
				root = new Newnode(key);
				return true;
			}

			if (root->_key < key)
			{
				return _EraseR(root->_right, key);
			}
			else if (root->_key > key)
			{
				return _EraseR(root->_left, key);
			}
			else
			{
				Newnode* del = root;

				if (root->_left == nullptr)
				{
					root = root->_right;
				}
				else if (root->_right == nullptr)
				{
					root = root->_left;
				}
				else
				{
					Newnode* maxleft = root->_left;
					while (maxleft->_left)
					{
						maxleft = maxleft->_right;
					}
					swap(root->_key, maxleft->_key);

					return _EraseR(root->_left, key);
				}
				delete del;

				return true;
			}
		}

		

		//中序遍历
		void _Inorder(Newnode* root)
		{
			if (root == nullptr) {
				return;
			}

			_Inorder(root->_left);
			cout << root->_key << " ";
			_Inorder(root->_right);
		}


	private:
		Newnode* _root = nullptr;
	};

（六）总结

以上便是关于二叉搜索树的模拟实现。感谢大家的观看与支持！！！

起飞的风筝
关注
  • 8
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 10
    评论
专栏目录
关于二叉搜索树（BST）
weixin_45750950的博客
08-31 179
文章目录二叉搜索树的定义及性质定义性质二叉搜索树相关习题。验证二叉搜索树原题链接解法二叉搜索树的最小绝对差原题链接解法二叉搜索树中的众数原题链接解法暴力法利用二叉树的性质 二叉搜索树的定义及性质 定义 二叉搜索树（Binary Search Tree BST）是一种特殊的二叉树, 又称为排序二叉树，二叉查找树，二叉排序树。二叉查找树的递归定义如下： 要么二叉搜索树是一颗空树 要么二叉搜索树是由根节点，左子树，右子树组成，其中左子树和右子树都是二叉搜索树，且若左子树不空，左子树上所有节点的数据域均小于根节点
二叉搜索树BST的C++实现
liuchenjane的博客
11-05 6396
BST 包含的功能：插入，删除，查找，查找某一结点的后续和前驱，中序遍历和前序遍历 这里，用于实验的二叉树: //二叉搜索树BST #include #include using namespace std; class TreeNode{ public: int key; TreeNode* left; TreeNode* right; TreeNode* p;//
二叉树演示软件
09-11
本人在学习过程中编写的一个二叉树演示软件，功能齐全，但是逻辑还不是很清晰，可以拿来演示教学使用、自己学习使用。有需要代码的发邮件到447861996@qq.com 提供代码。可以进一步完善~~
二叉树简单模拟
理想流
06-21 735
package com.test.utils; /** * 二叉树模拟类 */ public class Tree { // 根节点 private TreeNode rootNode = new TreeNode(null, null, null); /** * 添加数据 */ public TreeNode add(Long data) { TreeNode no
【ZCMU1158】松哥的二叉树（模拟）
よろしくお願いします
08-21 572
题目链接 1158: 松哥的二叉树 Time Limit: 1 Sec  Memory Limit: 128 MB Submit: 54  Solved: 45 [Submit][Status][Web Board] Description 有一棵满二叉树，最大深度为D，且所有叶子的深度都相同。所有结点从上到下从左到右编号为1，2，3，…，2^D-1。松哥在结点1处放下一个小球，它会往下落...
模拟数据结构：二叉树
qq_44309181的博客
03-15 156
package com.zc.study; /** * @author zc * 二叉树模拟 * 包含了：二叉树的增删改查功能 */ public class BinaryTreeDemo { public static void main(String[] args) { Hero h1 = new Hero(1,"鸣人"); Hero h2 =...
二叉搜索树(Binary Seach Tree)模拟实现
m0_73904148的博客
06-04 434
二叉搜索树的模拟实现(增删查改)、二叉搜索树的性质、二叉搜索树的缺陷
树-98. 验证二叉搜索树-PYTHON
01-20
在二叉搜索树（Binary Search Tree，BST）中，每个节点的值必须满足以下规则：对于任意节点，其左子树中的所有节点的值都小于该节点的值，而其右子树中的所有节点的值都大于该节点的值。在给定的题目“树-98. 验证...
算法面试通关40讲完整课件 18-20 树、二叉树、二叉搜索树
07-06
为了有效地解决这些问题，你需要熟悉二叉搜索树的遍历方法，包括前序遍历、中序遍历和后序遍历，以及递归和迭代的实现。同时，了解如何通过这些遍历来找出节点的属性，比如最大值、最小值，或者构造二叉搜索树。 **...
二叉搜索树（C#，C++）
10-11
二叉搜索树（Binary Search Tree，BST）是一种特殊的二叉树结构，它的每个节点都包含一个键（key）、一个关联的值、一个指向左子树的引用和一个指向右子树的引用。在二叉搜索树中，对于任意节点，其左子树中的所有...
BST的实现以及kd tree的实现
11-22
BST的实现以及kd tree的实现
二叉查找树 减治法——C++代码
05-24
二叉查找树（Binary Search Tree，BST）是一种特殊的二叉树数据结构，它的每个节点都包含一个键（key）、一个关联的值、一个指向左子树的引用和一个指向右子树的引用。在二叉查找树中，对于任意节点，其左子树中的...
java-leetcode题解之第108题将有序数组转换为二叉搜索树.zip
06-18
这种方法称为“中序遍历法”，因为它在构建过程中模拟了二叉搜索树的中序遍历顺序。 在实现Java代码时，我们通常会定义一个辅助函数，该函数接受数组的起始和结束索引，然后根据上述步骤创建对应的二叉搜索树节点。...
【数据结构】二叉树的模拟实现
m0_64826370的博客
12-19 1865
树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。光看文字可能大家理解不了，我们看下图。二叉树是一种常见的树型数据结构，由若干个节点组成，每个节点最多有两个子节点，分别称为左子节点和右子节点。每个节点最多有两个子节点，且子节点的位置是固定的。左子节点在父节点的左边，右子节点在父节点的右边。二叉树的子树也是二叉树。二叉树的每个节点都有一个值，可以是任意类型的数据。
UVA 122 二叉树模拟
winycg的博客
04-28 749
题意：输入一棵二叉树，层序遍历输出二叉树的节点值，结点规模256，如果有结点没有被赋值或者被赋2次以上的值，则输出not complete（照着书做的时候书上输出-1导致程序一直WA） 使用数组模拟二叉树更加简单和方便 #include #include #include #include #include #include #include #include #include #define
【数据结构】二叉搜索树的模拟实现
Hacynn的博客
01-29 1281
Java底层实现搜索树的两个主要类是TreeSet和TreeMap。TreeSet是基于红黑树（Red-Black tree）实现的，它提供了对元素的唯一性排序。TreeSet中的元素是唯一的，并且按照升序排序。TreeMap也是基于红黑树实现的，它提供了一个键值对的映射关系，并且按照键的升序排序。TreeMap允许使用null键和null值。这两个类都实现了NavigableMap和SortedMap接口，提供了更丰富的方法用于搜索、排序和遍历操
二叉树模拟实现--c
sakeww的博客
09-20 294
BinaryTree.h #pragma once #include<malloc.h> #include<assert.h> #include<stdio.h> //binary tree node data type二叉树节点数据类型 typedef int BTNDataType; typedef struct BTNode { struct BTNode* left; struct BTNode* right; BTNDataType data;//节
BST的实现（二叉搜索树）
bafang9249的博客
01-09 146
void Inorder(struct Tree *T); //中序 void Preorder(struct Tree *T); //前序 void Postorder(struct Tree *T); //后序 struct Tree * InsertTree(struct Tree * T, int z);struct Tree * Delete(struct Tree *T...
数据结构——顺序表
最新发布
m0_61965705的博客
08-27 331
例如：查找顺序表中的某个元素所在下标，就可以使用ForeachSeqList函数，搭配FindData函数传参对遍历到的数据进行操作。如果要存放字符串类型的，最好写成以下形式。空间可以不连续，访问元素方便。
评论 10
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

起飞的风筝

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

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

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

打赏作者

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

抵扣说明：

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

余额充值