Java数据结构与算法解析——AVL树
Posted 4K_WarCraft
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Java数据结构与算法解析——AVL树相关的知识，希望对你有一定的参考价值。
之前我们说过普通二叉查找树的删除算法会使得左子树比右子树深，因为我们总是用右子树的一个来代替删除的节点。会造成二叉查找树，严重的不平衡。
AVL树简介
而AVL树就是解决普通二叉查找树弊端的方法，他是带有平衡条件的二叉查找树，这个平衡条件必须容易保持，而且它保证树的深度必须是O(logN).
AVL树是高度平衡的而二叉树。它的特点是：AVL树中任何节点的两个子树的高度最大差别为1。
上面的两张图片，左边的是AVL树，它的任何节点的两个子树的高度差别都<=1；而右边的不是AVL树，因为7的两颗子树的高度相差为2(以2为根节点的树的高度是3，而以8为根节点的树的高度是1)。
AVL树的实现
1.节点
class AVLTreeNode<T extends Comparable<T>>
T element;
int height;
AVLTreeNode<T> left;
AVLTreeNode<T> right;
public AVLTreeNode(T key, AVLTreeNode<T> left, AVLTreeNode<T> right)
this.element = key;
this.left = left;
this.right = right;
this.height = 0;
AVLTree是AVL树对应的类，而AVLTreeNode是AVL树节点，它是AVLTree的内部类。AVLTree包含了AVL树的根节点，AVL树的基本操作也定义在AVL树中。AVLTreeNode包括的几个组成对象:
(1) key – 是关键字，是用来对AVL树的节点进行排序的。
(2) left – 是左孩子。
(3) right – 是右孩子。
(4) height – 是高度。
2.树的高度
private int height(AVLTreeNode<T> tree)
if (tree != null)
return tree.height;
return 0;
public int height()
return height(mRoot);
有的地方将”空二叉树的高度是-1”，这里我们采用另一种定义：树的高度为最大层次。即空的二叉树的高度是0，非空树的高度等于它的最大层次(根的层次为1，根的子节点为第2层，依次类推)。
3.旋转
如果在AVL树中进行插入或删除节点后，可能导致AVL树失去平衡。这种失去平衡的可以概括为4种姿态：LL(左左)，LR(左右)，RR(右右)和RL(右左)。
上图中的4棵树都是”失去平衡的AVL树”，从左往右的情况依次是：LL、LR、RL、RR。除了上面的情况之外，还有其它的失去平衡的AVL树，如下图：
(1) LL：LeftLeft，也称为”左左”。插入或删除一个节点后，根节点的左子树的左子树还有非空子节点，导致”根的左子树的高度”比”根的右子树的高度”大2，导致AVL树失去了平衡。
例如，在上面LL情况中，由于”根节点(8)的左子树(4)的左子树(2)还有非空子节点”，而”根节点(8)的右子树(12)没有子节点”；导致”根节点(8)的左子树(4)高度”比”根节点(8)的右子树(12)”高2。
(2) LR：LeftRight，也称为”左右”。插入或删除一个节点后，根节点的左子树的右子树还有非空子节点，导致”根的左子树的高度”比”根的右子树的高度”大2，导致AVL树失去了平衡。
例如，在上面LR情况中，由于”根节点(8)的左子树(4)的左子树(6)还有非空子节点”，而”根节点(8)的右子树(12)没有子节点”；导致”根节点(8)的左子树(4)高度”比”根节点(8)的右子树(12)”高2。
(3) RL：RightLeft，称为”右左”。插入或删除一个节点后，根节点的右子树的左子树还有非空子节点，导致”根的右子树的高度”比”根的左子树的高度”大2，导致AVL树失去了平衡。
例如，在上面RL情况中，由于”根节点(8)的右子树(12)的左子树(10)还有非空子节点”，而”根节点(8)的左子树(4)没有子节点”；导致”根节点(8)的右子树(12)高度”比”根节点(8)的左子树(4)”高2。
(4) RR：RightRight，称为”右右”。插入或删除一个节点后，根节点的右子树的右子树还有非空子节点，导致”根的右子树的高度”比”根的左子树的高度”大2，导致AVL树失去了平衡。
例如，在上面RR情况中，由于”根节点(8)的右子树(12)的右子树(14)还有非空子节点”，而”根节点(8)的左子树(4)没有子节点”；导致”根节点(8)的右子树(12)高度”比”根节点(8)的左子树(4)”高2。
如果在AVL树中进行插入或删除节点后，可能导致AVL树失去平衡。AVL失去平衡之后，可以通过旋转使其恢复平衡，下面分别介绍”LL(左左)，LR(左右)，RR(右右)和RL(右左)”这4种情况对应的旋转方法。
LL的旋转
LL失去平衡的情况，可以通过一次旋转让AVL树恢复平衡。如下图：
图中左边是旋转之前的树，右边是旋转之后的树。从中可以发现，旋转之后的树又变成了AVL树，而且该旋转只需要一次即可完成。
对于LL旋转，你可以这样理解为：LL旋转是围绕”失去平衡的AVL根节点”进行的，也就是节点k2；而且由于是LL情况，即左左情况，就用手抓着”左孩子，即k1”使劲摇。将k1变成根节点，k2变成k1的右子树，”k1的右子树”变成”k2的左子树”。
LL的旋转代码
/**
* LL：左左对应的情况(左单旋转)。
* @param k2
* @return 旋转后的根节点
*/
private AVLTreeNode<T> leftLeftRotation(AVLTreeNode<T> k2)
AVLTreeNode<T> k1;
k1 = k2.left;
k2.left = k1.right;
k1.right = k2;
k2.height = Math.max(height(k2.left), height(k2.right)) + 1;
k1.height = Math.max(height(k1.left), k2.height) + 1;
return k1;
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
RR的旋转
理解了LL之后，RR就相当容易理解了。RR是与LL对称的情况！RR恢复平衡的旋转方法如下：
图中左边是旋转之前的树，右边是旋转之后的树。RR旋转也只需要一次即可完成。
private AVLTreeNode<T> rightRightRotation(AVLTreeNode<T> k1)
AVLTreeNode<T> k2
k2 = k1.right
k1.right = k2.left
k2.left = k1
k1.height = Math.max(height(k1.left), height(k1.right)) + 1
k2.height = Math.max(height(k2.right), k1.height) + 1
return k2
LR的旋转
LR失去平衡的情况，需要经过两次旋转才能让AVL树恢复平衡。
第一次旋转是围绕”k1”进行的”RR旋转”，第二次是围绕”k3”进行的”LL旋转”。
LR的旋转代码
/**
* LR：左右对应的情况(左双旋转)。
* @param k3
* @return 旋转后的根节点
*/
private AVLTreeNode<T> leftRightRotation(AVLTreeNode<T> k3)
k3.left = rightRightRotation(k3.left);
return leftLeftRotation(k3);
RL的旋转
RL是与LR的对称情况！RL恢复平衡的旋转方法如下：
第一次旋转是围绕”k3”进行的”LL旋转”，第二次是围绕”k1”进行的”RR旋转”。
RL的旋转代码
/**
* RL：右左对应的情况(右双旋转)。
* @param k1
* @return 旋转后的根节点
*/
private AVLTreeNode<T> rightLeftRotation(AVLTreeNode<T> k1)
k1.right = leftLeftRotation(k1.right);
return rightRightRotation(k1);
4.插入
public void insert(T key)
mRoot = insert(mRoot, key);
/**
* 将结点插入到AVL树中，并返回根节点
*
* @param tree AVL树的根结点
* @param key 插入的结点的键值
* @return 根节点
*/
private AVLTreeNode<T> insert(AVLTreeNode<T> tree, T key)
if (tree == null)
return tree = new AVLTreeNode<T>(key, null, null);
int cmp = key.compareTo(tree.element);
if (cmp < 0)
tree.left = insert(tree.left, key);
else if (cmp > 0)
tree.right = insert(tree.right, key);
return balance(tree);
- 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
插入节点后，可能会使AVL树失去平衡，通过balance()方法进行相应的调节。
private static final int ALLOWED_IMBALANCE = 1;
private AVLTreeNode<T> balance(AVLTreeNode<T> tree)
if (tree == null)
return tree;
if (height(tree.left) - height(tree.right) > ALLOWED_IMBALANCE)
if (height(tree.left.left) >= height(tree.left.right))
leftLeftRotation(tree);
else
leftRightRotation(tree);
else if (height(tree.right) - height(tree.left) > ALLOWED_IMBALANCE)
if (height(tree.right.right) >= height(tree.right.left))
rightRightRotation(tree);
else
rightLeftRotation(tree);
tree.height = Math.max( height(tree.left), height(tree.right)) + 1;
return tree;
- 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
5.删除
public void remove(T key)
AVLTreeNode<T> z;
mRoot = remove(mRoot, z);
/**
* 删除结点(z)，返回根节点
*
* @param tree AVL树的根结点
* @param z 待删除的结点
* @return 根节点
*/
private AVLTreeNode<T> remove(AVLTreeNode<T> tree, AVLTreeNode<T> z)
if (tree == null)
return tree;
int cmp = z.element.compareTo(tree.element);
if (cmp > 0)
tree.right = remove(tree.right, z);
else if (cmp < 0)
tree.left = remove(tree.left, z);
else if (tree.left != null && tree.right != null)
tree.element = findMin(tree.right).element;
tree.right = remove(tree.element, tree.right);
else
tree = (tree.left != null) ? tree.left : tree.right;
return balance(tree);
private AVLTreeNode<T> findMin(AVLTreeNode<T> node)
if (node != null)
while (node.left != null)
node = node.left;
return node;
public AVLTreeNode<T> remove(T t, AVLTreeNode<T> node)
if (node == null)
return node;
int compareResult = t.compareTo(node.element);
if (compareResult > 0)
node.right = remove(t, node.right);
else if (compareResult < 0)
node.left = remove(t, node.left);
else if (node.left != null && node.right != null)
node.element = findMin(node.right).element;
node.right = remove(node.element, node.right);
else
node = (node.left != null) ? node.left : node.right;
return node;
- 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
删除操作就是在原来查找二叉树的基础上，每一次删除都调用balance()方法对AVL树进行再平衡。
完整的实现代码如下：
public class AVLTree<T extends Comparable<T>>
private AVLTreeNode<T> mRoot;
class AVLTreeNode<T extends Comparable<T>>
T element;
int height;
AVLTreeNode<T> left;
AVLTreeNode<T> right;
public AVLTreeNode(T key, AVLTreeNode<T> left, AVLTreeNode<T> right)
this.element = key;
this.left = left;
this.right = right;
this.height = 数据结构——AVL数
数据结构之AVL树
图解数据结构树之AVL树
二叉树--二叉平衡树
算法二叉搜索树之AVL树
[javaSE] 数据结构（AVL树基本概念）