AVL树
AVL树是根据它的发明者G.M. Adelson-Velsky和E.M. Landis命名的。
它是最先发明的自平衡二叉查找树（Self-balancing binary search tree），也被称为高度平衡树。
相比于”二叉查找树”，它的特点是：AVL树中任何节点的两个子树的高度最大差别为1。
例子
AVL 平衡树
[plaintext]
1
2
3 5
2 7
1 3 6 9
不平衡的树：
[plaintext]
1
2
3
4
5
6
71
2
3
4
5
6
7
平衡因子
某结点的左子树与右子树的高度(深度)差即为该结点的平衡因子（BF,Balance Factor）。
平衡二叉树上所有结点的平衡因子只可能是 -1，0 或 1。
如果某一结点的平衡因子绝对值大于1则说明此树不是平衡二叉树。
为了方便计算每一结点的平衡因子我们可以为每个节点赋予height这一属性，表示此节点的高度。
实现
节点定义
[java]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38/**
* 内部节点
*
* @param <V> 泛型
* @since 0.0.5
*/
private static class Node<V> {
/**
* 左节点
*
* @since 0.0.5
*/
private Node<V> left;
/**
* 右节点
*
* @since 0.0.5
*/
private Node<V> right;
/**
* 数据信息
*
* @since 0.0.5
*/
private V data;
/**
* 当前元素所在的高度
*
* @since 0.0.5
*/
private int height;
public Node(V data) {
this.data = data;
this.left = null;
this.right = null;
this.height = 1;
}
}
经过老马的实战，感觉还是定义为内部类实现起来更加自然。
如果通过外部的 getter/setter 操作属性，代码会变得不那么直观。
类定义
这个和 BST 一样，我们继承自 ISortTree 接口。
所有的元素必须是 Comparable 的子类。
[java]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34/**
* avl 平衡树
*
* @author 老马啸西风
* @since 0.0.5
*/
public class AvlTree<V extends Comparable<? super V>> implements ISortTree<V> {
/**
* 根节点
*
* @since 0.0.5
*/
private Node<V> root;
/**
* 整棵树的大小
*
* @since 0.0.5
*/
private int size;
/**
* 构造器
* <p>
* 初始化一颗空树
*
* @since 0.0.5
*/
public AvlTree() {
this.root = null;
this.size = 0;
}
}
是否平衡
直接根据左右节点的高度计差值即可，这里新增了一个高度的概念，让实现变得非常简单。
[java]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41/**
* 获取节点的平衡因子
* @param node
* @return
*/
private int getBalanceFactor(Node node){
if(node==null){
return 0;
}
return getHeight(node.left)-getHeight(node.right);
}
//判断树是否为平衡二叉树
public boolean isBalanced(){
return isBalanced(root);
}
private boolean isBalanced(Node node){
if(node==null){
return true;
}
int balanceFactory = Math.abs(getBalanceFactor(node));
if(balanceFactory>1){
return false;
}
return isBalanced(node.left)&&isBalanced(node.right);
}
/**
* 获取当前节点的高度
*
* @param node 节点
* @return 高度
* @since 0.0.5
*/
private int getHeight(Node<V> node) {
if (node == null) {
return 0;
}
return node.height;
}
添加节点
往平衡二叉树中添加节点很可能会导致二叉树失去平衡，所以我们需要在每次插入节点后进行平衡的维护操作。
记住：我们所做的一切都是为了维持树的平衡。
理解了下面的 4 个场景，也就理解了 AVL 树。
插入节点破坏平衡性有如下四种情况：
LL（右旋）
LL的意思是向左子树（L）的左孩子（L）中插入新节点后导致不平衡，这种情况下需要右旋操作，而不是说LL的意思是右旋，后面的也是一样。
我们将这种情况抽象出来，得到下图：
代码实现如下:
[java]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20/**
* 右旋
*
* @since 0.0.5
*/
private Node<V> rightRotate(Node<V> y) {
Node<V> x = y.left;
Node<V> t3 = x.right;
x.right = y;
y.left = t3;
//更新height
y.height = Math.max(getHeight(y.left), getHeight(y.right)) + 1;
x.height = Math.max(getHeight(x.left), getHeight(x.right)) + 1;
// 更新根节点
if(y == root) {
this.root = x;
}
return x;
}
ps: 经过老马自测，更新根节点是必须的，否则会导致后续遍历 root 节点错乱。
RR（左旋）
这个和 LL 类似，只不过方向相反。
我们将这种情况抽象出来，得到下图：
代码实现如下：
[java]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20/**
* 左旋
*
* @since 0.0.5
*/
private Node<V> leftRotate(Node<V> y) {
Node<V> x = y.right;
Node<V> t3 = x.left;
x.left = y;
y.right = t3;
//更新height
y.height = Math.max(getHeight(y.left), getHeight(y.right)) + 1;
x.height = Math.max(getHeight(x.left), getHeight(x.right)) + 1;
// 更新根节点
if(y == root) {
this.root = x;
}
return x;
}
LR
场景如下：
我们将这种情况抽象出来，得到下图：
RL
场景如下：
我们将这种情况抽象出来，得到下图：
完整的添加实现
各位小伙伴，可以将下面的代码对照上面的四种场景进行理解。
[java]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47@Override
public void add(V data) {
this.root = add(root, data);
}
/**
* 插入元素
*
* @param node 节点
* @param v 待插入元素
* @return 结果
* @since 0.0.5
*/
private Node<V> add(Node<V> node, V v) {
if (node == null) {
size++;
return new Node<>(v);
}
if (v.compareTo(node.data) < 0) {
node.left = add(node.left, v);
} else if (v.compareTo(node.data) > 0) {
node.right = add(node.right, v);
}
//更新height
node.height = 1 + Math.max(getHeight(node.left), getHeight(node.right));
//计算平衡因子
int balanceFactor = getBalanceFactor(node);
if (balanceFactor > 1 && getBalanceFactor(node.left) > 0) {
//右旋LL
return rightRotate(node);
}
if (balanceFactor < -1 && getBalanceFactor(node.right) < 0) {
//左旋RR
return leftRotate(node);
}
//LR
if (balanceFactor > 1 && getBalanceFactor(node.left) < 0) {
node.left = leftRotate(node.left);
return rightRotate(node);
}
//RL
if (balanceFactor < -1 && getBalanceFactor(node.right) > 0) {
node.right = rightRotate(node.right);
return leftRotate(node);
}
return node;
}
删除操作
在删除AVL树节点前需要知道二分搜索树的节点删除操作，和二分搜索树删除节点不同的是我们删除AVL树的节点后需要进行平衡的维护操作。
[java]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115@Override
public boolean remove(V data) {
Node<V> node = getNode(root, data);
if (node != null) {
root = remove(root, data);
return true;
}
return false;
}
/**
* 返回以node为根节点的二分搜索树中，key所在的节点
*
* @param node 节点
* @param v 元素
* @return 结果
* @since 0.0.5
*/
private Node<V> getNode(Node<V> node, V v) {
if (node == null) {
return null;
}
if (v.equals(node.data)) {
return node;
} else if (v.compareTo(node.data) < 0) {
return getNode(node.left, v);
} else {
return getNode(node.right, v);
}
}
/**
* 返回以node为根的二分搜索树的最小值所在的节点
* <p>
* ps: 实际上就是最左子树
*
* @param node 节点
* @return 结果
* @since 0.0.5
*/
private Node<V> getMiniNode(Node<V> node) {
if (node.left == null) {
return node;
}
return getMiniNode(node.left);
}
/**
* 删除一个元素
*
* @param node 节点
* @param v 元素
* @return 结果
*/
private Node<V> remove(Node<V> node, V v) {
if (node == null) {
return null;
}
Node<V> retNode;
if (v.compareTo(node.data) < 0) {
node.left = remove(node.left, v);
retNode = node;
} else if (v.compareTo(node.data) > 0) {
node.right = remove(node.right, v);
retNode = node;
} else { // e.compareTo(node.e) == 0
// 待删除节点左子树为空的情况
if (node.left == null) {
Node<V> rightNode = node.right;
node.right = null;
size--;
retNode = rightNode;
}
// 待删除节点右子树为空的情况
else if (node.right == null) {
Node<V> leftNode = node.left;
node.left = null;
size--;
retNode = leftNode;
} else {
// 待删除节点左右子树均不为空的情况
// 找到比待删除节点大的最小节点, 即待删除节点右子树的最小节点
// 用这个节点顶替待删除节点的位置
Node<V> successor = getMiniNode(node.right);
successor.right = remove(node.right, successor.data);
successor.left = node.left;
node.left = node.right = null;
retNode = successor;
}
}
if (retNode == null) {
return null;
}
//维护平衡
//更新height
retNode.height = 1 + Math.max(getHeight(retNode.left), getHeight(retNode.right));
//计算平衡因子
int balanceFactor = getBalanceFactor(retNode);
if (balanceFactor > 1 && getBalanceFactor(retNode.left) >= 0) {
//右旋LL
return rightRotate(retNode);
}
if (balanceFactor < -1 && getBalanceFactor(retNode.right) <= 0) {
//左旋RR
return leftRotate(retNode);
}
//LR
if (balanceFactor > 1 && getBalanceFactor(retNode.left) < 0) {
node.left = leftRotate(retNode.left);
return rightRotate(retNode);
}
//RL
if (balanceFactor < -1 && getBalanceFactor(retNode.right) > 0) {
node.right = rightRotate(retNode.right);
return leftRotate(retNode);
}
return node;
}
测试
准备工作
为了便于大家直观的理解，我们在左旋/右旋执行前后，输出一下树的信息。
[java]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51/**
* 右旋
*
* @since 0.0.5
*/
private Node<V> rightRotate(Node<V> y) {
System.out.println("右旋执行前：");
print();
Node<V> x = y.left;
Node<V> t3 = x.right;
y.left = t3;
x.right = y;
//更新height
y.height = Math.max(getHeight(y.left), getHeight(y.right)) + 1;
x.height = Math.max(getHeight(x.left), getHeight(x.right)) + 1;
// 更新根节点
if(y == root) {
this.root = x;
}
System.out.println("右旋执行后：");
print();
return x;
}
/**
* 左旋
*
* @since 0.0.5
*/
private Node<V> leftRotate(Node<V> y) {
System.out.println("左旋执行前：");
print();
Node<V> x = y.right;
Node<V> t3 = x.left;
x.left = y;
y.right = t3;
//更新height
y.height = Math.max(getHeight(y.left), getHeight(y.right)) + 1;
x.height = Math.max(getHeight(x.left), getHeight(x.right)) + 1;
// 更新根节点
if(y == root) {
this.root = x;
}
System.out.println("左旋执行后：");
print();
return x;
}
测试
ll-右旋场景
[java]
1
2
3
4
5
6
7
8
9
10/**
* ll-右旋测试
*/
@Test
public void llTest() {
AvlTree<Integer> avlTree = new AvlTree<>();
avlTree.add(3);
avlTree.add(2);
avlTree.add(1);
}
日志如下：
[plaintext]
1
2
3
4
5
6
7右旋执行前：
3
2
1
右旋执行后：
2
1 3
rr-左旋测试
[java]
1
2
3
4
5
6
7
8
9
10/**
* rr-左旋测试
*/
@Test
public void rrTest() {
AvlTree<Integer> avlTree = new AvlTree<>();
avlTree.add(1);
avlTree.add(2);
avlTree.add(3);
}
日志如下：
[plaintext]
1
2
3
4
5
6
7左旋执行前：
1
2
3
左旋执行后：
2
1 3
LR-左旋右旋测试
[java]
1
2
3
4
5
6
7
8
9
10/**
* lr-左旋+右旋测试
*/
@Test
public void lrTest() {
AvlTree<Integer> avlTree = new AvlTree<>();
avlTree.add(3);
avlTree.add(1);
avlTree.add(2);
}
日志如下：
[plaintext]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15左旋执行前：
3
1
2
左旋执行后：
3
1
2
右旋执行前：
3
2
1
右旋执行后：
2
1 3
可以看到这里首先执行了左旋，让其编程 ll 的形式。
RL-右旋左旋测试
[java]
1
2
3
4
5
6
7
8
9
10/**
* rl-右旋+左旋测试
*/
@Test
public void rlTest() {
AvlTree<Integer> avlTree = new AvlTree<>();
avlTree.add(1);
avlTree.add(3);
avlTree.add(2);
}
日志如下：
[plaintext]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15右旋执行前：
1
3
2
右旋执行后：
1
3
2
左旋执行前：
1
2
3
左旋执行后：
2
1 3
首先执行右旋变成 rr，然后执行左旋。
小结
希望本文对你有帮助，如果有其他想法的话，也可以评论区和大家分享哦。
各位极客的点赞收藏转发，是老马持续写作的最大动力！
当然实现平衡树的方法有很多种，下一节我们一起学习一下大名鼎鼎的红黑树。
