Java数据结构与算法解析(六)——AVL树
来源:互联网 发布:linux修改ip配置文件 编辑:程序博客网 时间:2024/05/03 13:16
之前我们说过普通二叉查找树的删除算法会使得左子树比右子树深,因为我们总是用右子树的一个来代替删除的节点。会造成二叉查找树,严重的不平衡。
AVL树简介
而AVL树就是解决普通二叉查找树弊端的方法,他是带有平衡条件的二叉查找树,这个平衡条件必须容易保持,而且它保证树的深度必须是O(logN).
AVL树是高度平衡的而二叉树。它的特点是:AVL树中任何节点的两个子树的高度最大差别为1。
上面的两张图片,左边的是AVL树,它的任何节点的两个子树的高度差别都<=1;而右边的不是AVL树,因为7的两颗子树的高度相差为2(以2为根节点的树的高度是3,而以8为根节点的树的高度是1)。
AVL树的实现
1.节点
// AVL树的节点(内部类) 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; }
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) {// 将key插入到"tree的左子树"的情况 tree.left = insert(tree.left, key); } else if (cmp > 0) { // 将key插入到"tree的右子树"的情况 tree.right = insert(tree.right, key); } return balance(tree); }
插入节点后,可能会使AVL树失去平衡,通过balance()方法进行相应的调节。
private static final int ALLOWED_IMBALANCE = 1; private AVLTreeNode<T> balance(AVLTreeNode<T> tree) { if (tree == null) { return tree; } // 插入节点后,若AVL树失去平衡,则进行相应的调节。 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; }
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; }
删除操作就是在原来查找二叉树的基础上,每一次删除都调用balance()方法对AVL树进行再平衡。
完整的实现代码如下:
public class AVLTree<T extends Comparable<T>> { private AVLTreeNode<T> mRoot; // 根结点 // AVL树的节点(内部类) 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; } } /* * 获取树的高度 */ private int height(AVLTreeNode<T> tree) { if (tree != null) return tree.height; return 0; } public int height() { return height(mRoot); } /* * 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; } /** * 右右对应的情况(右单旋转)。 * * @param k1 * @return 旋转后的根节点 */ 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:左右对应的情况(左双旋转)。 * * @param k3 * @return 旋转后的根节点 */ private AVLTreeNode<T> leftRightRotation(AVLTreeNode<T> k3) { k3.left = rightRightRotation(k3.left); return leftLeftRotation(k3); } /** * RL:右左对应的情况(右双旋转)。 * * @param k1 * @return 旋转后的根节点 */ private AVLTreeNode<T> rightLeftRotation(AVLTreeNode<T> k1) { k1.right = leftLeftRotation(k1.right); return rightRightRotation(k1); } 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) {// 将key插入到"tree的左子树"的情况 tree.left = insert(tree.left, key); } else if (cmp > 0) { // 将key插入到"tree的右子树"的情况 tree.right = insert(tree.right, key); } return balance(tree); } private static final int ALLOWED_IMBALANCE = 1; private AVLTreeNode<T> balance(AVLTreeNode<T> tree) { if (tree == null) { return tree; } // 插入节点后,若AVL树失去平衡,则进行相应的调节。 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; } public void remove(T key) { AVLTreeNode<T> z; if ((z = search(mRoot, key)) != null) mRoot = remove(mRoot, z); } /* * (递归实现)查找"AVL树x"中键值为key的节点 */ private AVLTreeNode<T> search(AVLTreeNode<T> x, T key) { if (x == null) return x; int cmp = key.compareTo(x.element); if (cmp < 0) return search(x.left, key); else if (cmp > 0) return search(x.right, key); else return x; } public AVLTreeNode<T> search(T key) { return search(mRoot, key); } /** * 删除结点(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; } /* * 打印"二叉查找树" * * key -- 节点的键值 * direction -- 0,表示该节点是根节点; * -1,表示该节点是它的父结点的左孩子; * 1,表示该节点是它的父结点的右孩子。 */ private void print(AVLTreeNode<T> tree, T key, int direction) { if(tree != null) { if(direction==0) // tree是根节点 System.out.printf("%2d is root\n", tree.element, key); else // tree是分支节点 System.out.printf("%2d is %2d's %6s child\n", tree.element, key, direction==1?"right" : "left"); print(tree.left, tree.element, -1); print(tree.right,tree.element, 1); } } public void print() { if (mRoot != null) print(mRoot, mRoot.element, 0); }}
AVL树的测试程序
public class AVLTreeTest { private static int arr[] = {3, 2, 1, 4, 5, 6, 7, 16, 15, 14, 13, 12, 11, 10, 8, 9}; public static void main(String[] args) { int i; AVLTree<Integer> tree = new AVLTree<Integer>(); System.out.printf("== 依次添加: "); for (i = 0; i < arr.length; i++) { System.out.printf("%d ", arr[i]); tree.insert(arr[i]); } System.out.printf("\n== 前序遍历: "); tree.preOrder(); System.out.printf("\n== 中序遍历: "); tree.inOrder(); System.out.printf("\n== 后序遍历: "); tree.postOrder(); System.out.printf("\n"); System.out.printf("== 高度: %d\n", tree.height()); System.out.printf("== 树的详细信息: \n"); tree.print(); i = 6; System.out.printf("\n== 删除根节点: %d", i); tree.remove(i); System.out.printf("\n== 高度: %d", tree.height()); System.out.printf("\n== 中序遍历: "); tree.inOrder(); System.out.printf("\n== 树的详细信息: \n"); tree.print(); }}
AVL树测试程序流程进行分析
新建AVL树
依次添加”3,2,1,4,5,6,7,16,15,14,13,12,11,10,8,9” 到AVL树中。
2.01 添加3,2
添加3,2都不会破坏AVL树的平衡性。
2.02 添加1
添加1之后,AVL树失去平衡(LL),此时需要对AVL树进行旋转(LL旋转)。旋转过程如下:
2.03 添加4
添加4不会破坏AVL树的平衡性。
2.04 添加5
添加5之后,AVL树失去平衡(RR),此时需要对AVL树进行旋转(RR旋转)。旋转过程如下:
2.05 添加6
添加6之后,AVL树失去平衡(RR),此时需要对AVL树进行旋转(RR旋转)。旋转过程如下:
2.06 添加7
添加7之后,AVL树失去平衡(RR),此时需要对AVL树进行旋转(RR旋转)。旋转过程如下:
2.07 添加16
添加16不会破坏AVL树的平衡性。
2.08 添加15
添加15之后,AVL树失去平衡(RR),此时需要对AVL树进行旋转(RR旋转)。旋转过程如下:
2.09 添加14
添加14之后,AVL树失去平衡(RL),此时需要对AVL树进行旋转(RL旋转)。旋转过程如下:
2.10 添加13
添加13之后,AVL树失去平衡(RR),此时需要对AVL树进行旋转(RR旋转)。旋转过程如下:
2.11 添加12
添加12之后,AVL树失去平衡(LL),此时需要对AVL树进行旋转(LL旋转)。旋转过程如下:
2.12 添加11
添加11之后,AVL树失去平衡(LL),此时需要对AVL树进行旋转(LL旋转)。旋转过程如下:
2.13 添加10
添加10之后,AVL树失去平衡(LL),此时需要对AVL树进行旋转(LL旋转)。旋转过程如下:
2.14 添加8
添加8不会破坏AVL树的平衡性。
2.15 添加9
但是添加9之后,AVL树失去平衡(LR),此时需要对AVL树进行旋转(LR旋转)。旋转过程如下:
- Java数据结构与算法解析(六)——AVL树
- Java数据结构与算法解析(六)——AVL树
- Java数据结构与算法解析(六)——AVL树
- Java数据结构与算法解析---AVL树
- 数据结构与算法之AVL平衡树<六>
- 算法与数据结构 其六 Avl平衡树
- 数据结构与算法——AVL树简介
- 【数据结构与算法基础】AVL树 / AVL Tree
- 数据结构与算法10: 平衡二叉树AVL(AVL Tree)
- 数据结构—AVL树
- [数据结构与算法]AVL树的旋转
- C源码@数据结构与算法->AVL树
- 数据结构与算法简记:AVL树
- 数据结构与算法简记:AVL树
- 【算法】数据结构与算法分析学习笔记——第四章AVL树C语言实现
- Java数据结构与算法解析(八)——伸展树
- Java数据结构与算法解析(九)——B树
- Java数据结构与算法解析(八)——伸展树
- 队列 LinkedBlockingQueue
- 国内最火的开源项目 —— Python 篇
- java中的 方法的重写
- 第八章 线性时间排序
- Faster-RCNN_TF代码解读17:anchor_target_layer_tf.py
- Java数据结构与算法解析(六)——AVL树
- WPF深入浅出之我见
- java中继承的初始化顺序
- oracle11g 监听日志过大处理
- Sftp只允许用户访问指定的目录
- POJ 2559 Largest Rectangle in a Histogram(单调栈)
- iOS之《Effective Objective-C 2.0》读书笔记(48)
- Spark 集群搭建从零开始之2 Spark单机伪分布式安装与配置
- phpcmsv9调用友情链接