二叉搜索树（BST）分析及实现

已于 2022-03-09 09:21:11 修改
阅读量1.7k 收藏 6
点赞数 5
分类专栏： C++ 数据结构 文章标签： 二叉树
于 2021-05-17 11:39:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/S5242/article/details/116920036
版权

文章目录


二叉搜索树是AVL树和红黑树的基础， 学好二叉搜索树，有助于更好的理解map和set的特性。

概念

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

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

如图即为一颗二叉搜索树：
在这里插入图片描述
如果按中序遍历的话应该为递增顺序： 9,17, 23, 45, 5 3, 65, 78, 81, 87, 94

定义二叉树节点：

class BSTNode
{
	friend class BSTree<_Ty>;
public:
	BSTNode() : data(_Ty()), leftChild(nullptr), rightChild(nullptr)
	{}
	BSTNode(_Ty val, BSTNode* left = nullptr, BSTNode* right = nullptr)
		: data(val), leftChild(left), rightChild(right)
	{}
	~BSTNode()
	{}
private:
	_Ty data;
	BSTNode* leftChild;
	BSTNode* rightChild;
};

定义二叉树：

class BSTree
{
public:
	BSTree():root(nullptr)
	{}
	BSTree(vector<_Ty> & num)  : root(nullptr)
	{
		for (const auto e : num) {
			Insert1(root, e);
			//Insert2(root,e);
		}
	}
	~BSTree()
	{}

	/// <summary>
	/// 核心功能 增删
	/// <returns>
	bool Insert(const _Ty& x)
	{
		return Insert2(root, x); 
		//return Insert1(root, x);
	}

	bool Remove(const _Ty& key)
	{
		return Remove1(root, key);
		//return Remove2(root, key);
	}
	
private:
	BSTNode<_Ty>* root;

};

构造二叉树时需要用逐个元素插入；而插入就要先查找到该插入的位置；

查找

在这里插入图片描述

BSTNode<_Ty>* Search(BSTNode<_Ty>* t, const _Ty& key)const
	{
		if (t == nullptr)
			return t;
		if (key < t->data)
			return Search(t->leftChild, key);
		else if (key > t->data)
			return Search(t->rightChild, key);
		return t;
	}

插入

在这里插入图片描述

bool Insert1(BSTNode<_Ty>*& t, int x)  //递归
	{
		if (t == nullptr) {
			t = new BSTNode<_Ty>(x);
			return true;
		}
		
		if (x > t->data) {
			return  Insert1(t->rightChild, x);
		}
		if (x < t->data) {
			return  Insert1(t->leftChild, x);
		}
		return false;
	}
	bool Insert2(BSTNode<_Ty>* &t, const _Ty& x)  //非递归  需要找到当前节点的父节点
	{  
		if (t == nullptr) {
			t = new BSTNode<_Ty>(x);
			return true;
		}
		BSTNode<_Ty>* p = t;    //当前节点
		BSTNode<_Ty>* pre = t;  //父节点
		while (p) {             //比较大小走到分支尽头结束，此时p=nullptr
			pre = p;
			if (x > t->data) {
				p = p->rightChild;
			}
			else if (x < t->data) {
				p = p->leftChild;
			}
		}	
		//然后比较x和pre->data的大小决定插入的是左子树还是右子树
		if (x > pre->data) {
			pre->rightChild= new BSTNode<_Ty>(x);
		}
		else {
			pre->leftChild = new BSTNode<_Ty>(x);
		}
		return true;
	}

删除

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

  1. 要删除的结点只有左孩子结点。
  2. 要删除的结点只有右孩子结点 。
  3. 要删除的结点有左、右孩子结点
  4. 要删除的结点无左、右孩子结点

前三种情况删除节点后需要调整:
在这里插入图片描述
考虑完前三种情况就剩下第四种情况，第四种情况可以包含到1，2 情况中。

bool Remove1(BSTNode<_Ty>* &t, const _Ty& key)  //递归
	{
		if (t == nullptr)
			return false;
		if (key < t->data)
			return Remove1(t->leftChild,key);
		else if (key > t->data)
			return Remove1(t->rightChild, key);
		else{  //找到了则删除   
			
			if (t->leftChild && t->rightChild) {  //左右子树都不空
				BSTNode<_Ty> * q = t->rightChild;
				while (q->leftChild)
					q = q->leftChild;   //找右子树最小值
				t->data = q->data;      
				Remove1(t->rightChild, t->data);   //删除刚才被置换的节点
			}
			else { // 三种情况：左子树空  或者右子树空  或者左右子树都为空
				BSTNode<_Ty>*  p = t;
				if (t->leftChild != nullptr)   //左树不空
					t = t->leftChild;
				else    //右树不空
					t = t->rightChild;
				delete p;
			}			
		}
		return true;
	}

	bool Remove2(BSTNode<_Ty>*& t, const _Ty& key)  //非递归
	{
		if (t == nullptr)
			return false;
		BSTNode<_Ty>* cur = Search(key);
		if (cur == nullptr)
			return false;

		if (cur->leftChild && cur->rightChild) {  //左右子树都存在 可选择替换右子树的最小值或左子树的最大值			
			BSTNode<_Ty>* q = cur->leftChild;
			while (q->rightChild != nullptr)
				q = q->rightChild;
			cur->data = q->data;
			cur = q;
		}

		BSTNode<_Ty>* p = Parent(t,cur);   //获取父节点
		if (p == nullptr) //删除根节点  此时只有左树或者右树 或者都无
		{
			if (cur->leftChild != nullptr)
				cur = cur->leftChild;
			else
				cur = cur->rightChild;
		}
		else {	//非根节点
			if (p->leftChild==cur) { //cur为左树 且cur只有一颗子树
				if (cur->leftChild == nullptr)
					p->leftChild = cur->rightChild;
				else
					p->leftChild = cur->leftChild;
			}
			else if (p->rightChild== cur) {//cur为右树 且cur只有一颗子树
				if (cur->leftChild == nullptr)
					p->rightChild = cur->rightChild;
				else
					p->rightChild = cur->leftChild;
			}
			
			
		}	
		delete cur;
		return true;
	}

二叉搜索树的性能

插入和删除操作都必须先查找，查找效率代表了二叉搜索树中各个操作的性能。
对有n个结点的二叉搜索树，若每个元素查找的概率相等，则二叉搜索树平均查找长度是结点在二叉搜索树的深度的函数，即结点越深，则比较次数越多。
但对于同一个关键码集合，如果各关键码插入的次序不同，可能得到不同结构的二叉搜索树：
在这里插入图片描述
最优情况下，二叉搜索树为完全二叉树，其平均比较次数为：log 2 N
最差情况下，二叉搜索树退化为单支树，其平均比较次数为：N/2 。 优化方案----->可使用平衡二叉搜索树

完整代码

#include <iostream>
#include <vector>
using namespace std;

template<class _Ty>
class BSTree;

template<class _Ty>
class BSTNode
{
	friend class BSTree<_Ty>;
public:
	BSTNode() : data(_Ty()), leftChild(nullptr), rightChild(nullptr)
	{}
	BSTNode(_Ty val, BSTNode* left = nullptr, BSTNode* right = nullptr)
		: data(val), leftChild(left), rightChild(right)
	{}
	~BSTNode()
	{}
private:
	_Ty data;
	BSTNode* leftChild;
	BSTNode* rightChild;
};

template<class _Ty>
class BSTree
{
public:
	BSTree():root(nullptr)
	{}
	BSTree(vector<_Ty> & num)  : root(nullptr)
	{
		for (const auto e : num) {
			Insert1(root, e);
			//Insert2(root,e);
		}
	}
	~BSTree()
	{}
	/// 核心功能 增删
	bool Insert(const _Ty& x)
	{
		return Insert2(root, x); 
		//return Insert1(root, x);
	}

	bool Remove(const _Ty& key)
	{
		return Remove1(root, key);
		//return Remove2(root, key);
	}
	

	/// 其它功能
public:
	void Order()const   //中序遍历 方便查看结果
	{
		Order(root);
	}

	BSTNode<_Ty>* Min()const   //求树最小值
	{
		return Min(root);
	}
	BSTNode<_Ty>* Max()const  //求树最大值
	{
		return Max(root);
	}
	
	BSTNode<_Ty>* Parent(BSTNode<_Ty>* key)const   //寻找节点的父节点
	{
		return Parent(root, key);
	}
	BSTNode<_Ty>* Search(const _Ty& key)const
	{
		return Search(root, key);
	}
	

protected:
	bool Insert1(BSTNode<_Ty>*& t, int x)  //递归
	{
		if (t == nullptr) {
			t = new BSTNode<_Ty>(x);
			return true;
		}
		
		if (x > t->data) {
			return  Insert1(t->rightChild, x);
		}
		if (x < t->data) {
			return  Insert1(t->leftChild, x);
		}
		return false;
	}
	bool Insert2(BSTNode<_Ty>* &t, const _Ty& x)  //非递归  需要找到当前节点的父节点
	{  
		if (t == nullptr) {
			t = new BSTNode<_Ty>(x);
			return true;
		}
		BSTNode<_Ty>* p = t;    //当前节点
		BSTNode<_Ty>* pre = t;  //父节点
		while (p) {             //比较大小走到分支尽头结束，此时p=nullptr
			pre = p;
			if (x > t->data) {
				p = p->rightChild;
			}
			else if (x < t->data) {
				p = p->leftChild;
			}
		}	
		//然后比较x和pre->data的大小决定插入的是左子树还是右子树
		if (x > pre->data) {
			pre->rightChild= new BSTNode<_Ty>(x);
		}
		else {
			pre->leftChild = new BSTNode<_Ty>(x);
		}
		return true;
	}

	bool Remove1(BSTNode<_Ty>* &t, const _Ty& key)  //递归
	{
		if (t == nullptr)
			return false;
		if (key < t->data)
			return Remove1(t->leftChild,key);
		else if (key < t->data)
			return Remove1(t->rightChild, key);
		else{  //找到了则删除   
			
			if (t->leftChild && t->rightChild) {
				BSTNode<_Ty> * q = t->rightChild;
				while (q->leftChild)
					q = q->leftChild;
				t->data = q->data;
				Remove1(t->rightChild, t->data);
			}
			else {
				BSTNode<_Ty>*  p = t;
				if (t->leftChild != nullptr)
					t = t->leftChild;
				else
					t = t->rightChild;
				delete p;
			}			
		}
		return true;
	}

	bool Remove2(BSTNode<_Ty>*& t, const _Ty& key)
	{
		if (t == nullptr)
			return false;
		BSTNode<_Ty>* cur = Search(key);
		if (cur == nullptr)
			return false;

		if (cur->leftChild && cur->rightChild) {  //左右子树都存在 可选择替换右子树的最小值或左子树的最大值			
			BSTNode<_Ty>* q = cur->leftChild;
			while (q->rightChild != nullptr)
				q = q->rightChild;
			cur->data = q->data;
			cur = q;
		}

		BSTNode<_Ty>* p = Parent(t,cur);
		if (p == nullptr) //删除根节点  此时只有左树或者右树 或者都无
		{
			if (cur->leftChild != nullptr)
				cur = cur->leftChild;
			else
				cur = cur->rightChild;
		}
		else {	//非根节点
			if (p->leftChild==cur) { //cur为左树 且cur只有一颗子树
				if (cur->leftChild == nullptr)
					p->leftChild = cur->rightChild;
				else
					p->leftChild = cur->leftChild;
			}
			else if (p->rightChild== cur) {//cur为右树 且cur只有一颗子树
				if (cur->leftChild == nullptr)
					p->rightChild = cur->rightChild;
				else
					p->rightChild = cur->leftChild;
			}
			
			
		}	
		delete cur;
		return true;
	}

protected:

	void Order(BSTNode<_Ty>* t)const   //中序遍历 方便查看结果
	{
		if (t == nullptr) {
			return;
		}
		Order(t->leftChild);
		printf("%d  ", t->data);
		Order(t->rightChild);
	}

	BSTNode<_Ty>* Min(BSTNode<_Ty>*&t)
	{
		while (t&&t->leftChild != nullptr) {   //t==nullptr时返回nullptr
			t = t->leftChild;
		}
		return t;
	}

	BSTNode<_Ty>* Max(BSTNode<_Ty>* t)const
	{
		while (t && t->rightChild != nullptr)
			t = t->rightChild;
		return t;
	}

	BSTNode<_Ty>* Parent(BSTNode<_Ty>* t, BSTNode<_Ty>* key)const
	{
		if (t == nullptr || key == t)
			return nullptr;
		if (key == t->leftChild || key == t->rightChild)
			return t;
		if (key->data < t->data)
			return Parent(t->leftChild, key);
		else if (key->data > t->data)
			return Parent(t->rightChild, key);
	}

	BSTNode<_Ty>* Search(BSTNode<_Ty>* t, const _Ty& key)const
	{
		if (t == nullptr)
			return t;
		if (key < t->data)
			return Search(t->leftChild, key);
		else if (key > t->data)
			return Search(t->rightChild, key);
		return t;
	}

private:
	BSTNode<_Ty>* root;

};

int main()
{
	vector<int>  v1{53,78,17,45,23,9,65,87,81,94 };
	BSTree<int> b1(v1);
	b1.Insert(88);
	b1.Order();
	cout << endl;
	b1.Remove(17);
	b1.Remove(53);

	b1.Order();
	return 0;
}

在这里插入图片描述

S5242
关注
  • 5
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 7
    评论
专栏目录
C++ 二叉查找树 —— 插入、遍历、查找、删除、销毁
辛旭东小小工作室
03-15 2442
二叉查找树的特性： 二叉查找树（Binary Search Tree）（又：二叉搜索树，二叉排序树） 具有以下特性： （1）若“左子树”不为空，则“左子树”上所有节点的值均小于“根节点”的值； （2）若“右子树”不为空，则“右子树”上所有节点的值均大于“根节点”的值； （3）左、右子树也分别为二叉排序树。 01 声明： #include &lt;iostream&gt; us...
（一）BST树（二叉搜索树）
qq_42119136的博客
06-29 4952
（一）BST树（二叉搜索树） 1.BST二叉搜索树 1.1BST树的定义 1 BST树也是一个二叉树，故满足递归定义; 2 其次每个节点只存在一个值; 3 需满足左子树值<=根值<=右子树，故按照中序遍历会得到一个非递减序列。 BST涉及操作主要增，删，查，除了删麻烦一点，其他操作均可递归实现，二叉查找树的一般性质： 1.在一棵二叉查找树上，执行查找、插入、删除等操作，的时间复杂度为O（log2n）。因为，一棵由n个结点，随机构造的二叉查找树的高度为log2n，所以顺理成章，一般操作的执行时间为
二叉搜索树实现及性能分析
weixin_42562387的博客
05-13 1783
概念: 二叉搜索树(Binary Search Tree),(又称:二叉查找树,二叉排序树):它或者是一颗空树,或者是一颗具有以下性质的二叉树: 若它的左子树不为空, 则左子树上所有节点的值均小于根节点的值; 若它的右子树不为空, 则右子树上所有节点的值均大于根节点的值; 它的左右子树也为二叉搜索树; 算法实现: 二叉搜索树的操作主要有: 1. 查找: 递归查找是否存在data. 2. 插入: 树为空, 直接插入, 返回true 树不为空, 按照二叉搜索树的性质查找插入位置, 插入新节点 3. 删
数据结构-二叉排序树（BST树）
理科男同学
11-15 9338
1，二叉排序树介绍 二叉排序树（Binary Sort Tree）或者是一颗空树；或者是具有如下性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 它的左、右子树又分别为二叉排序树。 显然二叉排序树的定义是一个递归形式的定义，所以后面景禹要讲的插入、查找和删除都是基于递归的形式。特别说明：如果有相同的值，可以将该节点放在左子节点或右子节点 1.1，二叉排序树的构建 假设我们有初始的无序...
linux BST树算法实现
gogo0707的博客
05-19 346
本文讲述了BST树的基本概念和算法实现，并且提供了示例。
Python实现二叉搜索树BST的方法示例
09-18
二叉搜索树（BST，Binary Search Tree），又称为二叉查找树或二叉排序树，是一种特殊的二叉树数据结构，其每个节点的值满足以下条件： 1. 节点的左子树中所有节点的值都小于该节点的值。 2. 节点的右子树中所有节点...
C++ 二叉搜索树(BST)的实现方法
08-30
C++ 二叉搜索树(BST)的实现方法 C++ 二叉搜索树(BST)是一种特殊的二叉树，它具有以下特征： 1. 二叉搜索树的每个节点都包含一个键值（key）和一个值（value）。 2. 对于任意一个节点，左子树中的键值都小于该节点...
Java二叉搜索树基础原理与实现方法详解
08-19
在实现二叉搜索树时，需要BST类继承Comparable，以便在实现时可以比较元素的大小。下面是基础代码： ```java package BST; public class BST<E extends Comparable<E>> { //定义树节点 private class Node { ...
二叉搜索树之：【BST】【基本应用汇合】
bei2002315的博客
10-25 665
计算 j =ne[i] 的单独 j 变量为根节点的子树。用l,r分别表示这两个返回值。以左右孩子为根节点的子树的。存左右孩子的存储方式。
二叉搜索树（BST），哈希表讲解及Java实现
qq_46116963的博客
03-26 1117
目录 二叉搜索树(BST) 概念 操作 向BST中添加一个元素 在BST中查找一个元素是否存在 在BST中找最小值/最大值 删除最小值和最大值 删除任意值*** 在BST中修改一个元素 总结 性能分析 和Java类集的关系 哈希表 概念 冲突 - 概念 冲突 - 避免 冲突-避免-哈希函数设计 ...
BST（二叉搜索树）原理解析及代码实现
热爱编程的菜鸟
01-27 1301
文章目录简介二叉搜索树介绍 简介 二叉搜索树作为一种经典的数据结构，它既有链表的快速插入与删除操作的特点，又有数组快速查找的优势； 二叉搜索树介绍 二叉排序树：BST
详细教你实现BST(二叉排序树)
Saber00001的博客
12-02 319
查找基本分类如下： 线性表的查找 顺序查找 折半查找 分块查找 树表的查找 二叉排序树 平衡二叉树 B树 B+树 散列表的查找 今天介绍二叉排序树。 二叉排序树 ( Binary Sort Tree ) 又称为二叉查找树，它是一种对排序和查找都很有用的特殊二叉树。 1. 二叉排序树的定义 二叉排序树是具有如下性质的二叉树： 若它的左子树不为空，则左子树上所有节点的值均小于...
二叉排序树(BST)的思路及C语言实现
热门推荐
kelvinmao的博客
05-31 1万+
请注意，为了能够更好的理解二叉排序树，我建议各位在看代码时能够设置好断点一步一步跟踪函数的运行过程以及各个变量的变化情况一.动态查找所面临的问题在进行动态查找操作时，如果我们是在一个无序的线性表中进行查找，在插入时可以将其插入表尾，表长加1即可；删除时，可以将待删除元素与表尾元素做个交换，表长减1即可。反正是无序的，当然是怎么高效怎么操作。但如果是有序的呢？回想学习线性表顺序存储时介绍的顺序表的缺点
二叉搜索树BST的C++实现
liuchenjane的博客
11-05 6362
BST 包含的功能：插入，删除，查找，查找某一结点的后续和前驱，中序遍历和前序遍历 这里，用于实验的二叉树: //二叉搜索树BST #include #include using namespace std; class TreeNode{ public: int key; TreeNode* left; TreeNode* right; TreeNode* p;//
BST的基本代码实现(详细注释)
weixin_47182486的博客
10-11 1234
BST的基本代码实现(详细注释) 用的都是非常朴素的方法，欢迎交流讨论 #include<iostream> #include<queue> using namespace std; typedef struct Bnode { Bnode*left, *right; int data; }BSTnode, *BSTree; void insert(BSTree &root,int val)//改变内容需用指针的引用 { if (!root) { root = n
二叉搜索树(BST)的基本操作
姿势水平
11-27 1416
二叉树的一个重要应用是查找其中的元素，二叉搜索树则是针对数据的动态查找而设计的一种高效的数据结构类型。二叉搜索树是一种特殊的二叉树，它可以为空；如果不为空，满足以下性质：1. 非空 左子树 的所有键值小于其根结点的键值。2. 非空 右子树 的所有键值大于其根结点的键值。3. 左右子树都是二叉搜索树。 由于定义的不同，二叉搜索树也有一些不同于二叉树的操作函数，本文实现了二叉搜索树的指定元素查找、最小元素查找、最大元素查找、插入和删除元素等功能。
BST构造
zerlina98的博客
01-22 391
#include using namespace std; #include class BstTree{ struct Node{ Node *left; Node *right; int data; Node(int i):data(i),left(NULL),right(NULL){ } }; public: Node* ro
BST
海绵的博客
08-09 188
Consider an infinite full binary search tree (see the figure below), the numbers in the nodes are 1, 2, 3, .... In a subtree whose root node is X, we can get the minimum number in this subtree by repe
java 二叉搜索树实现
最新发布
12-08
以下是Java实现二叉搜索树的基本步骤和代码示例： 1.定义二叉搜索树节点类 ```java class TreeNode { int val; TreeNode left; TreeNode right; TreeNode(int x) { val = x; } } ``` 2.定义二叉搜索树类 ```java class BST { private TreeNode root; public BST() { root = null; } // 向二叉搜索树中插入元素 public void insert(int val) { root = insert(root, val); } private TreeNode insert(TreeNode node, int val) { if (node == null) { return new TreeNode(val); } if (val < node.val) { node.left = insert(node.left, val); } else if (val > node.val) { node.right = insert(node.right, val); } return node; } // 在二叉搜索树中查找元素 public boolean search(int val) { return search(root, val); } private boolean search(TreeNode node, int val) { if (node == null) { return false; } if (val == node.val) { return true; } else if (val < node.val) { return search(node.left, val); } else { return search(node.right, val); } } // 删除二叉搜索树中的元素 public void delete(int val) { root = delete(root, val); } private TreeNode delete(TreeNode node, int val) { if (node == null) { return null; } if (val < node.val) { node.left = delete(node.left, val); } else if (val > node.val) { node.right = delete(node.right, val); } else { if (node.left == null) { return node.right; } else if (node.right == null) { return node.left; } TreeNode minNode = findMin(node.right); node.val = minNode.val; node.right = delete(node.right, node.val); } return node; } private TreeNode findMin(TreeNode node) { while (node.left != null) { node = node.left; } return node; } } ``` 3.测试代码 ```java public class TestBST { public static void main(String[] args) { BST bst = new BST(); bst.insert(5); bst.insert(3); bst.insert(7); bst.insert(1); bst.insert(9); System.out.println(bst.search(3)); // 输出：true bst.delete(3); System.out.println(bst.search(3)); // 输出：false } } ```

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值