文章目录
在本教程中,您将学习什么是avl树。此外,您还将找到在C上执行AVL树的示例。
AVL树是一种自平衡二叉搜索树,其中每个节点维护称为平衡因子的额外信息,其值为-1、0或+1。
AVL树以其发明者Georgy Adelson-Velsky和Landis得名。
1. 平衡因子
AVL树中节点的平衡因子是该节点左子树和右子树的高度之差。
平衡因子=(左子树的高度-右子树的高度)或(右子树的高度-左子树的高度)
avl树的自平衡特性由平衡因子来维持。平衡因子的值应始终为-1、0或+1。
平衡avl树的示例如下:
2. AVL树的操作
可以在AVL树上执行的操作是:
2.1 旋转AVL树中的子树
在旋转操作中,子树节点的位置是互换的。
旋转有两种类型:
2.1.1 左旋转
在左旋转中,右侧节点的排列转换为左侧节点的排列。
- 初始树为:
- 如果y有左子树,则指定x作为y的左子树的父级。
- 如果x的父级为空,则将y作为树的根。
- 否则,如果x是p的左子级,则将y作为p的左子级。
- 否则指定y作为p的右子级。
- 使y成为x的父级。
2.1.2 右旋转
在右旋转中,左侧节点的排列转换为右侧节点的排列。
- 初始树为:
- 如果x有一个右子树,则指定y作为x的右子树的父树。
- 如果y的父级为空,则将x作为树的根。
- 否则,如果y是其父p的右子级,则使x成为p的右子级。
- 否则指定x作为p的左子级。
- 使x成为y的父级。
2.1.3 左右和右左旋转
在左右旋转中,排列首先向左移动,然后向右移动。
- 在X-Y上做左旋转
- 在Y-Z上做右旋转。
在右左旋转中,排列首先向右移动,然后向左移动。
- 在X-Y上进行右旋转。
- 在Z-Y上做左旋转。
2.2 插入新节点的算法
新节点(newNode)始终作为平衡因子为0的叶节点插入。
- 初始树为:
要插入的节点为:
- 使用以下递归步骤转到相应的叶节点以插入新节点(newNode)。将newKey与当前树的rootKey进行比较。
a. 如果newKey<rootKey,则在当前节点的左子树上调用插入算法,直到到达叶节点为止。
b. 否则,如果newKey>rootKey,则在当前节点的右子树上调用插入算法,直到到达叶节点为止。
c. 否则,返回leafNode。
- 将从上述步骤获得的leafKey与newKey进行比较:
a. 如果newKey<leafKey,则将newNode设为leafNode的左孩子。
b. 否则,将newNode设为leafNode的右孩子。
- 更新节点的平衡因子。
- 如果节点不平衡,则重新平衡节点。
a. 如果平衡因子大于1,则表示左子树的高度大于右子树的高度。所以,做一个右旋转或左右旋转
a. 如果newNodeKey<leftChildKey执行右旋转
b. 否则,执行左右旋转
b. 如果平衡因子<-1,则表示右子树的高度大于左子树的高度。所以,做右旋转或左右旋转。
a. 如果newNodeKey>rightChildKey,执行左旋转。
b. 否则,执行右左旋转。 - 最终树为:
2.3 删除节点的算法
节点始终作为叶节点删除。删除节点后,节点的平衡因子会发生变化。为了重新平衡平衡因子,需要进行适当的旋转。
- 查找待删除的节点(递归用于在下面使用的代码中查找待删除的节点)。
- 删除节点有以下三种情况:
a. 如果待删除节点是叶节点(即没有任何子节点),则直接删除。
b. 如果待删除节点有一个子级,则用子级的内容替换待删除节点的内容,然后移除子级。
c. 如果待删除节点有两个子节点,则查找待删除节点的顺序继承节点w(即右子树中key值最小的节点)。
a. 将待删除节点的内容替换为w的内容
b. 移除叶节点w。
- 更新节点的平衡因子。
- 如果任何节点的平衡因子不等于-1、0或1,则重新平衡树。
a. 如果当前节点的平衡因子大于1,
a. 如果左孩子的平衡因子 >= 0,执行右旋转。
b. 否则执行左右旋转。
b. 如果当前节点的平衡因子小于 -1,
a. 如果右孩子的平衡因子 <= 0,执行左旋转。
b. 否则执行右左旋转。 - 最终树为:
3. C示例
// AVL tree implementation in C
#include <stdio.h>
#include <stdlib.h>
// Create Node
struct Node {
int key;
struct Node *left;
struct Node *right;
int height;
};
int max(int a, int b);
// Calculate height
int height(struct Node *N) {
if (N == NULL)
return 0;
return N->height;
}
int max(int a, int b) {
return (a > b) ? a : b;
}
// Create a node
struct Node *newNode(int key) {
struct Node *node = (struct Node *)
malloc(sizeof(struct Node));
node->key = key;
node->left = NULL;
node->right = NULL;
node->height = 1;
return (node);
}
// Right rotate
struct Node *rightRotate(struct Node *y) {
struct Node *x = y->left;
struct Node *T2 = x->right;
x->right = y;
y->left = T2;
y->height = max(height(y->left), height(y->right)) + 1;
x->height = max(height(x->left), height(x->right)) + 1;
return x;
}
// Left rotate
struct Node *leftRotate(struct Node *x) {
struct Node *y = x->right;
struct Node *T2 = y->left;
y->left = x;
x->right = T2;
x->height = max(height(x->left), height(x->right)) + 1;
y->height = max(height(y->left), height(y->right)) + 1;
return y;
}
// Get the balance factor
int getBalance(struct Node *N) {
if (N == NULL)
return 0;
return height(N->left) - height(N->right);
}
// Insert node
struct Node *insertNode(struct Node *node, int key) {
// Find the correct position to insertNode the node and insertNode it
if (node == NULL)
return (newNode(key));
if (key < node->key)
node->left = insertNode(node->left, key);
else if (key > node->key)
node->right = insertNode(node->right, key);
else
return node;
// Update the balance factor of each node and
// Balance the tree
node->height = 1 + max(height(node->left),
height(node->right));
int balance = getBalance(node);
if (balance > 1 && key < node->left->key)
return rightRotate(node);
if (balance < -1 && key > node->right->key)
return leftRotate(node);
if (balance > 1 && key > node->left->key) {
node->left = leftRotate(node->left);
return rightRotate(node);
}
if (balance < -1 && key < node->right->key) {
node->right = rightRotate(node->right);
return leftRotate(node);
}
return node;
}
struct Node *minValueNode(struct Node *node) {
struct Node *current = node;
while (current->left != NULL)
current = current->left;
return current;
}
// Delete a nodes
struct Node *deleteNode(struct Node *root, int key) {
// Find the node and delete it
if (root == NULL)
return root;
if (key < root->key)
root->left = deleteNode(root->left, key);
else if (key > root->key)
root->right = deleteNode(root->right, key);
else {
if ((root->left == NULL) || (root->right == NULL)) {
struct Node *temp = root->left ? root->left : root->right;
if (temp == NULL) {
temp = root;
root = NULL;
} else
*root = *temp;
free(temp);
} else {
struct Node *temp = minValueNode(root->right);
root->key = temp->key;
root->right = deleteNode(root->right, temp->key);
}
}
if (root == NULL)
return root;
// Update the balance factor of each node and
// balance the tree
root->height = 1 + max(height(root->left),
height(root->right));
int balance = getBalance(root);
if (balance > 1 && getBalance(root->left) >= 0)
return rightRotate(root);
if (balance > 1 && getBalance(root->left) < 0) {
root->left = leftRotate(root->left);
return rightRotate(root);
}
if (balance < -1 && getBalance(root->right) <= 0)
return leftRotate(root);
if (balance < -1 && getBalance(root->right) > 0) {
root->right = rightRotate(root->right);
return leftRotate(root);
}
return root;
}
// Print the tree
void printPreOrder(struct Node *root) {
if (root != NULL) {
printf("%d ", root->key);
printPreOrder(root->left);
printPreOrder(root->right);
}
}
int main() {
struct Node *root = NULL;
root = insertNode(root, 2);
root = insertNode(root, 1);
root = insertNode(root, 7);
root = insertNode(root, 4);
root = insertNode(root, 5);
root = insertNode(root, 3);
root = insertNode(root, 8);
printPreOrder(root);
root = deleteNode(root, 3);
printf("\nAfter deletion: ");
printPreOrder(root);
return 0;
}
4. AVL树上不同操作的复杂性
插入 | 删除 | 查找 |
---|---|---|
O(log n) | O(log n) | O(log n) |
5. AVL树应用
- 在数据库中对大记录进行索引
- 用于在大型数据库中搜索
参考文档
[1]Parewa Labs Pvt. Ltd.Balanced Binary Tree[EB/OL].https://www.programiz.com/dsa/avl-tree,2020-01-01.