平衡二叉搜索树
AVL树的实现
- 二叉搜索树在插入和删除时，节点可能发生失衡；
- 如果在插入和删除时通过旋转，始终让二叉搜索树保持平衡，称之为平衡二叉搜索树；
- AVL树是自平衡二叉搜索树的实现之一
LL
- 失衡节点(图中5红色)的`bf>1`，即左边更高
- 失衡节点的左孩子(图中3 黄色)的`bf>=0`，即左孩子这边也是左边更高或等高
LR
- 失衡节点(图中6)的`bf>1`，即左边更高
- 失衡节点的左孩子(图中2 黄色)的`bf<0`，即左孩子这边是右边更高
RL
-失衡节点(图中2)的`bf<-1`，即右边更高
-失衡节点的右孩子(图中6黄色)的`bf>0`，即右孩子这边是左边更高
RR
-失衡节点(图中2红色)的`bf<-1`，即右边更高
-失衡节点的右孩子(图中6黄色)的`bf<=0`，即右孩子这边是右边更高或者等高
public class AVLTree{
static class AVLNode{
int key;
Object value;
AVLNode left;
AVLNode right;
int height = 1;
public AVLNode (int key, Object value) {
this.key = key;
this.value = value;
}
public AVLNode (int key) {
this.key = key;
}
public AVLNode (int key, Object value, AVLNode left, AVLNode right) {
this.key = key;
this.value = value;
this.left = left;
this.right = right;
}
}
// 求节点高度
public int height(AVLNode node) {
return node == 0 ? 0 : node.height;
}
// 更新节点高度(新增、删除、旋转)
public void updateHeight(AVLNode node) {
node.height = Math.max(height(node.left), height(node.right)) + 1;
}
// 平衡因子(balance factor) = 左子树高度-右子树高度
// bf = 0, -1, 1, 表示左右平衡
// bf > 1, 表示左子树高
// bf < -1, 表示右子树高
public int bf(TreeNode node) {
return height(node.left) - height(node.right);
}
// 输入要旋转的节点，返回新节点----右旋
private AVLNode rightRotate(AVLNode red) {
AVLNode yellow = red.left;
AVLNode green = yellow.right;
yellow.right = red;
red.left = green;
updateHeight(red);
updateHeight(yellow);
return yellow;
}
// 输入要旋转的节点，返回新节点----左旋
private AVLNode leftRotate(AVLNode red) {
AVLNode yellow = red.right;
AVLNode green = yellow.left;
yellow.left = red;
red.righ = green;
updateHeight(red);
updateHeight(yellow);
return yellow;
}
// 先左旋，后右旋----先左旋左子树，后右旋根节点
private AVLNode leftRightRotate(AVLNode node) {
node.left = leftRotate(node.left);
return rightRotate(node);
}
// 先右旋右子树，后左旋根节点
private AVLNode rightLeftRotate(AVLNode node) {
node.right = rightRotate(node.right);
return leftRotate(node);
}
// 检查是否平衡
private AVLNode balance(AVLNode node) {
if (node == null) {
return node;
}
int bf = bf(node);
if (bf > 1 && bf(node.left) >= 0) { //LL
rightRotate(node);
} else if (bf > 1 && bf(node.left) < 0) { // LR
leftRightRotate(node);
} else if (bf < -1 && bf(node.right) > 0) { // RL
rightLeftRotate(node);
} else if (bf < -1 && bf(node.right) <= 0) { // RR
leftRotate(node);
}
}
AVLNode root;
public void put(int key, Object value) {
return doPut(root, key, value);
}
private ALVNode doPut(AVLNode node, int key, Object value) {
// 1.找到空位，创建新节点
if (node == null) {
return new AVLNode(key, value);
}
// 2.树中存在节点，做更新操作
if (node.key == key) {
node.value = value;
return node;
}
// 3.查找操作
if (key < node.key) {
node.left = doPut(node.left, key, value);
}
if (key > node.key) {
node.right = doPut(node.right, key, value);
}
// 更新高度，检查是否平衡
updateHeight(node);
return balance(node);
}
public void remove(int key) {
root = doRemove(root, key);
}
public AVLNode doRemove(AVLNode node, int key) {
// 1.节点为空
if (node == null) {
return null;
}
// 2.寻找节点
if (key < node.key) {
node.left = doRemove(node.left, key);
} else if (key > node.key) {
node.right = doRemove(node.right, key);
} else {
// 3.找到节点，判断删除节点是否有孩子
if (node.left == null && node.right == null) {
return null;
} else if(node.left == null) {
node = node.right;
} else if (node.right == null) {
node = node.left;
} else { // 左右子树均在
// 在待删除节点的右子树zhon寻找待删除节点的后继节点
AVLNode s = node.right;
while (s.left != null) {
s = s.left;
}
// 找到后继节点
s.right = doRemove(node.right, s.key);
s.left = node.left;
node = s;
}
}
updateHeight(node);
return balance(node);
}
}
删除操作
Remove(node.right, s.key);
s.left = node.left;
node = s;
}
}
updateHeight(node);
return balance(node);
}
}
删除操作
