AVL平衡树（AVL Tree）

CyberMuse2024-10-05 21:40

**场景：课堂讨论**

**小明（ESFP学生）**：张老师，为什么AVL树（AVL Tree）中的旋转操作这么重要？感觉只是节点的移动，有没有什么实际意义？

**张老师（ENTP老师）**：好问题，小明！旋转在AVL树中不只是简单的节点移动，它在保持树的平衡性方面起着关键作用。让我用几个例子来说明。

例子1：图书馆书架摆放

  • **张老师**：想象一下，图书馆的书架（Bookshelf）如果一边书多，一边书少，拿书的时候是不是很不方便？

  • **小明**：是的，会导致某边的书难以找到。

  • **张老师**：AVL树的旋转就像重新摆放书架上的书，让两边的书一样多，方便取书。

**代码示例**：

```python

节点类定义

class TreeNode:

def init(self, value):

self.value = value

self.left = None

self.right = None

self.height = 1

def right_rotate(y):

x = y.left # x是y的左子节点

T2 = x.right # T2是x的右子树，准备重新挂接

x.right = y # y成为x的右子节点

y.left = T2 # T2成为y的左子节点

更新高度

y.height = 1 + max(get_height(y.left), get_height(y.right))

x.height = 1 + max(get_height(x.left), get_height(x.right))

return x # 返回新的子树根节点

def get_height(node):

if not node:

return 0

return node.height

```

这段代码定义了一个简单的AVL树节点类`TreeNode`以及一个用于右旋的函数`right_rotate`。我们可以逐步解释这段代码的组成部分和功能：

1. `TreeNode` 类

```python

class TreeNode:

def init(self, value):

self.value = value

self.left = None

self.right = None

self.height = 1

```

  • **`init` 方法**：初始化一个树节点。

  • `value`：节点的值。

  • `left` 和 `right`：指向左子节点和右子节点的指针，初始为 `None`。

  • `height`：节点的高度，初始为1，因为新节点没有子节点时，高度为1。

2. `right_rotate` 函数

```python

def right_rotate(y):

x = y.left # x是y的左子节点

T2 = x.right # T2是x的右子树，准备重新挂接

x.right = y # y成为x的右子节点

y.left = T2 # T2成为y的左子节点

更新高度

y.height = 1 + max(get_height(y.left), get_height(y.right))

x.height = 1 + max(get_height(x.left), get_height(x.right))

return x # 返回新的子树根节点

```

  • **参数 `y`**：需要进行右旋转的子树的根节点。

  • **旋转过程**：

  1. `x = y.left`：将 `y` 的左子节点 `x` 存储。

  2. `T2 = x.right`：将 `x` 的右子树（如果有）存储为 `T2`。

  3. `x.right = y`：将 `y` 设为 `x` 的右子节点。

  4. `y.left = T2`：将 `T2` 挂在 `y` 的左子节点上。

  • **更新高度**：

  • `y.height`：重新计算 `y` 的高度，等于其左右子树高度的最大值加1。

  • `x.height`：重新计算 `x` 的高度。

  • **返回值**：返回新的子树根节点 `x`。

3. `get_height` 函数

```python

def get_height(node):

if not node:

return 0

return node.height

```

  • **功能**：返回节点的高度。如果节点不存在（`None`），返回高度为0。

使用场景

  • 这些函数是AVL树实现的一部分。AVL树是一种自平衡的二叉查找树，插入和删除操作后会通过旋转保持树的平衡。

  • `right_rotate` 是在AVL树中处理左重情况的一种旋转操作，它在插入或删除节点后用于恢复平衡。

示例

假设我们有一个不平衡的子树：

```

y

/

x

\

T2

```

执行 `right_rotate(y)` 后：

```

x

\

y

/

T2

```

通过右旋，树变得更加平衡。这是AVL树保持高度平衡的关键操作之一。

例子2：交通信号灯

  • **张老师**：再想象一下交通信号灯（Traffic Light），如果一边的车流过多，另一边很少，会造成交通堵塞。

  • **小明**：确实，那需要调整信号灯的时间。

  • **张老师**：在AVL树中，旋转就像调整信号灯的时间，保证两边车流均匀。

例子3：团队工作分配

  • **张老师**：最后，想象一个项目团队（Project Team），某些人工作过多，另一些人却很闲，会影响效率。

  • **小明**：对，应该重新分配工作。

  • **张老师**：AVL树的旋转就像重新分配任务，让每个人都有合理的工作量。

**小明（ESFP学生）**：明白了，旋转可以保持平衡，类似于现实生活中的许多场景。那旋转的具体操作就是为了确保树的高度尽可能小，从而提高效率，对吗？

**张老师（ENTP老师）**：完全正确！通过这些例子，你可以看到旋转在数据结构中帮助我们保持平衡状态，从而提高操作效率。

思维导图总结

```

[旋转在AVL树中的意义]

├── 保持平衡

│ ├── 高效查找

│ └── 高效插入/删除

├── 实际应用类比

│ ├── 图书馆书架

│ ├── 交通信号灯

│ └── 团队工作分配

└── 实现例子

├── 右旋操作代码

└── 高度更新

```

**老师（ENTP）**：同学们，今天我们来探讨AVL树（AVL Tree），这是一种自平衡的二叉查找树（Binary Search Tree, BST）。它的名字来自于两位发明者的首字母组合。首先，谁能告诉我AVL树的两个主要特性是什么？

**学生（ESFP）**：嗯，AVL树有两个主要特性吧？一个是它遵循二叉查找树的性质，另一个是它的平衡性。也就是每个节点的左子树和右子树的高度差不超过1，对吗？

**老师（ENTP）**：没错！AVL树的平衡性通过平衡因子（Balance Factor, BF）来监控。这个因子就是左子树高度减去右子树高度的值。现在，我们来看一个例子。假设我们有一个节点A，它的左子树高度是2，右子树高度是1，那么A的平衡因子是多少？

**学生（ESFP）**：平衡因子就是2减去1，所以是1。这说明A是平衡的。

**老师（ENTP）**：完全正确。那么当我们插入一个新节点导致平衡因子超过1或小于-1时，该怎么处理呢？

**学生（ESFP）**：我想这时候需要做旋转操作（Rotation）来恢复平衡。不过，可以再详细讲讲旋转吗？

**老师（ENTP）**：当然。旋转分为四种基本类型：LL（左左）旋转、LR（左右）旋转、RR（右右）旋转和RL（右左）旋转。我们通过一个具体例子来说明。

例子1：LL旋转

**老师（ENTP）**：假设我们有一个不平衡的子树：

```

C

/

B

/

A

```

这是一个典型的左左（LL）不平衡。我们要对节点C进行右旋（Right Rotation）。右旋后，树变成：

```

B

/ \

A C

```

**老师（ENTP）**：通过这次旋转，树重新获得平衡。请注意，旋转操作是局部的，只影响特定的子树。

例子2：LR旋转

**老师（ENTP）**：接下来，我们看看左右（LR）旋转的情况。假设我们有：

```

C

/

A

\

B

```

首先，对A进行左旋（Left Rotation），得到：

```

C

/

B

/

A

```

接着，对C进行右旋，最终结果是：

```

B

/ \

A C

```

这样，我们通过两次旋转恢复了平衡。

例子3：RR旋转

**老师（ENTP）**：我们再看一个右右（RR）旋转的例子：

```

A

\

B

\

C

```

这是一个右右不平衡，我们对A进行左旋：

```

B

/ \

A C

```

**老师（ENTP）**：通过左旋，树重新平衡。

**学生（ESFP）**：我明白了，旋转就是为了调整树的结构，使得每个节点的平衡因子在-1到1之间。通过这种方式，AVL树保持了高效的查找、插入和删除操作。

**老师（ENTP）**：很棒的总结！AVL树在数据库索引、文件系统索引等需要频繁查找且保持数据有序的场景中非常有用。虽然在插入和删除时可能需要多次旋转，但它的平衡性更高，这在查找操作中尤为重要。

**老师（ENTP）**：很好！现在我们更深入地探讨一下AVL树的一些实现细节和优化策略。首先，我们来看一下AVL树的节点结构。一般来说，AVL树节点除了存储键值对外，还需要保存什么信息呢？

**学生（ESFP）**：节点除了保存键值对，还需要保存左右子树的指针、父节点指针，以及一个平衡因子以记录高度差。

**老师（ENTP）**：对的。以下是一个C++中AVL节点的简化结构：

```cpp

template<class K, class V>

struct AVLNode {

AVLNode<K, V>* _left;

AVLNode<K, V>* _right;

AVLNode<K, V>* _parent;

int _bf; // 平衡因子

pair<K, V> _kv; // 键值对

AVLNode(const pair<K,V>& kv) : _bf(0), _kv(kv), _left(nullptr), _right(nullptr), _parent(nullptr) {}

};

```

**老师（ENTP）**：这种结构允许我们在旋转时轻松调整指针，并在插入和删除后快速更新平衡因子。接下来，我们来看看插入操作的具体流程。

插入操作详细流程

**老师（ENTP）**：插入操作分为几个步骤：标准的BST插入、更新平衡因子、检查平衡并进行必要的旋转修正。

  1. **标准BST插入**：按照二叉查找树的规则插入新节点。

  2. **更新平衡因子**：从插入点开始向上回溯，更新每个节点的平衡因子。

  3. **检查平衡并旋转**：如果某个节点的平衡因子超过1或小于-1，确定不平衡类型（LL、LR、RR、RL）并进行相应的旋转。

**学生（ESFP）**：所以每次插入后我们都要回溯到根节点，检查并修正所有可能的不平衡？

**老师（ENTP）**：通常只需修正第一个遇到的不平衡节点，因为旋转操作会恢复该子树的平衡，其父节点的平衡因子可能也会恢复正常。

AVL树的应用场景

**学生（ESFP）**：AVL树和红黑树（Red-Black Tree）相比有什么优缺点呢？

**老师（ENTP）**：AVL树比红黑树具有更严格的平衡性，这意味着在查找操作中，AVL树的性能通常更好。然而，这种严格的平衡性也意味着在插入和删除时，AVL树可能需要更多旋转，导致这些操作的开销比红黑树稍高。

**老师（ENTP）**：因此，AVL树适合用于查找频繁且插入删除较少的场景，比如数据库索引。而红黑树在插入和删除操作频繁的场合可能更具优势，比如在STL的map和set实现中。

**老师（ENTP）**：太好了，既然你对AVL树在实际应用中的实现细节感兴趣，我们就继续探讨一下它在数据库索引中的具体应用。

AVL树在数据库索引中的应用

在数据库中，索引是一种用于快速查找记录的数据结构。AVL树可以作为一种索引结构，帮助提高查询效率。我们来看看它在数据库中的典型应用。

1. **快速查找**

**老师（ENTP）**：AVL树的平衡性使得查找操作非常高效，时间复杂度为O(log n)。在数据库索引中，AVL树可以用来组织记录的主键或唯一键，使得通过键值来查找记录变得快速。

**学生（ESFP）**：这是不是意味着当有大量数据时，AVL树能保证查找时间不会因为数据量增加而显著变长？

**老师（ENTP）**：正是如此。无论数据量多大，AVL树的深度始终保持在O(log n)，确保查找操作的效率。

2. **有序数据存储**

**老师（ENTP）**：由于AVL树也是一种二叉查找树，它天然支持有序数据的存储和遍历。这对于需要按顺序检索数据的查询非常有用，比如范围查询。

**学生（ESFP）**：这就是说，如果我想找出数据库中某个范围内的所有记录，AVL树可以帮助快速定位？

**老师（ENTP）**：没错，AVL树支持中序遍历（In-order Traversal），可以方便地获取有序数据。

3. **增删操作的平衡**

**老师（ENTP）**：虽然AVL树的插入和删除操作较红黑树而言稍显复杂，但它的严格平衡特性使得它在某些需要高效查找的场合更具优势。

4. **实际应用中的考虑**

**老师（ENTP）**：在实际数据库系统中，除了AVL树，还有其他索引结构如B树（B-Tree）和B+树（B+ Tree）等。AVL树适合用于内存中的索引，因为它的旋转和调整操作在内存中更为高效。

AVL树与其他索引结构的比较

**学生（ESFP）**：那AVL树和B树、B+树相比有什么特点呢？

**老师（ENTP）**：这是个好问题！简要来说：

  • **AVL树**：高度平衡，适合内存索引，查找快。

  • **B树**：用于磁盘存储的多路自平衡树，节点包含多个元素，减少磁盘I/O次数。

  • **B+树**：B树的变种，所有数据都存储在叶子节点，叶子节点链接，范围查询更高效。

思维导图总结

```

AVL树在数据库中的应用

├── 快速查找

│ └── 时间复杂度O(log n)

├── 有序数据存储

│ └── 支持范围查询

├── 增删操作

│ └── 平衡调整

└── 与其他索引结构比较

├── AVL树：高效查找

├── B树：适合磁盘存储

└── B+树：高效范围查询

```

```

AVL树

├── 节点结构

│ ├── 左右子树指针

│ ├── 父节点指针

│ ├── 平衡因子

│ └── 键值对

├── 操作流程

│ ├── 插入

│ │ ├── 标准BST插入

│ │ ├── 更新平衡因子

│ │ └── 检查并旋转

│ └── 删除（类似）

├── 优缺点

│ ├── 优点：查找快

│ └── 缺点：插入删除旋转多

└── 应用场景

├── 数据库索引

└── 文件系统索引

```

```

AVL树

├── 特性

│ ├── 平衡性

│ └── 二叉查找树性质

├── 旋转操作

│ ├── LL旋转

│ ├── LR旋转

│ ├── RR旋转

│ └── RL旋转

├── 应用

│ ├── 数据库索引

│ └── 文件系统索引

└── 实现结构

└── 三叉链表

├── 左子树指针

├── 右子树指针

├── 父节点指针

└── 平衡因子

```我们全面理解了AVL树的基本概念、特性和操作。希望这种讨论形式帮助你更好地掌握AVL树的知识！

我们来看看在一个更大的树结构中，右旋操作是如何帮助恢复平衡的。

大树结构中的旋转示意

初始状态

考虑以下不平衡的AVL树，其中每个节点的左子树比右子树高，导致不平衡：

```

30

/

20

/

10

```

在这个树中，节点`30`的左子树高度是2，而右子树高度是0，所以平衡因子是2，超过了AVL树允许的范围。

右旋操作

我们对节点`30`进行右旋，以恢复树的平衡。右旋的步骤如下：

  1. **选择旋转节点**：节点`30`是失去平衡的节点。

  2. **执行右旋**：

  • 将`20`提升为新的根节点。

  • 将`30`移动为`20`的右子节点。

  • 保持`10`为`20`的左子节点。

旋转后的树结构变为：

```

20

/ \

10 30

```

旋转效果

  1. **恢复平衡**：现在每个节点的平衡因子都在-1到1之间。

  • 节点`20`的平衡因子是0（左、右子树高度均为1）。

  • 节点`10`和`30`的平衡因子都是0（没有子节点）。

  1. **提高效率**：通过保持树的平衡性，确保查找、插入和删除操作的时间复杂度保持在O(log n)。

更大树结构中的应用

在实际应用中，树的规模可能更大，旋转操作可能需要在多个层级上进行。以下是一个更复杂的例子：

初始不平衡树

```

40

/

30

/

20

/

10

```

在这种情况下，AVL树的多个节点可能失去平衡。我们可以从最下层开始进行旋转：

  1. **对`30`进行右旋**：

```

30

/ \

20 40

/

10

```

  1. **对`40`进行右旋**，如果必要的话，继续调整：

```

30

/ \

20 40

/

10

```

通过一系列旋转操作，树恢复了平衡，每个节点的平衡因子都在-1到1之间。

总结

旋转操作在AVL树中是保持平衡的关键，它通过局部调整节点位置来确保整个树的高度尽可能小。这在大规模数据集中的应用尤为重要，提升了数据操作的效率。无论树的规模多大，旋转都能迅速修正不平衡，使得AVL树始终保持高效的性能表现。

这里是AVL树旋转中的高度更新和相关的先修知识的详细解释和示例：

先修知识

  1. **二叉树**：
  • 每个节点最多有两个子节点，称为左子节点和右子节点。
  1. **平衡因子**：

  • 平衡因子是节点左子树高度减去右子树高度的差。

  • 在AVL树中，每个节点的平衡因子必须是-1、0或1。

  1. **节点高度**：

  • 节点的高度是从该节点到叶节点的最长路径上的边数。

  • 叶节点的高度为0。

  1. **AVL树**：
  • 一种自平衡的二叉搜索树，确保每个节点的平衡因子在-1到1之间。

右旋操作示例

初始状态

考虑以下不平衡的子树：

```

y

/

x

\

T2

```

  • `y` 的高度 = 2

  • `x` 的高度 = 1

  • `T2` 的高度 = 0

旋转步骤

  1. **选定旋转节点**：

  • `x = y.left`：`x` 是 `y` 的左子节点。

  • `T2 = x.right`：`T2` 是 `x` 的右子树。

  1. **旋转操作**：

```python

def right_rotate(y):

x = y.left # x 是 y 的左子节点

T2 = x.right # T2 是 x 的右子树

进行旋转

x.right = y # 将 y 旋转到 x 的右子节点

y.left = T2 # 将 T2 挂接到 y 的左子树

更新高度

y.height = 1 + max(get_height(y.left), get_height(y.right))

x.height = 1 + max(get_height(x.left), get_height(x.right))

return x # 返回新的子树根节点

```

  1. **更新高度**：

  • `y` 的新高度 = 1 + max(高度(`T2`), 0) = 1 + max(0, 0) = 1

  • `x` 的新高度 = 1 + max(高度(无), `y` 的高度) = 1 + max(-1, 1) = 2

结果状态

旋转后的子树：

```

x

\

y

/

T2

```

  • `x` 的高度 = 2

  • `y` 的高度 = 1

  • `T2` 的高度 = 0

代码注释和解释

```python

class TreeNode:

def init(self, value):

self.value = value

self.left = None

self.right = None

self.height = 1 # 初始节点高度为1

def get_height(node):

if not node:

return -1 # 空节点的高度为-1

return node.height

def right_rotate(y):

x = y.left # x 为 y 的左子节点

T2 = x.right # T2 为 x 的右子树

执行旋转

x.right = y # 将 y 变为 x 的右子节点

y.left = T2 # 将 T2 连接到 y 的左子树

更新 y 和 x 的高度

y.height = 1 + max(get_height(y.left), get_height(y.right))

x.height = 1 + max(get_height(x.left), get_height(x.right))

return x # 返回新的根节点 x

```

结论

通过右旋操作，AVL树的高度和结构得到了调整，从而保持了树的平衡性。旋转后，树的高度变化反映了平衡因子的调整，确保操作效率。这个过程对于维护AVL树的高效查找、插入和删除操作是必要的。

【代码示范】

好的，我们可以通过一个具体的例子来演示AVL树的插入操作，包括数值代入、旋转调整，并展示每一步的程序结果及相关注释。我们将用C++实现一个简单的AVL树插入操作，并以插入几个整数为例。

示例：插入操作

假设我们要在一个空的AVL树中依次插入以下数值：20, 10, 30, 5, 3。我们将演示这些插入操作以及进行的旋转调整。

1. 插入20

  • **操作**：插入20

  • **结果**：树中只有一个节点20，不需要旋转。

```cpp

// 插入20

AVLNode<int, int>* root = new AVLNode<int, int>({20, 0});

// 树结构：

// 20

```

2. 插入10

  • **操作**：插入10，作为20的左子节点

  • **结果**：平衡因子在[-1, 1]之间，无需旋转。

```cpp

// 插入10

root->_left = new AVLNode<int, int>({10, 0});

root->_left->_parent = root;

// 更新平衡因子

root->_bf = 1;

// 树结构：

// 20

// /

// 10

```

3. 插入30

  • **操作**：插入30，作为20的右子节点

  • **结果**：平衡因子在[-1, 1]之间，无需旋转。

```cpp

// 插入30

root->_right = new AVLNode<int, int>({30, 0});

root->_right->_parent = root;

// 更新平衡因子

root->_bf = 0;

// 树结构：

// 20

// / \

// 10 30

```

4. 插入5

  • **操作**：插入5，作为10的左子节点

  • **结果**：平衡因子在[-1, 1]之间，无需旋转。

```cpp

// 插入5

root->_left->_left = new AVLNode<int, int>({5, 0});

root->_left->_left->_parent = root->_left;

// 更新平衡因子

root->_left->_bf = 1;

root->_bf = 1;

// 树结构：

// 20

// / \

// 10 30

// /

// 5

```

5. 插入3（触发旋转）

  • **操作**：插入3，作为5的左子节点

  • **结果**：插入后10节点的平衡因子为2，需要进行右旋。

```cpp

// 插入3

root->_left->_left->_left = new AVLNode<int, int>({3, 0});

root->_left->_left->_left->_parent = root->_left->_left;

// 更新平衡因子

root->_left->_left->_bf = 1;

root->_left->_bf = 2;

root->_bf = 2;

// 进行右旋以恢复平衡

// 右旋前：

// 20

// / \

// 10 30

// /

// 5

// /

//3

// 右旋操作

AVLNode<int, int>* leftChild = root->_left;

root->_left = leftChild->_right;

if (leftChild->_right) {

leftChild->_right->_parent = root;

}

leftChild->_right = root;

leftChild->_parent = root->_parent;

root->_parent = leftChild;

root = leftChild; // 更新根节点指向

// 更新平衡因子

root->_bf = 0;

root->_right->_bf = 0;

// 右旋后：

// 10

// / \

// 5 20

// / \

//3 30

```

总结

每次插入后，我们检查并更新节点的平衡因子，然后在需要时进行旋转调整以保持AVL树的平衡。通过这种方式，AVL树可以保证所有查找、插入和删除操作的时间复杂度都为O(log n)。这种逐步的插入和调整机制使得AVL树在需要频繁查找的应用场合非常高效。

相关推荐
搬砖的小码农_Sky4 小时前
C语言：数组
c语言·数据结构
先鱼鲨生6 小时前
数据结构——栈、队列
数据结构
一念之坤6 小时前
零基础学Python之数据结构 -- 01篇
数据结构·python
IT 青年6 小时前
数据结构 （1）基本概念和术语
数据结构·算法
熬夜学编程的小王6 小时前
【初阶数据结构篇】双向链表的实现（赋源码）
数据结构·c++·链表·双向链表
liujjjiyun7 小时前
小R的随机播放顺序
数据结构·c++·算法
Reese_Cool9 小时前
【数据结构与算法】排序
java·c语言·开发语言·数据结构·c++·算法·排序算法
djk88889 小时前
.net将List＜实体1＞的数据转到List＜实体2＞
数据结构·list·.net
搬砖的小码农_Sky10 小时前
C语言：结构体
c语言·数据结构
_OLi_11 小时前
力扣 LeetCode 106. 从中序与后序遍历序列构造二叉树（Day9：二叉树）
数据结构·算法·leetcode
热门推荐
01(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明02PyTorch机器学习实现液态神经网络03【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总04玄机平台应急响应—webshell查杀05Coze扣子平台完整体验和实践（附国内和国际版对比）06Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO07【目标跟踪】相机运动补偿08Unity中PICO实现 隔空取物 和 接触抓取物体09RAG 实践- Ollama+RagFlow 部署本地知识库10怎样让音频速度变慢？请跟随以下方法进行操作