第八章 平衡二叉搜索树、AVL树
第八章 平衡二叉搜索树、AVL树
二叉搜索树缺点分析
- 当 n 比较大时，两者的性能差异比较大
- 比如 n = 1000000 时，二叉搜索树的最低高度是 20，最高高度是 1000000
由此可见，
二叉搜索树添加节点时可能会导致二叉搜索树退化成链表
删除节点时也可能会导致二叉搜索树退化成链表
有没有办法防止二叉搜索树退化成链表？
让添加、删除、搜索的复杂度维持在 O(logn)？
改进二叉搜索树
平衡（Balance）
平衡：当节点数量固定时，左右子树的高度越接近，这棵二叉树就越平衡（高度越低）
理想平衡
最理想的平衡，就是像完全二叉树、满二叉树那样，高度是最小的
如何改进二叉搜索树？
- 首先，节点的添加、删除顺序是无法限制的，可以认为是随机的
- 所以，改进方案是：在节点的添加、删除操作之后，想办法让二叉搜索树恢复平衡（减小树的高度）
- 如果接着继续调整节点的位置，完全可以达到理想平衡，但是付出的代价可能会比较大
- 比如调整的次数会比较多，反而增加了时间复杂度
- 总结来说，比较合理的改进方案是：用尽量少的调整次数达到适度平衡即可
- 一棵达到适度平衡的二叉搜索树，可以称之为：平衡二叉搜索树
平衡二叉搜索树（Balanced Binary Search Tree）
- 英文简称为：BBST
- 经典常见的平衡二叉搜索树有：
- AVL树
- Windows NT 内核中广泛使用
- 红黑树
- C++ STL（比如 map、set ）
- Java 的 TreeMap、TreeSet、HashMap、HashSet
- Linux 的进程调度
- Ngix 的 timer 管理
- 一般也称它们为：自平衡的二叉搜索树（Self-balancing Binary Search Tree）
- AVL树
AVL树
- AVL 树是最早发明的自平衡二叉搜索树之—
- AVL取名于两位发明者的名字
- G.M.Adelson-Velsky 和 E.M.Landis（来自苏联的科学家）
- 平衡因子（Balance Factor）：某结点的左右子树的高度差
- AVL树的特点：
- 每个节点的平衡因子只可能是 1、0、-1 (绝对值 ≤ 1，如果超过 1，称之为 “失衡")
- 每个节点的左右子树高度差不超过1
- 搜索、添加、删除的时间复杂度是 O ( logn )
BST 对比 AVLTree
输入数据：35, 37, 34, 56, 25, 62, 57, 9, 74, 32, 94, 80, 75, 100, 16, 82
继承 BST
添加节点导致的失衡
示例：往下面这棵子树中添加 13
- 最坏情况：可能会导致所有祖先节点都失衡
- 父节点、非祖先节点，都不可能失衡
修复平衡的操作：
- LL – 右旋转（单旋）
- RR – 左旋转（单旋）
- LR – 先左旋，再右旋（双旋）
- RL – 先右旋，再左旋（双旋）
有些教程里面：
- 把右旋转叫做 zig，旋转之后的状态叫做 zigged
- 把左旋转叫做 zag，旋转之后的状态叫做 zagged
LL – 右旋转（单旋）
有些教程里面，把右旋转叫做zig，旋转之后的状态叫做zigged
操作步骤
g.left = p.rightp.right = g- 让
p成为这颗子树的根节点 - 旋转后仍然是一颗 二叉搜索树：
T0 < n < T1 < p < T2 < g < T3 - 整棵树都达到平衡
- 还需要注意维护的内容
T2、p、g的parent属性
- 先后更新
g、p的高度
/**
* 右旋
*
* @param grand
*/
private void rotateRight(Node<E> grand) {
Node<E> parent = grand.left;
Node<E> child = parent.right;
grand.left = child;
parent.right = grand;
afterRotate(grand, parent, child);
}
RR – 左旋转（单旋）
有些教程里面，把左旋转叫做zag，旋转之后的状态叫做zagged
操作步骤
g.right = p.leftp.left = g- 让
p成为这颗子树的根节点 - 旋转后仍然是一颗 二叉搜索树：
T0 < g < T1 < o < T2 < n < T3 - 整棵树都达到平衡
- 还需要注意维护的内容
T1、p、g的parent属性
- 先后更新
g、p的高度
/**
* 左旋
*
* @param grand
*/
private void rotateLeft(Node<E> grand) {
Node<E> parent = grand.right;
Node<E> child = parent.left;
grand.right = child;
parent.left = grand;
afterRotate(grand, parent, child);
}
LR – 先左旋，再右旋（双旋）
LR 就是 先进行 左旋转 – RR、再进行 右旋转 – LL
- 先左旋转：
p.right = n.left、n.left = p - 再右旋转：
g.left = n.right、n.right = g - 旋转后仍然是一颗 二叉搜索树：
T0 < p < T1 < n < T2 < g < T3 - 整棵树都达到平衡
RL – 先右旋，再左旋（双旋）
RL 就是 先进行 右旋转 – LL、再进行 左旋转 – RR
- 先右旋转：
p.left = n.right、n.right = p - 再左旋转：
g.right = n.left、n.left = g - 旋转后仍然是一颗 二叉搜索树：
T0 < g < T1 < n < T2 < p < T3 - 整棵树都达到平衡
旋转之后维护的内容
private void afterRotate(Node<E> grand, Node<E> parent, Node<E> child) {
//让parent成为子树的根节点
parent.parent = grand.parent;
if (grand.isLeftChild()) {
grand.parent.left = parent;
} else if (grand.isRightChild()) {
grand.parent.right = parent;
} else { //grand是根节点
root = parent;
}
//更新child的parent
if (child != null) {
child.parent = grand;
}
//更新grand的parent
grand.parent = parent;
//更新高度
updateHeight(grand);
updateHeight(parent);
}
添加之后的修复图解
- 输入数据：13, 14, 15, 12, 11, 17, 16, 8, 9, 1
- 输入13：正常
- 输入14：正常
- 输入15：13失衡，RR，左旋转
- 输入12：正常
- 输入11：13失衡，LL，右旋转
- 输入17：正常
- 输入16：15失衡，RL，先对17进行右旋转、再对15进行左旋转
- 输入8：正常
- 输入9：11失衡，LR，先对8进行左旋转、再对11进行右旋转
- 输入1：12失衡，LL，对12进行右旋转
添加之后的修复 - 代码实现
@Override
protected void afterAdd(Node<E> node) {
while ((node = node.parent) != null) {
if (isBalanced(node)) {
//更新高度
updateHeight(node);
} else {
//恢复平衡
rebalance(node);
//整棵树恢复平衡
break;
}
}
}
/**
* 恢复平衡
*
* @param grand 高度最低的那个不平衡节点
*/
private void rebalance(Node<E> grand) {
Node<E> parent = ((AVLNode<E>) grand).tallerChild();
Node<E> node = ((AVLNode<E>) parent).tallerChild();
if (parent.isLeftChild()) { //L
if (node.isLeftChild()) { //LL
rotateRight(grand); //右旋
} else { //LR
rotateLeft(parent); //左旋
rotateRight(grand); //右旋
}
} else { //R
if (node.isLeftChild()) { //RL
rotateRight(parent); //右旋
rotateLeft(grand); //左旋
} else { //RR
rotateLeft(grand); //左旋
}
}
}
统一所有的旋转操作
private void rotate(
Node<E> r, //子树的根节点
Node<E> a, Node<E> b, Node<E> c,
Node<E> d,
Node<E> e, Node<E> f, Node<E> g) {
//让d成为这棵子树的根节点
d.parent = r.parent;
if (r.isLeftChild()) {
r.parent.left = d;
} else if (r.isRightChild()) {
r.parent.right = d;
} else {
root = d;
}
// a - b - c
b.left = a;
if (a != null) {
a.parent = b;
}
b.right = c;
if (c != null) {
c.parent = b;
}
updateHeight(b); //更新b的高度
// e - f - g
f.left = e;
if (e != null) {
e.parent = f;
}
f.right = g;
if (g != null) {
g.parent = f;
}
updateHeight(f); //更新f的高度
// b - d - f
d.left = b;
d.right = f;
b.parent = d;
f.parent = d;
updateHeight(d); //更新d的高度
}
/**
* 统一旋转操作
* 恢复平衡
*
* @param grand 高度最低的那个不平衡节点
*/
private void rebalance(Node<E> grand) {
Node<E> parent = ((AVLNode<E>) grand).tallerChild();
Node<E> node = ((AVLNode<E>) parent).tallerChild();
if (parent.isLeftChild()) { //L
if (node.isLeftChild()) { //LL
rotate(grand, node.left, node, node.right, parent, parent.right, grand, grand.right);
} else { //LR
rotate(grand, parent.left, parent, node.left, node, node.right, grand, grand.right);
}
} else { //R
if (node.isLeftChild()) { //RL
rotate(grand, grand.left, grand, node.left, node, node.right, parent, parent.right);
} else { //RR
rotate(grand, grand.left, grand, parent.left, parent, node.left, node, node.right);
}
}
}
删除节点导致的失衡
- 示例：删除下面这棵子树中的 16
- 可能会导致父节点或祖先节点失衡（只有1个节点会失衡）
- 其他节点，都不可能失衡
LL – 右旋转（单旋）
- 如果绿色节点不存在，更高层的祖先节点可能也会失衡，需要再次恢复平衡，然后又可能导致更高层的祖先节点失衡…
- 极端情况下，所有祖先节点都需要进行恢复平衡的操作，共 O(logn) 次调整
RR – 左旋转（单旋）
LR – RR左旋转，LL右旋转（双旋）
RL – LL右旋转，RR左旋转（双旋）
删除之后的修复
@Override
protected void afterRemove(Node<E> node) {
while ((node = node.parent) != null) {
if (isBalanced(node)) {
//更新高度
updateHeight(node);
} else {
//恢复平衡
rebalance(node);
}
}
}
AVL树总结
- 添加
- 可能会导致所有祖先节点都失衡
- 只要让高度最低的失衡节点恢复平衡，整棵树就恢复平衡【仅需 O(1) 次调整】
- 删除
- 可能会导致父节点或祖先节点失衡（只有1个节点会失衡）
- 恢复平衡后，可能会导致更高层的祖先节点失衡【最多需要 O(logn) 次调整】
- 平均时间复杂度
- 搜索：O(logn)
- 添加：O(logn)，仅需 O(1) 次的旋转操作
- 删除：O(logn)，最多需要 O(logn) 次的旋转操作
AVL树完整源码
package cn.xx.java.tree;
import java.util.Comparator;
/**
* AVL树
*
* @author xiexu
* @create 2021-08-03 10:49 上午
*/
public class AVLTree<E> extends BST<E> {
public AVLTree() {
this(null);
}
public AVLTree(Comparator<E> comparator) {
super(comparator);
}
/**
* 添加节点之后的操作
*
* @param node 新添加的节点
*/
@Override
protected void afterAdd(Node<E> node) {
while ((node = node.parent) != null) {
if (isBalanced(node)) { //当前节点是平衡的
//更新高度
updateHeight(node);
} else {
/**
* 恢复平衡
* 进去里面的node就是高度最低的那个不平衡节点
*/
rebalance(node);
//整棵树恢复平衡
break;
}
}
}
/**
* 删除节点之后的操作
*
* @param node 被删除的节点
*/
@Override
protected void afterRemove(Node<E> node) {
while ((node = node.parent) != null) {
if (isBalanced(node)) {
//更新高度
updateHeight(node);
} else {
//恢复平衡
rebalance(node);
}
}
}
/**
* 重写父类中的 createNode
*
* @param element
* @param parent
* @return
*/
@Override
protected Node<E> createNode(E element, Node<E> parent) {
return new AVLNode<>(element, parent);
}
/**
* 恢复平衡
*
* @param grand 高度最低的那个不平衡节点
*/
private void rebalance2(Node<E> grand) {
Node<E> parent = ((AVLNode<E>) grand).tallerChild();
Node<E> node = ((AVLNode<E>) parent).tallerChild();
if (parent.isLeftChild()) { //L
if (node.isLeftChild()) { //LL
rotateRight(grand); //右旋
} else { //LR
rotateLeft(parent); //左旋
rotateRight(grand); //右旋
}
} else { //R
if (node.isLeftChild()) { //RL
rotateRight(parent); //右旋
rotateLeft(grand); //左旋
} else { //RR
rotateLeft(grand); //左旋
}
}
}
/**
* 统一旋转操作
* 恢复平衡
*
* @param grand 高度最低的那个不平衡节点
*/
private void rebalance(Node<E> grand) {
Node<E> parent = ((AVLNode<E>) grand).tallerChild();
Node<E> node = ((AVLNode<E>) parent).tallerChild();
if (parent.isLeftChild()) { //L
if (node.isLeftChild()) { //LL
rotate(grand, node.left, node, node.right, parent, parent.right, grand, grand.right);
} else { //LR
rotate(grand, parent.left, parent, node.left, node, node.right, grand, grand.right);
}
} else { //R
if (node.isLeftChild()) { //RL
rotate(grand, grand.left, grand, node.left, node, node.right, parent, parent.right);
} else { //RR
rotate(grand, grand.left, grand, parent.left, parent, node.left, node, node.right);
}
}
}
private void rotate(
Node<E> r, //子树的根节点
Node<E> a, Node<E> b, Node<E> c,
Node<E> d,
Node<E> e, Node<E> f, Node<E> g) {
//让d成为这棵子树的根节点
d.parent = r.parent;
if (r.isLeftChild()) { // r是父节点的左子节点
r.parent.left = d;
} else if (r.isRightChild()) { // r是父节点的右子节点
r.parent.right = d;
} else { // r是根节点
root = d;
}
// a - b - c
b.left = a;
if (a != null) {
a.parent = b;
}
b.right = c;
if (c != null) {
c.parent = b;
}
updateHeight(b); //更新b的高度
// e - f - g
f.left = e;
if (e != null) {
e.parent = f;
}
f.right = g;
if (g != null) {
g.parent = f;
}
updateHeight(f); //更新f的高度
// b - d - f
d.left = b;
d.right = f;
b.parent = d;
f.parent = d;
updateHeight(d); //更新d的高度
}
/**
* 左旋
*
* @param grand
*/
private void rotateLeft(Node<E> grand) {
Node<E> parent = grand.right;
Node<E> child = parent.left;
grand.right = child;
parent.left = grand;
afterRotate(grand, parent, child);
}
/**
* 右旋
*
* @param grand
*/
private void rotateRight(Node<E> grand) {
Node<E> parent = grand.left;
Node<E> child = parent.right;
grand.left = child;
parent.right = grand;
afterRotate(grand, parent, child);
}
/**
* 公共代码：不管是左旋转、右旋转，都要执行
*
* @param grand 失衡节点
* @param parent
* @param child
*/
private void afterRotate(Node<E> grand, Node<E> parent, Node<E> child) {
//让parent成为子树的根节点
parent.parent = grand.parent;
if (grand.isLeftChild()) {
grand.parent.left = parent;
} else if (grand.isRightChild()) {
grand.parent.right = parent;
} else { //grand是根节点
root = parent;
}
//更新child的parent
if (child != null) {
child.parent = grand;
}
//更新grand的parent
grand.parent = parent;
//更新高度
updateHeight(grand);
updateHeight(parent);
}
/**
* 判断传入节点是否平衡
*
* @param node
* @return
*/
private boolean isBalanced(Node<E> node) {
return Math.abs(((AVLNode<E>) node).balanceFactor()) <= 1;
}
/**
* 更新高度
*
* @param node
*/
private void updateHeight(Node<E> node) {
((AVLNode<E>) node).updateHeight();
}
/**
* AVL树节点
*
* @param
*/
private static class AVLNode<E> extends Node<E> {
int height = 1; //叶子节点的默认高度就是1
public AVLNode(E element, Node<E> parent) {
super(element, parent);
}
/**
* 返回当前节点的平衡因子
*
* @return
*/
public int balanceFactor() {
int leftHeight = left == null ? 0 : ((AVLNode<E>) left).height;
int rightHeight = right == null ? 0 : ((AVLNode<E>) right).height;
return leftHeight - rightHeight;
}
/**
* 更新节点的高度
*/
public void updateHeight() {
int leftHeight = left == null ? 0 : ((AVLNode<E>) left).height;
int rightHeight = right == null ? 0 : ((AVLNode<E>) right).height;
height = 1 + Math.max(leftHeight, rightHeight);
}
/**
* 返回高度较高的那个子节点
* 因为p总是左右子树中高度最高的那个节点
* n也总是左右子树中高度最高的那个节点
*
* @return
*/
public Node<E> tallerChild() {
int leftHeight = left == null ? 0 : ((AVLNode<E>) left).height;
int rightHeight = right == null ? 0 : ((AVLNode<E>) right).height;
if (leftHeight > rightHeight) {
return left;
}
if (leftHeight < rightHeight) {
return right;
}
/**
* 左右高度相同，就返回与父节点的子节点同方向的那个节点
*/
return isLeftChild() ? left : right;
}
@Override
public String toString() {
String parentString = "null";
if (parent != null) {
parentString = parent.element.toString();
}
return element + "_p(" + parentString + ")_h(" + height + ")";
}
}
}
练习
110_平衡二叉树
package 二叉树;
/**
* https://leetcode-cn.com/problems/balanced-binary-tree/
*
* @author xiexu
* @create 2021-08-04 11:50 上午
*/
public class _110_平衡二叉树 {
public boolean isBalanced(TreeNode root) {
return getHeight(root) != -1;
}
public int getHeight(TreeNode root) {
if (root == null) {
return 0;
}
int leftHeight = getHeight(root.left);
if (leftHeight == -1) {
return -1;
}
int rightHeight = getHeight(root.right);
if (rightHeight == -1) {
return -1;
}
// 左右子树高度差大于1，return -1表示已经不是平衡树了
if (Math.abs(leftHeight - rightHeight) > 1) {
return -1;
}
return Math.max(leftHeight, rightHeight) + 1;
}
}