平衡二叉树平衡因子怎么计算_平衡二叉树（AVL Tree）旋转机制分析

平衡二叉树（AVL Tree）

概述

AVL树是以二分搜索树（BST）为底层数据结构而实现的，其特性是需要维护AVL的|平衡因子| <= 1

平衡因子
对于一个父节点的左右子树高度差的绝对值需要 <= 1

AVL最复杂的操作在于add()和remove()两个方法需要维护AVL的平衡二叉树特性，细节在下面展开

节点类

由于需要知道AVL一个节点的高度，因此需要在BST的内部类Node中新维护一个成员变量height

public class Node<K, V> {K key;V value;int height;Node<K, V> left, right;public Node(K key, V value) {this.key = key;this.value = value;this.left = null;this.right = null;this.height = 1;}
}

IMap接口

该接口定义了BST的方法

public interface IMap<K, V> {void add(K key, V value);V remove(K key);boolean contains(K key);V get(K key);void set(K key, V value);int getSize();boolean isEmpty();
}

AVLTree类

成员变量以及构造方法

private int size;
private Node<K, V> root;public AVLTree() {root = null;size = 0;
}

基本的方法

下面的方法均是为了实现add()和remove()方法时，可能造成AVL的平衡性被打破而封装的辅助方法

getHeight()

private int getHeight(Node<K, V> node) {if (node == null) {return 0;}return node.height;
}

该方法用于获取某节点的高度，且维护node为null时可能抛出的异常

getNode(Node node, K key)

private Node<K, V> getNode(Node<K, V> node, K key) {if (root == null) {return null;}if (key.compareTo(node.key) == 0) {return node;} else if (key.compareTo(node.key) < 0) {return getNode(node.left, key);} else {return getNode(node.right, key);}
}

根据key获取节点

getBalanceFactor(Node node)

// 获取平衡因子
private int getBalanceFactor(Node<K, V> node) {if (node == null) {return 0;}return getHeight(node.left) - getHeight(node.right);
}

获取平衡因子，并且维护了node可能为null而抛出异常的情况

核心方法

add(Node node)

@Override
public void add(K key, V value) {root = add(root, key, value);
}private Node<K, V> add(Node<K, V> node, K key, V value) {if (node == null) {size++;return new Node<>(key, value);}if (key.compareTo(node.key) < 0) {node.left = add(node.left, key, value);} else if (key.compareTo(node.key) > 0) {node.right = add(node.right, key, value);} else {// 如果插入节点存在，此处定义为改变 Value 的值（也可以根据情况不做改变）node.value = value;}node.height = Math.max(getHeight(node.left), getHeight(node.right) + 1);int balanceFactor = getBalanceFactor(node);// 平衡维护// LLif (balanceFactor > 1 && getBalanceFactor(node.left) >= 0) {return rightRotate(node);}// RRif (balanceFactor < -1 && getBalanceFactor(node.right) <= 0) {return leftRotate(node);}// LRif (balanceFactor > 1 && getBalanceFactor(node.right) < 0) {node.left = leftRotate(node.left);return rightRotate(node);}// RLif (balanceFactor < -1 && getBalanceFactor(node.right) > 0) {node.right = leftRotate(node);return rightRotate(node.right);}return node;
}

remove(K key)

@Override
public V remove(K key) {Node<K, V> node = getNode(root, key);if (node != null) {root = remove(root, key);return node.value;}return null;
}private Node<K, V> remove(Node<K, V> node, K key) {if (node == null) {return null;}Node<K, V> retNode;if (key.compareTo(node.key) < 0) {node.left = remove(node.left, key);retNode = node;} else if (key.compareTo(node.key) > 0) {node.right = remove(node.right, key);retNode = node;} else {if (node.left == null) {Node<K, V> rightNode = node.right;node.right = null;size--;retNode = node;}if (node.right == null) {Node<K, V> leftNode = node.left;node.left = null;size--;retNode = node;}// 左右子树均不为空的情况Node<K, V> minimum = minimum(node.right);minimum.right = removeMin(node.right);minimum.left = node.left;node.left = node.right = null;retNode = minimum;}retNode.height = 1 + Math.max(getHeight(retNode.left), getHeight(retNode.right));int balanceFactor = getBalanceFactor(retNode);// 平衡维护// LLif (balanceFactor > 1 && getBalanceFactor(retNode.left) >= 0) {return rightRotate(retNode);}// RRif (balanceFactor < -1 && getBalanceFactor(retNode.right) <= 0) {return leftRotate(retNode);}// LRif (balanceFactor > 1 && getBalanceFactor(retNode.right) < 0) {retNode.left = leftRotate(retNode.left);return rightRotate(retNode);}// RLif (balanceFactor < -1 && getBalanceFactor(retNode.right) > 0) {retNode.right = leftRotate(retNode);return rightRotate(retNode.right);}return retNode;
}

维护AVL的平衡性质——旋转

这里是文章的核心内容，即如何保证AVL的平衡性质，这里开始详细描述维护AVL特性的机制——旋转

旋转分为四种形式，分别为：

LL旋转
RR旋转
LR旋转
RL旋转

只需要理解一种旋转机制，就可以理解其它的旋转机制

这里以LL和LR旋转为例

LL旋转

如图所示，根节点的平衡因子为2，而破坏该AVL的节点在根节点的左子树的左节点，因此需要LL旋转来维护其平衡

接下来根据实际代码进一步理解这个机制
为了结合代码，现在虚拟出三个节点（或子树），它们可以是null，也可以实际存在

目前由于是LL旋转，那么提供一个private方法用于维护平衡，下面给出方法详细代码，代码后有每一个表达式的详细解释

// 右旋转
private Node<K, V> rightRotate(Node<K, V> y) {Node<K, V> x = y.left;Node<K, V> t3 = x.right;x.right = y;y.left = t3;// 更新heighty.height = Math.max(getHeight(y.left), getHeight(y.right)) + 1;x.height = Math.max(getHeight(x.left), getHeight(x.right)) + 1;return x;
}

第一行表达式Node<K, V> x = y.left，将发现节点y的左子树暂存

第二行表达式Node<K, V> t3 = x.right，将单独拿出的节点的右子树t3暂存

第三行表达式x.right = y，将发现节点y接入x的右子树

第四行表达式y.left = t3，将暂存节点t3插入发现节点y的左节点

注意：以上的每个操作都是满足了二分搜索树（BST）的特性，这点对于理解旋转机制很重要
由于最终平衡后的AVL高度发生了改变，因此需要对更新后的AVL高度进行维护

// 更新height
y.height = Math.max(getHeight(y.left), getHeight(y.right)) + 1;
x.height = Math.max(getHeight(x.left), getHeight(x.right)) + 1;

LR旋转

LR旋转和LL旋转的差别在于LR旋转需要进行两次旋转操作，具体步骤如下：

首先对于上面的AVL进行一次左旋转，然后就会暂时将其转变为LL旋转的状态

然后再进行一次右旋转，即可恢复到AVL的状态

易错点分析

AVL有一个非常容易误解的地方，如图

实际上旋转的命名（LL、RR、LR、RL）也都是根据破坏节点t1(t2)与发现节点y的相对位置命名

也就是说无论是：

还是：

旋转方式是相同的，均为LL旋转，结果如图：