二叉搜索树的查找与删除一些基本操作

最新推荐文章于 2022-06-03 12:27:06 发布
最新推荐文章于 2022-06-03 12:27:06 发布
阅读量302 收藏
点赞数
分类专栏： C/C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hj605635529/article/details/70186885
版权
二叉搜索树：它或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 它的左、右子树也分别为二叉排序树。

二叉搜索树有个特点，最左的是最小的节点，最右的是最大的节点。 
当我们把二叉搜索树进行中序遍历的时候，它是进行排序后的结果，所以我们也把二叉搜索树叫做排序二叉树。


接下来我们介绍二叉排序树的所有的算法：

1.1搜索二叉树的结构

首先我们来看它的结构，他的结构和二叉树类似，所以会有一个左孩子节点的指针，一个右孩子节点的指针，还有一个key值（主键）和一个value(值），二叉树中key值和value值是相等的，我们用这四个属性来构建搜索二叉树， 

template<typename K,typename V>
struct BSTNode
{
	BSTNode(const K & key,const V & value):_key(key),_value(value),_LChild(NULL),_RChild(NULL)
	{   }

	K _key;
	V _value;
	BSTNode<K,V>* _LChild;
	BSTNode<K,V>* _RChild;
};

1.2二叉树的构造函数

构建搜索二叉树，我们这里采用先构建一棵空树，利用Insert插入方法来插入元素。

public:
	//默认构造函数
	BinarySearchTree():pRoot(NULL) { }
	//拷贝构造函数
	BinarySearchTree(const BinarySearchTree<K,V> & Bst)
	{
		pRoot = _Copy(Bst.pRoot);
	}
private:
	BSTNode<K,V>* _Copy(BSTNode<K,V> *Root)
	{
		if (Root == NULL)
		{
			return NULL;
		}
		BSTNode<K,V> *ptemp = new BSTNode<K,V>(Root->_key,Root->_value);
		ptemp->_LChild = _Copy(Root->_LChild);
		ptemp->_RChild = _Copy(Root->_RChild);
		return ptemp;
	}

1.3二叉树的插入函数 


其搜索二叉树关键的算法之一，如果为空树，那么可以直接进行插入。他的用根节点的键值和key进行比较，如果key大于根节点键值，就说明在右子树如果小，那么就说明在右子树，如果相等，就说明已经出现了，不需要再次进行插入。插入的时候要看与父亲节点的key进行比较，如果小插入右边，如果大，插入左边。


插入非递归代码：

//非递归版本
	bool Insert(const K & key,const V & value)
	{
		if (pRoot == NULL)
		{
			pRoot = new BSTNode<K,V>(key,value);
			return true;
		}

		BSTNode<K,V> *pcur = pRoot;
		BSTNode<K,V> *pParent = NULL;
		//找到要插入的位置，发现其实插入的位置都是树的叶子节点。
		while (pcur)
		{
			if (key < pcur->_key)
			{
				pParent = pcur;
				pcur = pcur->_LChild;
			}
			else if(key > pcur->_key)
			{
				pParent = pcur;
				pcur = pcur->_RChild;
			}
			else
				return false;   //这个值在树里有，插入失败。
		}

		BSTNode<K,V> *pM = new BSTNode<K,V>(key,value);
		if (key < pParent->_key)  //插在左子树上。
		{
			pParent->_LChild = pM;
		}
		else
		{
			pParent->_RChild = pM;
		}
		return true;
	}
插入递归代码： 

//递归的版本
	bool Insert(const K & key,const V & value)
	{	
		return _Insert(pRoot,key,value);
	}
bool _Insert(BSTNode<K,V> *&Root,const K & key, const V & value)
	{
		if (Root == NULL)
		{
			Root = new BSTNode<K,V>(key,value);
			return true;
		}

		if (key < Root->_key)
		{
			return _Insert(Root->_LChild,key,value);
		}
		else if(key > Root->_key)
			return _Insert(Root->_RChild,key,value);
		else
			return false;
	}

1.4搜索二叉树的查找

搜索二叉树的查找，下面进行简单的介绍一下，你要搜索的，那么就是和根的key比较，如果大于根的key，那么就找右树，如果小于根的key，那么就找左树。相等，就代表找到了。
二叉搜索树的查找非递归代码： 
//非递归版本
	bool Find(const K & key)
	{
		if (pRoot == NULL)
		{
			return false;
		}
		BSTNode<K,V> *pcur = pRoot;

		while (pcur)
		{
			if (pcur->_key == key)
			{
				return true;
			}
			else if (key < pcur->_key)
			{
				pcur = pcur->_LChild;
			}
			else
			{
				pcur = pcur->_RChild;
			}
		}
		return false;
	}
二叉树的递归查找代码： 
bool Find(const K & key)
	{
		return _Find(pRoot,key);
	}
bool _Find(BSTNode<K,V>*Root,const K & key)
	{
		if (Root == NULL)
		{
			return false;
		}

		if (Root->_key == key)
		{
			return true;
		}
		else if (key < Root->_key)
		{
			return _Find(Root->_LChild,key);
		}
		else 
			return _Find(Root->_RChild,key);
		
	}

1.5搜索二叉树的删除

搜索二叉树的删除算法算是最难的了。在这里我们需要考虑几种思路。
1.根为空
2.只有根节点且根节点就是我们要删除的节点。
3.只有左单支
4.只有右单支
5.要删除的节点既有左孩子又有右孩子

1和2好理解，就不多说了，重点说说3,4,5三种情况。

只有左单支（删除的三种情况）

只有右单支（删除的三种情况）




删除的节点既有左单支又有右单支




删除节点代码：

bool Remove(const K & key)
	{
		if (pRoot == NULL)
		{
			return false;
		}

		if (pRoot->_LChild == NULL && pRoot->_RChild == NULL && pRoot->_key == key)
		{
			delete pRoot;
			pRoot = NULL;
		}

		BSTNode<K,V> *pcur = pRoot;
		BSTNode<K,V> *pParent = NULL;
		//在树中找这个节点
		while (pcur)
		{
			if (key < pcur->_key)
			{
				pParent = pcur;
				pcur = pcur->_LChild;
			}
			else if (key > pcur->_key)
			{
				pParent = pcur;
				pcur = pcur->_RChild;
			}
			else 
				break;
		}

		if (pcur)  //找到了。
		{
			if (pcur->_LChild == NULL)  //右单支
			{
				if (pParent != NULL)  //删除的不是根节点
				{
					if (pcur == pParent->_RChild)
					{
						pParent->_RChild = pcur->_RChild;
					}
					else
						pParent->_LChild = pcur->_RChild;
				}
				else  //删除的是根节点，此时pParent为空，所以这里要单独的拿出来写，要不然程序直接崩溃。
				{
					pRoot = pcur->_LChild;
				}

			}
			else if (pcur->_RChild == NULL) //左单支
			{
				if (pParent != NULL)
				{
					if (pcur == pParent->_LChild)
					{
						pParent->_LChild = pcur->_LChild;
					}
					else
						pParent->_RChild = pcur->_LChild;
				}
				else
					pRoot = pcur->_RChild;

			}
			else  //要删除的节点左右子树都有  将右链的最左链的节点代替当前的节点，删除最左链的那个节点。
			{
				BSTNode<K,V> *firstInOrder = pcur->_RChild;

				while (firstInOrder->_LChild)
				{
					pParent = firstInOrder;
					firstInOrder = firstInOrder->_LChild;
				}

				pcur->_key = firstInOrder->_key;
				pcur->_value = firstInOrder->_value;

				if (pcur->_RChild != firstInOrder)  //右子树的左链不为空
				{
					pParent->_LChild = firstInOrder->_RChild;
				}
				else   //右子树的左链为空。
				{
					pcur->_RChild = firstInOrder->_RChild;
				}

				pcur = firstInOrder;  //pcur指向要删除的节点

			}

			delete pcur;
			return true;
		}


		return false;  //没找到直接返回false.
	}

整个代码如下：

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

template<typename K,typename V>
struct BSTNode
{
	BSTNode(const K & key,const V & value):_key(key),_value(value),_LChild(NULL),_RChild(NULL)
	{   }

	K _key;
	V _value;
	BSTNode<K,V>* _LChild;
	BSTNode<K,V>* _RChild;
};

template<typename K,typename V>
class BinarySearchTree
{
public:
	//默认构造函数
	BinarySearchTree():pRoot(NULL) { }
	//拷贝构造函数
	BinarySearchTree(const BinarySearchTree<K,V> & Bst)
	{
		pRoot = _Copy(Bst.pRoot);
	}

	BinarySearchTree& operator=(const BinarySearchTree<K,V> & Bst)
	{
		if (this != &Bst)
		{
			BinarySearchTree<K,V> ptemp(Bst);
			swap(pRoot,ptemp.pRoot);
		}
		return *this;
	}

	~BinarySearchTree()
	{
		_Destroy(pRoot);
	}



	非递归版本
	//bool Insert(const K & key,const V & value)
	//{
	//	if (pRoot == NULL)
	//	{
	//		pRoot = new BSTNode<K,V>(key,value);
	//		return true;
	//	}

	//	BSTNode<K,V> *pcur = pRoot;
	//	BSTNode<K,V> *pParent = NULL;
	//	//找到要插入的位置，发现其实插入的位置都是树的叶子节点。
	//	while (pcur)
	//	{
	//		if (key < pcur->_key)
	//		{
	//			pParent = pcur;
	//			pcur = pcur->_LChild;
	//		}
	//		else if(key > pcur->_key)
	//		{
	//			pParent = pcur;
	//			pcur = pcur->_RChild;
	//		}
	//		else
	//			return false;   //这个值在树里有，插入失败。
	//	}

	//	BSTNode<K,V> *pM = new BSTNode<K,V>(key,value);
	//	if (key < pParent->_key)  //插在左子树上。
	//	{
	//		pParent->_LChild = pM;
	//	}
	//	else
	//	{
	//		pParent->_RChild = pM;
	//	}
	//	return true;
	//}

	//递归的版本
	bool Insert(const K & key,const V & value)
	{	
		return _Insert(pRoot,key,value);
	}

	非递归版本
	//bool Find(const K & key)
	//{
	//	if (pRoot == NULL)
	//	{
	//		return false;
	//	}
	//	BSTNode<K,V> *pcur = pRoot;

	//	while (pcur)
	//	{
	//		if (pcur->_key == key)
	//		{
	//			return true;
	//		}
	//		else if (key < pcur->_key)
	//		{
	//			pcur = pcur->_LChild;
	//		}
	//		else
	//		{
	//			pcur = pcur->_RChild;
	//		}
	//	}
	//	return false;
	//}

	bool Find(const K & key)
	{
		return _Find(pRoot,key);
	}


	bool Remove(const K & key)
	{
		if (pRoot == NULL)
		{
			return false;
		}

		if (pRoot->_LChild == NULL && pRoot->_RChild == NULL && pRoot->_key == key)
		{
			delete pRoot;
			pRoot = NULL;
		}

		BSTNode<K,V> *pcur = pRoot;
		BSTNode<K,V> *pParent = NULL;
		//在树中找这个节点
		while (pcur)
		{
			if (key < pcur->_key)
			{
				pParent = pcur;
				pcur = pcur->_LChild;
			}
			else if (key > pcur->_key)
			{
				pParent = pcur;
				pcur = pcur->_RChild;
			}
			else 
				break;
		}

		if (pcur)  //找到了。
		{
			if (pcur->_LChild == NULL)  //右单支
			{
				if (pParent != NULL)  //删除的不是根节点
				{
					if (pcur == pParent->_RChild)
					{
						pParent->_RChild = pcur->_RChild;
					}
					else
						pParent->_LChild = pcur->_RChild;
				}
				else  //删除的是根节点，此时pParent为空，所以这里要单独的拿出来写，要不然程序直接崩溃。
				{
					pRoot = pcur->_LChild;
				}

			}
			else if (pcur->_RChild == NULL) //左单支
			{
				if (pParent != NULL)
				{
					if (pcur == pParent->_LChild)
					{
						pParent->_LChild = pcur->_LChild;
					}
					else
						pParent->_RChild = pcur->_LChild;
				}
				else
					pRoot = pcur->_RChild;

			}
			else  //要删除的节点左右子树都有  将右链的最左链的节点代替当前的节点，删除最左链的那个节点。
			{
				BSTNode<K,V> *firstInOrder = pcur->_RChild;

				while (firstInOrder->_LChild)
				{
					pParent = firstInOrder;
					firstInOrder = firstInOrder->_LChild;
				}

				pcur->_key = firstInOrder->_key;
				pcur->_value = firstInOrder->_value;

				if (pcur->_RChild != firstInOrder)  //右子树的左链不为空
				{
					pParent->_LChild = firstInOrder->_RChild;
				}
				else   //右子树的左链为空。
				{
					pcur->_RChild = firstInOrder->_RChild;
				}

				pcur = firstInOrder;  //pcur指向要删除的节点

			}

			delete pcur;
			return true;
		}


		return false;  //没找到直接返回false.
	}
private:
	BSTNode<K,V>* _Copy(BSTNode<K,V> *Root)
	{
		if (Root == NULL)
		{
			return NULL;
		}
		BSTNode<K,V> *ptemp = new BSTNode<K,V>(Root->_key,Root->_value);
		ptemp->_LChild = _Copy(Root->_LChild);
		ptemp->_RChild = _Copy(Root->_RChild);
		return ptemp;
	}

	void _Destroy(BSTNode<K,V> *Root)
	{
		if (Root == NULL)
		{
			return;
		}
		_Destroy(Root->_LChild);
		_Destroy(Root->_RChild);
		delete Root;
		Root = NULL;
	}

	bool _Insert(BSTNode<K,V> *&Root,const K & key, const V & value)
	{
		if (Root == NULL)
		{
			Root = new BSTNode<K,V>(key,value);
			return true;
		}

		if (key < Root->_key)
		{
			return _Insert(Root->_LChild,key,value);
		}
		else if(key > Root->_key)
			return _Insert(Root->_RChild,key,value);
		else
			return false;
	}

	bool _Find(BSTNode<K,V>*Root,const K & key)
	{
		if (Root == NULL)
		{
			return false;
		}

		if (Root->_key == key)
		{
			return true;
		}
		else if (key < Root->_key)
		{
			return _Find(Root->_LChild,key);
		}
		else 
			return _Find(Root->_RChild,key);
		
	}


private:
	BSTNode<K,V> *pRoot;
};



hj605635529
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉搜索树+C++程序+对二叉搜索树的基本操作
02-16
二叉搜索树+C++程序+对二叉搜索树的基本操作：包括查找、插入、删除元素。 文件是标准cpp文件，可以在devc++上成功运行，在vs上运行，稍加编辑便可以。 建议用devc，此软件使用方便。
java实现并图解二叉搜索树的添加、查找以及删除方法(保姆级教程)
weixin_48654011的博客
04-09 1577
目录 二叉搜索树的概念 实现二叉搜索树的添加方法 实现二叉搜索树的查找方法 实现二叉搜索树的删除方法 附带java代码 二叉搜索树的概念 二叉搜索树（二叉排序树）： 1.首先是一棵二叉树 2.其次左子树上所有节点的值都小于根节点的值，右子树上所有节点的值都大于根节点的值。 图解： 实现二叉搜索树的添加方法 先讲解思路，在进行图解，最后实现代码 实现二叉搜索树的查找方法 先讲解思路，在进行图解，最后实现代码 实现二叉搜索树的删除方法 先讲解思路，在进行图解，最后实现代码 .
【JAVA】【刷题子】450. 删除二叉搜索树中的节点
南方者的博客
06-03 145
给定一个二叉搜索树的根节点 root 和一个值 key，删除二叉搜索树中的key对应的节点，并保证二叉搜索树的性质不变。返回二叉搜索树（有可能被更新）的根节点的引用...
【C++从青铜到王者】第十九篇:C++二叉树进化之二叉搜索树
森明帮大于黑虎帮的博客
07-24 821
系列文章目录 文章目录系列文章目录前言一、内容安排说明二、二叉搜索树1.二叉搜索树概念2.二叉搜索树操作1.二叉搜索树的查找2.二叉搜索树的插入3.二叉搜索树的删除4.二叉搜索树的修改3.二叉搜索树实现4.二叉搜索树应用5.二叉搜索树的性能分析总结 前言 一、内容安排说明 二叉树在前面C数据结构阶段已经讲过，本节取名二叉树进阶是因为： map和set特性需要先铺垫二叉搜索树，而二叉搜索树也是一种树形结构。 二叉搜索树的特性了解，有助于更好的理解map和set的特性。 二叉树中部分面试题稍微有.
二叉排序树的查找删除操作
qq_56350439的博客
12-05 650
1、二叉排序树的查找： typedef struct BSTNOde{ int data; struct BSTNOde *lchild,*rchild; }二叉排序树的结构定义 BSTree SearchBST(BSTree T,int &key){ //二叉排序树中的查�? if((!T)||key==T->data){ return T; } else if(key<T->data){ ret
搜索二叉树的查找，插入与删除操作图解
didi1663478999的博客
04-12 1537
二叉搜索树 1.二叉搜索树的概念 二叉搜索树又称二叉排序树，或者是一颗空树，或者是具有以下性质的二叉树： （1）若它的左子树不为空，则左子树上所有节点的值都小于根节点的值 （2）若它的右子树不为空，则右子树上所有节点的值都大于根节点的值 （3）它的左右子树也分别为二叉搜索树 ={5，3，4, 1，7, 8，2, 6，0, 9} 顺便回顾一下二叉树前中后序遍历是怎么遍历的 前序（根左右）：5...
Java创建二叉搜索树,实现搜索,插入,删除的操作实例
08-28
下面小编就为大家分享一篇Java创建二叉搜索树,实现搜索,插入,删除的操作实例，具有很好的参考价值，希望对大家有所帮助
Java 实现二叉搜索树的查找、插入、删除、遍历
08-31
本文主要介绍了Java实现二叉搜索树的查找、插入、删除、遍历等内容。具有很好的参考价值，下面跟着小编一起来看下吧
Python实现二叉搜索树BST的方法示例
01-20
二叉排序树（BST）又称二叉查找树、二叉搜索树 二叉排序树(Binary Sort Tree)又称二叉查找树。它或者是一棵空树；或者是具有下列性质的二叉树： 1.若左子树不空，则左子树上所有结点的值均小于根结点的值； 2.若...
Java删除二叉搜索树的任意元素的方法详解
08-19
主要介绍了Java删除二叉搜索树的任意元素的方法,结合实例形式详细分析了java这对二叉搜索树的遍历、查找、删除等相关操作技巧与使用注意事项,需要的朋友可以参考下
二叉搜索树递归算法
weixin_34348805的博客
08-20 1643
二叉搜索树的查找——递归算法: boolFind(BTreeNode*BST,ElemType&item) { if(BST==NULL) returnfalse;//查找失败 else{ if(item==BST->data){ item=BST->data;//查找成功...
二叉排序树(BST)的查找算法（递归算法）
热门推荐
认知 行动 坚持
06-09 2万+
#include using namespace std; // BST的结点 typedef struct node { int key; struct node *lChild, *rChild; }Node, *BST; // 在给定的BST插入element, 使之称为新的BST bool BSTInsert(Node * &p, int element) { if(NULL
二叉查找树之——递归实现
naw0011的专栏
10-29 1555
以二叉树为基础的树形数据结构在计算机中起到的作用不言而喻。最近在重温二叉树，主要是理解其中的递归和非递归实现的关联，并对二叉树的应用有更深的理解。其中，二叉树可以用来实现堆排序，可以用来形成查找树，由于其特殊的数据结构，在二叉树中的操作基本都是O(logn)的时间复杂度。下面慢慢细品。        二叉树的数据结构可以用来表示： typedef struct tagTreeNode{
二叉排序树的删除操作
weixin_34408624的博客
04-09 735
算法思想 二叉排序树，删除操作主要针对三种情况。 1 叶子节点-直接删除就可以了 2 没有左孩子的节点-直接嫁接右子树就可以了(没有右孩子的节点-直接嫁接左子树就可以了) 3 如果左右子树都存在，则寻找删除节点的直接前驱（即左子树里面的最右的节点） 编程时需要注意，函数时针对指针的操作，因此为了修改指针，要使用二级指针传参才可以 例如： void delete(BinaryTre...
二叉排序树中查找元素的递归和非递归写法
buptwds的专栏
07-18 7735
上一篇介绍了二分查找的递归和非递归写法，这一篇文章主要记录二叉排序树中查找元素的递归和非递归写法。二叉排序树又称为二叉查找树，也称为二叉搜索树。 二叉排序树或者是一棵空树，或者是具有下列性质的二叉树： （1）若左子树不空，则左子树上所有结点的值均小于它的根结点的值； （2）若右子树不空，则右子树上所有结点的值均大于它的根结点的值； （3）左、右子树也分别为二叉排序树； （4）没有键值相等的
二叉查找树中的插入查找和删除
naget的博客
09-05 1万+
上一篇文中，通过二分查找，我们实现了对数级别的查找方案，但因为使用了数组这一数据结构，插入时需要移动大量的元素，导致插入动作任然很慢。为了减少移动的元素，我们这次使用链表，为了保持二分查找的效率，我们将二者结合起来——二叉查找树。 一个二叉查找树就是一个二叉树，每个节点上包含有一个键一个值一个指向左节点的链接一个指向右节点的链接（这个图中的数字代表键，值没有显示）。而且每个结点的键都大于其左...
算法思想（五）——二叉搜索树
sinat_38368658的博客
02-24 581
二分查找法 Binary Search 对于有序数列，才能使用二分查找法（排序的作用）（logn级别复杂度） 使用递归方式实现二分查找法 递归实现通常思维起来更容易，但在性能上会有略差。 ...
二叉搜索树中删除一个结点
02-25 595
// 在ptr为根的二叉搜索树中删除x的结点，若删除成功则新结点通过ptr返回templatebool BST::Remove(const K x, BSTNode*& ptr){    BSTNode* tmp;    if(ptr != NULL)    {        if(x data)          // 左子树中执行删除            Remove(x, ptr->lef
二叉搜索树的查找和删除
weixin_45949728的博客
09-30 116
<1>Find BinTree Insert( BinTree BST, ElementType X ) { if( !BST ){ /* 若原树为空，生成并返回一个结点的二叉搜索树 */ BST = (BinTree)malloc(sizeof(struct TNode)); BST->Data = X; BST->Left = BST->Right = NULL; } else { /* 开始找要插入元素的位置 */ if( X <
二叉搜索树查找c++代码
最新发布
11-17
二叉搜索树是一种常见的数据结构，可以用于高效地查找、插入和删除元素。在二叉搜索树中，每个节点都有一个值，并且左子树中的所有节点的值都小于该节点的值，右子树中的所有节点的值都大于该节点的值。 要查找一个...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值