数据结构与算法系列----平衡二叉树（AVL树）

最新推荐文章于 2022-11-13 17:32:42 发布
最新推荐文章于 2022-11-13 17:32:42 发布
阅读量2.1k 收藏 3
点赞数 2
分类专栏： ACM 与数据结构 文章标签： 平衡二叉树 AVL 数据结构 C++ 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/laojiu_/article/details/51898992
版权 
一：背景

平衡二叉树（又称AVL树）是二叉查找树的一个进化体，由于二叉查找树不是严格的O(logN)，所以引入一个具有平衡概念的二叉树，它的查找速度是O(logN)。所以在学习平衡二叉树之前，读者必须需要了解下二叉查找树，具体链接：二叉查找树


那么平衡是什么意思？我们要求对于一棵二叉查找树 ，它的每一个节点的左右子树高度之差不超过1。（对于树的高度的约定：空节点高度是0；叶子节点高度是1。）例如下图：


在进行下面的分析之前，我们先对AVL树作个概述，让读者先了解其运作机制，而后读者接下来的阅读才会容易许多。


我们为何说普通的二叉查找树不是严格的O(logN)复杂度呢？可以试想，如果我们插入的是一组有序上升或下降的数据，必然造成二叉查找树退化成一个单链表，其深度就是链表长度，查找效率为O（n），与我们想要的O(logN)比起相形见绌，因此我们想到“平衡”这个概念，继而引入二叉查找树，这就是我们接下来要讲的“平衡二叉树”，上图已经完美诠释了“平衡”的概念，读者可以再看一遍。


讲到平衡，那又如何去平衡呢？如何判断失衡呢？判断失衡很简单，我们只需在节点里加个变量，不妨设为m_height，其意义是该节点下的树的高度，在插入数据或者删除数据时我们要判断这个节点的左右儿子节点的高度之差是否大于1即可。


当我们发现该节点不平衡，我们自然需要对其做些处理，使其满足平衡。经过分析，在插入数据或者删除数据时只会有四种失衡的情况，所以我们需要对这四种情况分别写出应对的代码。这也就是我们第二部分即将要讲的四种应对之策----旋转。旋转学完，接下来的内容就不是很难了，无非就是插入，删除，查找，打印了，和二叉查找树差不多，唯一的区别就是判断失衡和失衡后的旋转，代码都有注释，一看就懂。


好，接下来先看下我们给AVL树定义的节点结构，代码如下：

typedef struct Node
{
	int m_key;
	int m_height;
	Node* m_lChild;
	Node* m_rChild;
	Node(int key)
	{
		m_key = key;
		m_height = 1;
		m_rChild = m_lChild = nullptr;
	}
}* PNode;


二：旋转算法

1.左左情况


节点3的左子树比右子树高2，左节点2的左子树比右子树高，这称为左左情况。

/* 左左情况，p指向失衡点，即图例中3 */
PNode LL_Rotate(PNode & p)
{
	cout << "LL\n";

	PNode top = p->m_lChild;
	p->m_lChild = top->m_rChild;
	top->m_rChild = p;

	p->m_height = max(Height(p->m_lChild), Height(p->m_rChild)) + 1;
	top->m_height = max(Height(top->m_lChild), Height(top->m_rChild)) + 1;

	return top;
}

2.右右情况

节点3的右子树比左子树高2，右节点4的右子树比左子树高，这称为右右情况。

/* 右右情况，p指向失衡点，即图例中3 */
PNode RR_Rotate(PNode & p)
{
	cout << "RR\n";

	PNode top = p->m_rChild;
	p->m_rChild = top->m_lChild;
	top->m_lChild = p;

	p->m_height = max(Height(p->m_lChild), Height(p->m_rChild)) + 1;
	top->m_height = max(Height(top->m_lChild), Height(top->m_rChild)) + 1;

	return top;
}

3.左右情况

节点5的左子树比右子树高2，左节点2的右子树比左子树高，这称为左右情况。

/* 左右情况，p指向失衡点，即图例中5 */
PNode LR_Rotate(PNode & p)
{
	cout << "LR\n";

	p->m_lChild = RR_Rotate(p->m_lChild);
	return LL_Rotate(p);
}

4.右左情况

节点15的右子树比左子树高2，右节点20的左子树比右子树高，这称为右左情况。

/* 右左情况，p指向失衡点，即图例中15 */
PNode RL_Rotate(PNode & p)
{
	cout << "RL\n";

	p->m_rChild = LL_Rotate(p->m_rChild);
	return RR_Rotate(p);
}

三：其它算法实现

在写之前，先看两个辅助函数：

/* 计算当前节点的高度 */
int Height(PNode & p)
{
	return (p == nullptr) ? 0 : p->m_height;
}

/* 找到该节点下的最小值节点，返回该最小值，注意参数不是引用传递 */
int FindMin(PNode  p)
{
	while (p->m_lChild)
		p = p->m_lChild;
	return p->m_key;
}

1.插入

利用递归，我们先将节点插入，插入成功即递归结束，在一层一层的结束时，然后判断经过的每个节点的左右子树高度差，进行调整。

/* 添加操作 */
bool Add(int key, PNode & p)
{
	if (p == nullptr)
	{
		p = new Node(key);
		return true;
	}
	else
	{
		if (key == p->m_key)//已存在，直接退出
			return false;

		if (key < p->m_key)//左子树
		{
			if (Add(key, p->m_lChild))//是否成功插入
			{
				if (Height(p->m_lChild) - Height(p->m_rChild) == 2)//高度差等于2，得旋转调整
				{
					if (key < p->m_lChild->m_key)
						p = LL_Rotate(p);//左左情况
					else
						p = LR_Rotate(p);//左右情况
				}
				p->m_height = max(Height(p->m_lChild), Height(p->m_rChild)) + 1;//更新高度
				return true;
			}
			else
				return false;
		}

		else //右子树
		{
			if (Add(key, p->m_rChild))
			{
				if (Height(p->m_lChild) - Height(p->m_rChild) == -2)
				{
					if (key > p->m_rChild->m_key)
						p = RR_Rotate(p);
					else
						p = RL_Rotate(p);
				}
				p->m_height = max(Height(p->m_lChild), Height(p->m_rChild)) + 1;//更新高度
				return true;
			}
			else
				return false;
		}
	}
}

2.删除

删除的节点一共三种类型：有左右孩子；没有左右孩子；只有一个孩子（左或者右）。

其中对于第一种情况，也就是该节点是有左右孩子的，这里用了一个巧妙的方法，利用转化的思想，具体看代码，把这种情况转化为第二种或第三种。

/* 删除操作 */
bool Delete(int key, PNode & p)
{
	if (p == nullptr)
		return false;
	else
	{
		if (key == p->m_key)//找到该点
		{
			if (p->m_lChild && p->m_rChild)//左右孩子都存在
			{
				p->m_key = FindMin(p->m_rChild);//找到该节点下的最小节点
				Delete(p->m_key, p->m_rChild);//转化为: 删除找到的这个最小节点
			}
			else if (!p->m_lChild && !p->m_rChild)//左右孩子都不存在
			{
				PNode t = p;//注意p是引用类型
				p = nullptr;
				delete t;
				return true;
			}
			else//左右孩子只存在一个
			{
				PNode t = p;
				p = (p->m_lChild == nullptr) ? p->m_rChild : p->m_lChild;
				delete t;
				return true;
			}
		}

		else if (key < p->m_key)//在左子树删除
		{
			if (Delete(key, p->m_lChild))
			{
				if (Height(p->m_lChild) - Height(p->m_rChild) == 2)
				{
					if (key < p->m_lChild->m_key)
						p = LL_Rotate(p);
					else
						p = LR_Rotate(p);
				}

				p->m_height = max(Height(p->m_lChild), Height(p->m_rChild)) + 1;
				return true;
			}
			else
				return false;
		}
		else//在右子树删除
		{
			if (Delete(key, p->m_rChild))
			{
				if (Height(p->m_lChild) - Height(p->m_rChild) == -2)
				{
					if (key > p->m_rChild->m_key)
						p = RR_Rotate(p);
					else
						p = RL_Rotate(p);
				}
				p->m_height = max(Height(p->m_lChild), Height(p->m_rChild)) + 1;
				return true;
			}
			else
				return false;
		}
	}
}

3.查找 
/* 查找操作 */
bool Find(int key, PNode & p)
{
	if (p == nullptr)
		return false;
	else
	{
		if (key == p->m_key)
			return true;
		else if (key < p->m_key)
			return Find(key, p->m_lChild);
		else
			return Find(key, p->m_rChild);
	}
}

4.层次遍历 

/* 层次遍历，和普通的层次遍历不一样，打印的结果模拟了树的形状 */
void PrintTheLevel(PNode & p, int level)
{
	if (p == nullptr || level <= 0)
		return;
	if (level == 1)
	{
		cout << p->m_key << "," << p->m_height << "  ";//输出节点及对应的高度
		return;
	}

	PrintTheLevel(p->m_lChild, level - 1);
	PrintTheLevel(p->m_rChild, level - 1);
}

void LevelOrder(PNode & p)
{
	int depth = Height(p);
	for (int i = 1; i <= depth; i++)
	{
		PrintTheLevel(p, i);//打印树的第i行
		cout << endl;
	}
}


四：完整代码

#define _CRT_SECURE_NO_DEPRECATE 
#define _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES 1 

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

typedef struct Node
{
    int m_key;
    int m_height;
    Node* m_lChild;
    Node* m_rChild;
    Node(int key)
    {
        m_key = key;
        m_height = 1;
        m_rChild = m_lChild = nullptr;
    }
}* PNode;

PNode pRoot = nullptr;//根节点


/* 计算当前节点的高度 */
int Height(PNode & p)
{
    return (p == nullptr) ? 0 : p->m_height;
}

/* 找到该节点下的最小值节点，返回该最小值，注意参数不是引用传递 */
int FindMin(PNode  p)
{
    while (p->m_lChild)
        p = p->m_lChild;
    return p->m_key;
}

/* 左左情况 */
PNode LL_Rotate(PNode & p)
{
    cout << "LL\n";

    PNode top = p->m_lChild;
    p->m_lChild = top->m_rChild;
    top->m_rChild = p;

    p->m_height = max(Height(p->m_lChild), Height(p->m_rChild)) + 1;
    top->m_height = max(Height(top->m_lChild), Height(top->m_rChild)) + 1;

    return top;
}

/* 右右情况 */
PNode RR_Rotate(PNode & p)
{
    cout << "RR\n";

    PNode top = p->m_rChild;
    p->m_rChild = top->m_lChild;
    top->m_lChild = p;

    p->m_height = max(Height(p->m_lChild), Height(p->m_rChild)) + 1;
    top->m_height = max(Height(top->m_lChild), Height(top->m_rChild)) + 1;

    return top;
}

/* 左右情况 */
PNode LR_Rotate(PNode & p)
{
    cout << "LR\n";

    p->m_lChild = RR_Rotate(p->m_lChild);
    return LL_Rotate(p);
}

/* 右左情况 */
PNode RL_Rotate(PNode & p)
{
    cout << "RL\n";

    p->m_rChild = LL_Rotate(p->m_rChild);
    return RR_Rotate(p);
}

/* 添加操作 */
bool Add(int key, PNode & p)
{
    if (p == nullptr)
    {
        p = new Node(key);
        return true;
    }
    else
    {
        if (key == p->m_key)//已存在，直接退出
            return false;

        if (key < p->m_key)//左子树
        {
            if (Add(key, p->m_lChild))//是否成功插入
            {
                if (Height(p->m_lChild) - Height(p->m_rChild) == 2)//高度差等于2，得旋转调整
                {
                    if (key < p->m_lChild->m_key)
                        p = LL_Rotate(p);//左左情况
                    else
                        p = LR_Rotate(p);//左右情况
                }
                p->m_height = max(Height(p->m_lChild), Height(p->m_rChild)) + 1;//更新高度
                return true;
            }
            else
                return false;
        }

        else //右子树
        {
            if (Add(key, p->m_rChild))
            {
                if (Height(p->m_lChild) - Height(p->m_rChild) == -2)
                {
                    if (key > p->m_rChild->m_key)
                        p = RR_Rotate(p);
                    else
                        p = RL_Rotate(p);
                }
                p->m_height = max(Height(p->m_lChild), Height(p->m_rChild)) + 1;//更新高度
                return true;
            }
            else
                return false;
        }
    }
}

/* 删除操作 */
bool Delete(int key, PNode & p)
{
    if (p == nullptr)
        return false;
    else
    {
        if (key == p->m_key)//找到该点
        {
            if (p->m_lChild && p->m_rChild)//左右孩子都存在
            {
                p->m_key = FindMin(p->m_rChild);//找到该节点下的最小节点
                Delete(p->m_key, p->m_rChild);//转化为: 删除找到的这个最小节点
            }
            else if (!p->m_lChild && !p->m_rChild)//左右孩子都不存在
            {
                PNode t = p;//注意p是引用类型
                p = nullptr;
                delete t;
                return true;
            }
            else//左右孩子只存在一个
            {
                PNode t = p;
                p = (p->m_lChild == nullptr) ? p->m_rChild : p->m_lChild;
                delete t;
                return true;
            }
        }

        else if (key < p->m_key)//在左子树删除
        {
            if (Delete(key, p->m_lChild))
            {
                if (Height(p->m_lChild) - Height(p->m_rChild) == 2)
                {
                    if (key < p->m_lChild->m_key)
                        p = LL_Rotate(p);
                    else
                        p = LR_Rotate(p);
                }

                p->m_height = max(Height(p->m_lChild), Height(p->m_rChild)) + 1;
                return true;
            }
            else
                return false;
        }
        else//在右子树删除
        {
            if (Delete(key, p->m_rChild))
            {
                if (Height(p->m_lChild) - Height(p->m_rChild) == -2)
                {
                    if (key > p->m_rChild->m_key)
                        p = RR_Rotate(p);
                    else
                        p = RL_Rotate(p);
                }
                p->m_height = max(Height(p->m_lChild), Height(p->m_rChild)) + 1;
                return true;
            }
            else
                return false;
        }
    }
}

/* 查找操作 */
bool Find(int key, PNode & p)
{
    if (p == nullptr)
        return false;
    else
    {
        if (key == p->m_key)
            return true;
        else if (key < p->m_key)
            return Find(key, p->m_lChild);
        else
            return Find(key, p->m_rChild);
    }
}

/* 层次遍历，和普通的层次遍历不一样，打印的结果模拟了树的形状 */
void PrintTheLevel(PNode & p, int level)
{
    if (p == nullptr || level <= 0)
        return;
    if (level == 1)
    {
        cout << p->m_key << "," << p->m_height << "  ";//输出节点及对应的高度
        return;
    }

    PrintTheLevel(p->m_lChild, level - 1);
    PrintTheLevel(p->m_rChild, level - 1);
}

void LevelOrder(PNode & p)
{
    int depth = Height(p);
    for (int i = 1; i <= depth; i++)
    {
        PrintTheLevel(p, i);
        cout << endl;
    }
}

int main()
{


    
    return 0;
}







数据测试方面，请读者自行设计数据，针对各算法进行测试，博主设计的多组数据运行均正确。

若程序有错，请一定底下留言，博主会及时回复，谢谢。




返回目录---->数据结构与算法目录







图片资源来自及参考自：

http://www.cppblog.com/cxiaojia/archive/2012/08/20/187776.html

http://www.cnblogs.com/huangxincheng/archive/2012/07/22/2603956.html




LaoJiu_
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
平衡树——AVL算法
_int_me的博客
05-02 1031
有关AVL树的解析
数据结构（十五）二叉树 —— 平衡二叉树
在路上
08-12 924
在前面的章节已经有总结过，在某些特定的情况下，二叉排序树是有可能退化成单链表的。也就是说，如果一个二叉排序树对已经有序的序列进行排序，那么其中的结构就会退化成单链表，并且元素的查找效率也会明显的下降，那么此时我们需要一些特别的手段保证这个二叉排序树的“平衡”，进而保证查询元素的效率。
二叉树——平衡二叉树
csdn18529124315的博客
04-15 1238
平衡二叉树是二叉树变异，规则更加苛刻 想要将二叉树变为平衡二叉树，主要通过左旋和右旋来处理， 平衡二叉树和二叉树的区别是： 一：平衡二叉树要求重最上层的跟节点到最下面的叶节点经过的路程或者数据个数到小于或者与绝对值1 （根节点到叶节点的路径长度的最大值和最小值分别为a和b，那么a-b的绝对值要大于或等于1 ，如有 |a-b| >=1） 二：平衡树的根节点的左侧数据必须小于根节点，右侧树的数据必须大于根节点 开始解释平衡二叉树和二叉树的区别第一个点 下面开始上图（这个图只是普通的二叉树）： 从90到6
平衡二叉树详解 通俗易懂
热门推荐
半亩方糖
01-10 11万+
平衡二叉树（AVL） 阅读之前请先了解 二叉搜索树 平衡二叉树定义：任意节点的子树的高度差都小于等于 1 1. 为什么使用「平衡二叉树」 二叉树能提高查询的效率 O(logn)，但是当你插入 {1,2,3,4,5,6} 这种数据的时候，你的二叉树就像一个「链表」一样，搜索效率变为 O(n) 于是在 1962 年，一个姓 AV 的大佬（G. M. Adelson-Velsky） 和一个姓 L 的大佬（ Evgenii Landis）提出「平衡二叉树」（AVL） 。 于是插入 {1,2,3,4,5,6}
平衡二叉树详解
尽量致力于发表微服务、中间件和算法等原创作品。
06-17 4万+
平衡二叉树（Balanced Binary Tree）又被称为AVL树（有别于AVL算法），且具有以下性质：它是一 棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。这个方案很好的解决了二叉查找树退化成链表的问题，把插入，查找，删除的时间复杂度最好情况和最坏情况都维持在O(logN)。但是频繁旋转会使插入和删除牺牲掉O(logN)左右的时间，不过相对二叉查找树来说，时间上稳定了很多。 平衡二叉树大部分操作和二叉查找树类似，主要不同在于插入删除的时候平衡二叉树的平衡可
数据结构算法与应用-C C++语言描述
11-19
第二部分 数据结构 第3章 数据描述 75 3.1 引言 75 3.2 线性表 76 3.3 公式化描述 77 3.3.1 基本概念 77 3.3.2 异常类NoMem 79 3.3.3 操作 79 3.3.4 评价 83 3.4 链表描述 86 3.4.1 类ChainNode 和Chain 86 3.4.2 ...
java-data-structures-algorithms:Java 数据结构算法
05-30
Java 数据结构算法 使用 Java 的数据结构算法 先决条件 git 2.6+ Maven 3+ Java 8+ 排序 、 、 、 、 、 、 搜索 二进制, 顺序 数据结构 堆 堆栈数组， 堆栈链接 队列 数组或链接 最小/ 最大优先级队列 ...
数据结构算法与应用-C__语言描述
01-19
本书在简要回顾了基本的C++ 程序设计概念的基础上，全面系统地介绍了队列、堆栈、树、图等基本数据结构，以及贪婪算法、分而治之算法、分枝定界算法等多种算法设计方法，为数据结构与算法的继续学习和研究奠定了一...
03平衡二叉树_AVLTree.rar_03平衡二叉树_AVLTree_大话数据结构_平衡二叉树
09-21
查找算法，平衡二叉树，大话数据结构里面的。
二叉树：平衡二叉树
qq_46785243的博客
11-13 1284
平衡二叉树
平衡二叉树的建立c语言实现
09-03
平衡二叉树的建立c语言实现。详细的实现了对平衡二叉树的创建。通过这个能很好的理解平衡二叉树及其数据结构
平衡二叉树
清风
05-01 4万+
1.定义 平衡二叉树，又称AVL树，用于解决二叉排序树高度不确定的情况，如果二叉排序树的子树间的高度相差太大，就会让二叉排序树操作的时间复杂度升级为O(n)，为了避免这一情况，为最坏的情况做准备，就出现了平衡二叉树，使树的高度尽可能的小，其本质还是一棵二叉搜索树。 平衡二叉树的性质： 左子树和右子树的高度之差的绝对值小于等于1 左子树和右子树也是平衡二叉树 为了方便起见，给树上的每个结点附加一个数字，给出该结点左子树与右子树的高度差，这个数字称为结点的平衡因子（BF） 平衡因子=结点左子树的高度-
平衡二叉树（AVL）详解
H_Q_Li的博客
04-04 3866
平衡二叉树（AVL） 1、为什么会出现平衡二叉树 平衡二叉树（Balanced Binary Tree），又称AVL树，指的是左子树上的所有节点的值都比根节点的值小，而右子树上的所有节点的值都比根节点的值大，且左子树与右子树的高度差最大为1。 平衡二叉树性质：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。 知道了平衡二叉树的概念之后，我们来聊聊为什么会...
算法：二叉平衡树（AVL树）
OceanStar的博客
10-07 6981
平衡二叉树定义 平衡二叉树 全称叫做 平衡二叉搜索（排序）树，简称 AVL树。英文：Balanced Binary Tree （BBT），注：二叉查找树(BST) AVL 什么意思？AVL 是大学教授 G.M. Adelson-Velsky 和 E.M. Landis 名称的缩写，他们提出的平衡二叉树的概念，为了纪念他们，将 平衡二叉树 称为 AVL树。 AVL树本质上是一颗二叉查找树，但是它又具有以下特点： 它是一棵空树或它的左右两个子树的高度差的绝对值不超过1， 左右两个子树 也都是一棵平衡二叉树。
二叉查找树与平衡二叉树
金发只是水一下的博客
08-29 8万+
二叉查找树 　　二叉查找树，也称二叉搜索树，或二叉排序树。其定义也比较简单，要么是一颗空树，要么就是具有如下性质的二叉树： （1）若任意节点的左子树不空，则左子树上所有结点的值均小于它的根结点的值； （2） 若任意节点的右子树不空，则右子树上所有结点的值均大于它的根结点的值； （3） 任意节点的左、右子树也分别为二叉查找树； （4） 没有键值相等的节点。 　　如上图所示，是不同形态...
二叉树的应用---2.平衡二叉树
roothahh的博客
04-15 2281
（一）平衡二叉树的概念： 由于二叉搜索树的时间复杂度最好为O（logn），最差为O（n），因此有了AVL树，即平衡二叉树，其时间复杂度为O（logn），其定义为： 1.平衡因子：二叉树中某结点的右子树的高度和左子树的高度差为该结点的平衡因子 2.平衡二叉树满足（1）树中任一结点的平衡因子的绝对值不超过1（2）任一结点的左子树和右子树均是平衡二叉树 如图所示即为一个平衡二叉树： 如图是一个非二叉树： 由于二平衡二叉树是一种特殊的二叉搜索树，其查找操作与二叉搜索树类似，不再考虑； （二）平衡二叉树的插入
基础算法汇总之AVL树实现
学习和工作总结，共勉！
10-25 392
一. 什么是AVL树？ 在说AVL树之前，先回顾一下我们之前研究过的二分查找树（二分搜索树），在极端的情况下，二分搜索树会从一棵二叉树变为链表（按顺序插入数据）这样的查询效率会大打折扣。 测试上一节二叉查找树在极端情况下的例子： 为了解决这个问题，就需要通过增加一些属性和变化，将二叉查找树转为（在创建二叉树时候进行旋转让二叉树再次平衡）二叉平衡树。 AVL树（由G.M.Adelson-Velsky和Evgenii Landis发明，AVL命名是使用两个人的名字缩写组成）是最早的自平衡二叉搜索树，AVL树
二叉树和平衡二叉树
SHUIHAN_007的博客
04-07 1044
为什么需要树这种数据结构 数组存储方式的分析 优点：通过下标方式访问元素，速度快。对于有序数组，还可使用二分查找提高检索速度。 缺点：如果要检索具体某个值，或者插入值(按一定顺序)会整体移动，效率较低 链式存储方式的分析 优点：在一定程度上对数组存储方式有优化(比如：插入一个数值节点，只需要将插入节点，链接到链表中即可， 删除效率也很好)。 缺点：在进行检索时，效率仍然较低，比如(检索某个值，需要从头节点开始遍历) 树存储方式的分析 能提高数据存储，读取的效率, 比如利用 二叉排序树(Binary Sort
数据结构与算法 - 查找
最新发布
07-29
5. 平衡二叉树（如AVL树、红黑树）查找：在平衡二叉树中进行查找操作，保持树的平衡性，使得查找操作具有较好的时间复杂度。 6. B树/B+树查找：B树和B+树是一种多路搜索树，可以在磁盘等外部存储设备上进行高效的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值