二叉搜索树【数据结构】

最新推荐文章于 2022-06-04 16:29:01 发布
原创 最新推荐文章于 2022-06-04 16:29:01 发布 · 191 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#C语言 #二叉树 #数据结构 #搜索 #二叉搜索树

二叉搜索树（Binary Search Tree）：

（又：二叉搜索树，二叉排序树）

它或者是一棵空树，或者是具有下列性质的二叉树：

  若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值；

  若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；

  它的左、右子树也分别为二叉排序树。 ————百度百科



二叉搜索树的基本操作：

构成:既然是二叉树那么构成一定包括了左子树、右子树、结点的值域

typedef struct BSTNode
{
	struct BSTNode* _left;		
	struct BSTNode* _right;		
	BSTDataType _data;
}BNode, *pBNode;

插入：在二叉搜索树中插入新元素时，必须先检测该元素是否在树中已经存在。如果已经存在，则不进行插入；否则将新元素加入到搜索停止的地方。 

1、树为空，则直接插入，插入节点为根节点

2、树不为空，则按照二叉搜索树的特性查找要插入的位置，插入

int InsertBSTree(pBNode* pRoot, BSTDataType data)
{
	pBNode pCur = NULL;			//插入的元素
	pBNode pParent = NULL;		//插入元素的双亲
	assert(pRoot);
	//空树
	if (NULL == *pRoot)		//空树则插入节点为根节点
	{
		*pRoot = BuyNode(data);
		return 1;
	}
	//找待插入元素的位置
	pCur = *pRoot;
	while (pCur)
	{
		if (data < pCur->_data)
		{
			pParent = pCur;
			pCur = pCur->_left;
		}
		else if (data > pCur->_data)
		{
			pParent = pCur;
			pCur = pCur->_right;
		}
		else
		{
			return 0;
		}
	}

	//插入新节点
	pCur = BuyNode(data);			//接收新的结点

	if (data > pParent->_data)
	{
		pParent->_right = pCur;
	}
	else
	{
		pParent->_left = pCur;
	}
	return 1;
}
删除：首先查找元素是否在二叉搜索树中，如果不存在，则返回, 否则要  删除的结点可能分下面四种情况：  
a. 要删除的结点无孩子结点  
b. 要删除的结点只有左孩子结点  
c. 要删除的结点只有右孩子结点  
d. 要删除的结点有左、右孩子结点  
情况a可以归类到c或者d  
对于上述情况，相应的删除方法如下：  
a. 直接删除该结点  
b. 删除该结点且使被删除节点的双亲结点指向被删除节点的左孩子
结点  
c. 删除该结点且使被删除节点的双亲结点指向被删除结点的右孩子结
点  
d. 在它的右子树中寻找中序下的第一个结点(关键码最小)，用它的值填补到被删除节点中，在来处理该结点的删除问题  


int DeleteBSTree(pBNode* pRoot, BSTDataType data)
{
	pBNode pCur = NULL;					//标记当前结点
	pBNode pParent = NULL;				//标记当前结点的双亲节点
	pBNode pDel = NULL;					//标记要删除的树
	/* 存在？ 空树？ */
	assert(pRoot);
	if (NULL == *pRoot)
	{
		return 0;
	}

	/* 找出删除节点的位置 */
	pCur = *pRoot;
	while (pCur)
	{
		if (data == pCur->_data)
			break;
		else if (data < pCur->_data)
		{
			pParent = pCur;
			pCur = pCur->_left;
		}
		else
		{
			pParent = pCur;
			pCur = pCur->_right;
		}
	}
	if (NULL == pCur)//没找到要删除的结点
	{
		return 0;
	}

	/* 对节点进行删除  */
	//1.只有左孩子
	if (NULL == pCur->_right)
	{
		pDel = pCur;
		//1>节点是根节点------直接删
		if (pCur == *pRoot)
		{
			*pRoot = pCur->_left;
		}
		//2>节点是有左子树的结点-------让pParent 的左子树指向pCur的左子树
		else
		{
			if (pCur == pParent->_left)//删除没有2的1.
			{
				pParent->_left = pCur->_left;
			}
			else
			{
				pParent->_right = pCur->_left;
			}

		}
	}
	//2.只有右孩子
	else if (NULL == pCur->_left)
	{
		pDel = pCur;
		//1>根节点----直接删
		if (pCur == *pRoot)
		{
			*pRoot = pCur->_right;
		}
		//只有右子树的非根节点
		else
		{
			if (pCur == pParent->_right)
			{
				pParent->_right = pCur->_right;
			}
			else
			{
				pParent->_left = pCur->_right;
			}
		}
	}
	//3.左右孩子都有-----在右子树中找最小的节点替换后删除最小节点
	//              -----在左子树中找最大的结点替换后删除
	else
	{
		//方法一：在左子树中找最大的元素替换
		//pParent = pCur;
		//pDel = pParent->_left;
		//while (pDel->_right)
		//{
		//	pParent = pDel;
		//	pDel = pDel->_right;
		//}
		//pCur->_data = pDel->_data;
		//if (pDel == pParent->_right)  //要删除结点是双亲的右
		//{
		//	pParent->_right = pDel->_left;
		//}
		//else
		//{
		//	pParent->_left = pDel->_left;
		//}

		//方法二：在右子树中找最小的替换
		pParent = pCur;
		pDel = pCur->_right;

		while (pDel->_left)		//遍历找到最小的结点
		{
			pParent = pDel;
			pDel = pDel->_left;
		}
		pCur->_data = pDel->_data;		
		if ( pDel == pParent->_left)	//删除最小的结点
		{
			pParent->_left = pDel->_right;
		}
		else
		{
			pParent->_right = pDel->_right;
		}
	}

	free(pDel);
	pDel = NULL;
	return 1;
}
查找： 在子树中查找、找到返回true、否则返回False 

pBNode FindBSTree(pBNode pRoot, BSTDataType data)
{
	pBNode pCur = pRoot;		//从根节点开始
	while (pCur)			//遍历整个二叉树
	{
		if (data == pCur->_data)
			return pCur;
		else if (data > pCur->_data)
		{
			pCur = pCur->_right;
		}
		else
		{
			pCur = pCur->_left;
		}
	}

	return NULL;
}

完整代码：

1.Test.c

#include "BSTree.h"
#include <stdlib.h>


int main()
{
	TestBSTree();
	system("pause");
	return 0;
}


2.BSTree.h 

#pragma once				//二叉搜索树---O(N)  单支

typedef int BSTDataType;
#define NULL 0

typedef struct BSTNode
{
	struct BSTNode* _left;		
	struct BSTNode* _right;		
	BSTDataType _data;
}BNode, *pBNode;


void InitBSTree(pBNode* pRoot);						//初始化
int InsertBSTree(pBNode* pRoot, BSTDataType data);	//插入
int DeleteBSTree(pBNode* pRoot, BSTDataType data);	//删除
pBNode FindBSTree(pBNode pRoot, BSTDataType data);	//查找
void DestoryBSTree(pBNode* pRoot);					//销毁

int InsertBSTree_D(pBNode* pRoot, BSTDataType data);//递归插入
int DeleteBSTree_D(pBNode* pRoot, BSTDataType data);//递归删除
pBNode FindBSTree_D(pBNode pRoot, BSTDataType data);//递归查找


void InOrder(pBNode pRoot);							//中序遍历
pBNode BuyNode(BSTDataType data);					

void TestBSTree();


3.BSTree.c

#include "BSTree.h"
#include <malloc.h>
#include <assert.h>
#include <stdio.h>


void InitBSTree(pBNode* pRoot)
{
	assert(pRoot);
	*pRoot = NULL;
}
//构建新节点
pBNode BuyNode(BSTDataType data)
{
	pBNode pNode = (pBNode)malloc(sizeof(BNode));
	if (NULL == pNode)
	{
		return NULL;;
	}
	pNode->_data = data;
	pNode->_left = NULL;
	pNode->_right = NULL;
	return pNode;
}

int InsertBSTree_D(pBNode* pRoot, BSTDataType data)
{
	assert(pRoot);
	if (NULL == *pRoot)
	{
		*pRoot = BuyNode(data);
		return 1;
	}
	else
	{
		if (data == (*pRoot)->_data)
		{
			return 0;
		}
		if (data > (*pRoot)->_data)
		{
			return InsertBSTree_D(&(*pRoot)->_right, data);
		}
		else 
		{
			return InsertBSTree_D(&(*pRoot)->_left, data);
		}
	}
}

int InsertBSTree(pBNode* pRoot, BSTDataType data)
{
	pBNode pCur = NULL;			//插入的元素
	pBNode pParent = NULL;		//插入元素的双亲
	assert(pRoot);
	//空树
	if (NULL == *pRoot)		//空树则插入节点为根节点
	{
		*pRoot = BuyNode(data);
		return 1;
	}
	//找待插入元素的位置
	pCur = *pRoot;
	while (pCur)
	{
		if (data < pCur->_data)
		{
			pParent = pCur;
			pCur = pCur->_left;
		}
		else if (data > pCur->_data)
		{
			pParent = pCur;
			pCur = pCur->_right;
		}
		else
		{
			return 0;
		}
	}

	//插入新节点
	pCur = BuyNode(data);			//接收新的结点

	if (data > pParent->_data)
	{
		pParent->_right = pCur;
	}
	else
	{
		pParent->_left = pCur;
	}
	return 1;
}

int DeleteBSTree_D(pBNode* pRoot, BSTDataType data)
{
	assert(pRoot);
	if (NULL == *pRoot)
	{
		return 0;
	}
	else
	{
		if (data > (*pRoot)->_data)
		{
			return DeleteBSTree_D(&(*pRoot)->_right, data);
		}
		else if (data < (*pRoot)->_data)
		{
			return DeleteBSTree_D(&(*pRoot)->_left, data);
		}
		else
		{
			//已找到要删除的结点
			//1.只有左子树
			pBNode pDel = *pRoot;
				
			if (NULL == (*pRoot)->_right)
			{
				*pRoot = pDel->_left;
				free(pDel);
				return 1;
			}
			//2.只有右子树
			else if (NULL == (*pRoot)->_left)
			{
				*pRoot = pDel->_right;
				free(pDel);
				return 1;
			}
			//3.左右子树都存在
			else
			{
				//在右子树中找出要替换的结点（最小）
				//pBNode pParent = *pRoot;
				pDel = (*pRoot)->_right;
				while (pDel->_left)
				{
					//pParent = pDel;
					pDel = pDel->_left;
				}
				(*pRoot)->_data = pDel->_data;
				return DeleteBSTree_D(&(*pRoot)->_right, pDel->_data);
			}
		}
	}
}

int DeleteBSTree(pBNode* pRoot, BSTDataType data)
{
	pBNode pCur = NULL;					//标记当前结点
	pBNode pParent = NULL;				//标记当前结点的双亲节点
	pBNode pDel = NULL;					//标记要删除的树
	/* 存在？ 空树？ */
	assert(pRoot);
	if (NULL == *pRoot)
	{
		return 0;
	}

	/* 找出删除节点的位置 */
	pCur = *pRoot;
	while (pCur)
	{
		if (data == pCur->_data)
			break;
		else if (data < pCur->_data)
		{
			pParent = pCur;
			pCur = pCur->_left;
		}
		else
		{
			pParent = pCur;
			pCur = pCur->_right;
		}
	}
	if (NULL == pCur)//没找到要删除的结点
	{
		return 0;
	}

	/* 对节点进行删除  */
	//1.只有左孩子
	if (NULL == pCur->_right)
	{
		pDel = pCur;
		//1>节点是根节点------直接删
		if (pCur == *pRoot)
		{
			*pRoot = pCur->_left;
		}
		//2>节点是有左子树的结点-------让pParent 的左子树指向pCur的左子树
		else
		{
			if (pCur == pParent->_left)//删除没有2的1.
			{
				pParent->_left = pCur->_left;
			}
			else
			{
				pParent->_right = pCur->_left;
			}

		}
	}
	//2.只有右孩子
	else if (NULL == pCur->_left)
	{
		pDel = pCur;
		//1>根节点----直接删
		if (pCur == *pRoot)
		{
			*pRoot = pCur->_right;
		}
		//只有右子树的非根节点
		else
		{
			if (pCur == pParent->_right)
			{
				pParent->_right = pCur->_right;
			}
			else
			{
				pParent->_left = pCur->_right;
			}
		}
	}
	//3.左右孩子都有-----在右子树中找最小的节点替换后删除最小节点
	//              -----在左子树中找最大的结点替换后删除
	else
	{
		//方法一：在左子树中找最大的元素替换
		//pParent = pCur;
		//pDel = pParent->_left;
		//while (pDel->_right)
		//{
		//	pParent = pDel;
		//	pDel = pDel->_right;
		//}
		//pCur->_data = pDel->_data;
		//if (pDel == pParent->_right)  //要删除结点是双亲的右
		//{
		//	pParent->_right = pDel->_left;
		//}
		//else
		//{
		//	pParent->_left = pDel->_left;
		//}

		//方法二：在右子树中找最小的替换
		pParent = pCur;
		pDel = pCur->_right;

		while (pDel->_left)		//遍历找到最小的结点
		{
			pParent = pDel;
			pDel = pDel->_left;
		}
		pCur->_data = pDel->_data;		
		if ( pDel == pParent->_left)	//删除最小的结点
		{
			pParent->_left = pDel->_right;
		}
		else
		{
			pParent->_right = pDel->_right;
		}
	}

	free(pDel);
	pDel = NULL;
	return 1;
}


pBNode FindBSTree_D(pBNode pRoot, BSTDataType data)
{
	if (NULL == pRoot)
	{
		return NULL;
	}
	else
	{
		if (data == pRoot->_data)
		{
			return pRoot;
		}
		else if (data > pRoot->_data)
		{
			return FindBSTree_D(pRoot->_right, data);
		}
		else
		{
			return FindBSTree_D(pRoot->_left, data);
		}
	}
}

	


void InOrder(pBNode pRoot)
{
	if (NULL == pRoot)
	{
		return;
	}
	if (pRoot)
	{
		InOrder(pRoot->_left);
		printf("%d ", pRoot->_data);
		InOrder(pRoot->_right);
	}
}

void DestoryBSTree(pBNode* pRoot)		//递归销毁
{
	assert(pRoot);
	if (NULL == *pRoot)
	{
		return;
	}
	else
	{
		if (NULL != (*pRoot)->_left)		//左子树不为空
		{
			DestoryBSTree(&(*pRoot)->_left);
		}
		if (NULL != (*pRoot)->_right)		//右子树不为空
		{
			DestoryBSTree(&(*pRoot)->_right);
		}
		if (NULL == (*pRoot)->_right && NULL == (*pRoot)->_left)//叶子节点
		{
			free(*pRoot);
			*pRoot = NULL;
		}
	}

}

void TestBSTree()
{
	int array[] = { 5, 3, 4, 1, 7, 8, 2, 6, 0, 9 };
	pBNode pRoot = NULL;
	pBNode pCur = NULL;
	int i = 0;
	int data = 10;

	InitBSTree(&pRoot);
	for (; i < sizeof(array) / sizeof(array[0]); i++)
	{
		InsertBSTree_D(&pRoot, array[i]);
	}
	InOrder(pRoot);
	printf("\n");
	DeleteBSTree(&pRoot, 7);
	InOrder(pRoot);
	printf("\n");

	pCur = FindBSTree(pRoot, data);
	if (pCur)
	{
		printf("%d is in BSTree!!!",data);
	}
	else
	{
		printf("%d is not in BSTree!!!", data);
	}
	DestoryBSTree(&pRoot);
	
}
二叉搜索树性能分析：

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


【数据结构】二叉搜索树（Java + 链表实现）
明志の博客
08-07 1777
Map接口是独立的实现Iterable接口的集合都是可以使用 for - Each 语句进行打印的搜索性能会非常高。
BST（二叉排序树）
foooooods的博客
01-25 1350
二叉查找树（Binary Search Tree），（又：二叉搜索树，二叉排序树）它或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 它的左、右子树也分别为二叉排序树。 查询二叉搜索树： 递归的： tree_search(x,k) if(x==NULL |...
搜索二叉树
宇哲
10-21 1861
二叉搜索树：它或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 它的左、右子树也分别为二叉排序树。二叉搜索树有个特点，最左的是最小的节点，最右的是最大的节点。 当我们把二叉搜索树进行中序遍历的时候，它是进行排序后的结果，所以我们也把二叉搜索树叫做排序二叉树。接下来我们介绍二叉
第七课 常见的二叉树：二叉搜索树
weixin_42430208的博客
06-29 655
第七章 常见的二叉树：二叉搜索树1 定义2 性质3 代码实现 1 定义 又称二叉排序树或者二叉查找树。它或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值 2 性质 （1）若它的左子树不为空，则左子树上的所有节点的值都小于它的根节点的值； （2）若它的右子树不为空，则右子树上所有节点的值都大于它的根节点的值； （3）其他的左右子树也分别为二叉查找树； （4）二叉查找树是动态查找表，在查找的
二叉查找树的构造与遍历（C++）
RToax
01-18 480
#include&lt;iostream&gt; #include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; #include&lt;malloc.h&gt; using namespace std; typedef struct BSTNode{ int key; struct BSTNode *left,*right; }BSTNode...
数据结构---二叉排序树
qq_43552933的博客
08-25 149
数据结构—二叉排序树 原理：参考趣学数据结构 代码： #include<stdio.h> #include<stdlib.h> typedef struct bstTree { int data; struct bstTree* lchild, *rchild; }bstTree; void createBSTTree(bstTree* & T,int data) {//创建二叉排序树 bstTree *p = NULL; if (!T) { p = (bstTr
二叉排序树（二叉搜索树）【C++】
zypf_lover的博客
06-04 677
二叉搜索树
数据结构课设二叉搜索树算法应用与实现
最新发布
11-26
二叉搜索树具有如下性质 结点的左子树只包含小于当前结点的数，结点的右子树只包含大于当前结点的数，所有左子树和右子树自身必须也是二叉搜索树。 遍历二叉树；在访问其左子树和右子树时，我们也按照同样的方式遍历...
BST.rar_bst_二叉搜索树_数据结构动画_树 动画
09-23
二叉搜索树（BST，Binary Search Tree），是数据结构中一种非常重要的树形数据结构，它的每个节点都包含一个键、一个关联值、一个指向左子节点的引用和一个指向右子节点的引用。在二叉搜索树中，对于任何有效的节点...
Java创建二叉搜索树,实现搜索,插入,删除的操作实例
08-28
Java 创建二叉搜索树是指通过 Java 语言实现一个二叉搜索树数据结构，该树具有查找、插入、删除等操作的功能。二叉搜索树是一种特殊的二叉树，每个节点的值大于左子树的值，小于右子树的值。因此，在实现二叉搜索树...
陈越、何钦铭-数据结构作业12：是否同一棵二叉搜索树
04-20
给定一个插入序列就可以唯一确定一棵二叉搜索树。然而，一棵给定的二叉搜索树却可以由多种不同的插入序列得到。例如分别按照序列{2, 1, 3}和{2, 3, 1}插入初始为空的二叉搜索树，都得到一样的结果。于是对于输入的...
二叉排序树（BST）
YKbsmn的博客
06-18 3359
二叉排序树（也称二叉查找树）。 性质：左子树结点值 < 根结点值 < 右子树结点值 所以对二叉排序树进行中序遍历，可以得到一个递增的xu'l
二叉排序树（BST）的存储结构及基本操作
vener_的博客
09-13 2062
1.存储结构定义 typedef struct BSTNode{ ElemType data; Struct *lchild,*rchild; }BSTNode,*BSTree; 2.查找 BSTNode *BST_Search(BSTree T,ElemType key) { while(T!=NULL&&key!=T->data) { if(key<T->data) T=T->lchild; else T=T->rchi
二叉搜索树的基本操作(插入，删除)
4559的博客
08-24 373
前言 基本操作 插入 删除 前言 二叉搜索树是什么 二叉查找树（Binary Search Tree），（又：二叉搜索树，二叉排序树）它或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 它的左、右子树也分别为二叉排序树。 基本操作 插入 ...
二叉树搜索树（即：二叉排序树，二叉查找树）
weixin_41423494的博客
04-13 4423
1、定义： 二叉排序树或者是一颗空树，或者是具有下列性质的二叉树： （1）若它的左子树不空，则左子树上的所有结点的值均小于它的根结点的值。 （2）若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值。 （3）它的左、右子树叶分别是二叉排序树。 二叉排序树是递归定义的。由定义可得：中叙遍历二叉排序树是可以得到一个结点值递增的序列。 二叉排序树的二叉链表存储表示： ...
二叉搜索树中删除一个结点(递归&非递归)
HanSion.Z
08-23 3404
1.思路 思路：在链式结构中，要删除一个结点，我们常规的做法是找到要删除结点的前一个结点，把它的和一个结点，挂在前一个结点上，但是对于二叉搜索树，既要删除一个结点，又要满足二叉搜索树的性质，是相对于比较难的。 二叉搜索树的删除大致分为以下类： 对于以上的四类要删除的结点，其实我们还可以在具体一些，将一二三类归在一起，第四类是一类。 下面是两类删除结点的方法 ...
二叉排序树(BSTree)关于查找算法结合
Steve Wang's blog
05-19 1580
/*基于树的顺序查找法*/ /*二叉排序树的存储结构*/ typedef struct node { KeyType key; /*关键字的值*/ struct node *lchild, *rchild; /*左右指针*/ } NSTNode, *BSTree; /*二叉排序树插入递归算法*/ void InsertBST(BSTr
二叉排序树（新建，插入，查找，删除）（C语言编写）
半岛落枫的博客
11-23 7442
#include #include typedef struct BSTNode{         int data;         struct BSTNode *lchild,*rchild; }BSTNode,*BSTree; BSTree InsertBST(BSTree T,int data); BSTree CreatBST(BSTree T)
带头结点的双向链表【数据结构】
czf的编程工坊
03-12 1491
带头结点的双向链表是链表的进阶形式，但是使用起来也是非常方便的，基础操作需理解
二叉搜索树数据结构分析
08-26
二叉搜索树（Binary Search Tree）是一种具有特定性质的二叉树。它可以是一棵空树，或者满足以下条件： 1. 如果左子树不为空，则左子树上所有节点的值都小于根节点的值。 2. 如果右子树不为空，则右子树上所有节点的值都大于根节点的值。 3. 左右子树也分别为二叉搜索树。 二叉搜索树作为一种经典的数据结构，具有许多优点。它既支持链表的快速插入和删除操作，又支持数组的快速查找操作。因此，在文件系统和数据库系统等领域，经常使用二叉搜索树来实现高效的排序和检索操作。 二叉搜索树的主要操作包括插入、遍历、查找和删除。插入操作将一个新节点插入到合适的位置，遍历操作按照规定的顺序访问树的各个节点，查找操作根据给定的值在树中找到对应的节点，删除操作将指定节点从树中删除。 关于二叉搜索树的性能分析，它的查找和插入操作的平均时间复杂度为O(logN)，其中N是树中节点的数量。但是，如果树变得不平衡，最坏情况下的时间复杂度可能达到O(N)。为了避免树的不平衡，可以使用平衡二叉搜索树如AVL树进行优化。 总结来说，二叉搜索树是一种常用的数据结构，它具有快速插入和删除的特点，同时也支持高效的查找操作。但需要注意，为了保持性能，需要保持树的平衡。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *3* [【数据结构】二叉搜索树剖析（附源码）](https://blog.youkuaiyun.com/weixin_52344401/article/details/122908681)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 50%"] - *2* [【Java 数据结构】实现一个二叉搜索树](https://blog.youkuaiyun.com/m0_61784621/article/details/128405350)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 50%"] [ .reference_list ]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值