hello-algo/codes/java/chapter_tree/avl_tree.java

231 lines
7.2 KiB
Java
Raw Normal View History

/**
2022-12-10 20:46:47 +08:00
* File: avl_tree.java
* Created Time: 2022-12-10
* Author: Krahets (krahets@163.com)
*/
2022-12-11 02:44:48 +08:00
package chapter_tree;
import include.*;
2023-02-03 18:58:01 +08:00
/* AVL 树 */
2022-12-11 02:44:48 +08:00
class AVLTree {
TreeNode root; // 根节点
2022-12-11 02:44:48 +08:00
/* 获取节点高度 */
2022-12-11 02:44:48 +08:00
public int height(TreeNode node) {
// 空节点高度为 -1 ,叶节点高度为 0
2022-12-11 02:44:48 +08:00
return node == null ? -1 : node.height;
}
/* 更新节点高度 */
2022-12-11 02:44:48 +08:00
private void updateHeight(TreeNode node) {
// 节点高度等于最高子树高度 + 1
2022-12-11 02:44:48 +08:00
node.height = Math.max(height(node.left), height(node.right)) + 1;
}
/* 获取平衡因子 */
public int balanceFactor(TreeNode node) {
// 空节点平衡因子为 0
if (node == null)
return 0;
// 节点平衡因子 = 左子树高度 - 右子树高度
2022-12-11 02:44:48 +08:00
return height(node.left) - height(node.right);
}
/* 右旋操作 */
private TreeNode rightRotate(TreeNode node) {
TreeNode child = node.left;
TreeNode grandChild = child.right;
// 以 child 为原点,将 node 向右旋转
child.right = node;
node.left = grandChild;
// 更新节点高度
2022-12-11 02:44:48 +08:00
updateHeight(node);
updateHeight(child);
// 返回旋转后子树的根节点
2022-12-11 02:44:48 +08:00
return child;
}
/* 左旋操作 */
private TreeNode leftRotate(TreeNode node) {
TreeNode child = node.right;
TreeNode grandChild = child.left;
// 以 child 为原点,将 node 向左旋转
child.left = node;
node.right = grandChild;
// 更新节点高度
2022-12-11 02:44:48 +08:00
updateHeight(node);
updateHeight(child);
// 返回旋转后子树的根节点
2022-12-11 02:44:48 +08:00
return child;
}
/* 执行旋转操作,使该子树重新恢复平衡 */
private TreeNode rotate(TreeNode node) {
// 获取节点 node 的平衡因子
2022-12-11 02:44:48 +08:00
int balanceFactor = balanceFactor(node);
// 左偏树
if (balanceFactor > 1) {
if (balanceFactor(node.left) >= 0) {
// 右旋
return rightRotate(node);
} else {
// 先左旋后右旋
node.left = leftRotate(node.left);
return rightRotate(node);
}
}
// 右偏树
if (balanceFactor < -1) {
if (balanceFactor(node.right) <= 0) {
// 左旋
return leftRotate(node);
} else {
// 先右旋后左旋
node.right = rightRotate(node.right);
return leftRotate(node);
}
}
// 平衡树,无需旋转,直接返回
return node;
}
/* 插入节点 */
2022-12-11 02:44:48 +08:00
public TreeNode insert(int val) {
root = insertHelper(root, val);
return root;
}
/* 递归插入节点(辅助方法) */
2022-12-11 02:44:48 +08:00
private TreeNode insertHelper(TreeNode node, int val) {
if (node == null)
return new TreeNode(val);
/* 1. 查找插入位置,并插入节点 */
2022-12-11 02:44:48 +08:00
if (val < node.val)
node.left = insertHelper(node.left, val);
else if (val > node.val)
node.right = insertHelper(node.right, val);
else
return node; // 重复节点不插入,直接返回
updateHeight(node); // 更新节点高度
2022-12-11 02:44:48 +08:00
/* 2. 执行旋转操作,使该子树重新恢复平衡 */
node = rotate(node);
// 返回子树的根节点
2022-12-11 02:44:48 +08:00
return node;
}
/* 删除节点 */
2022-12-11 02:44:48 +08:00
public TreeNode remove(int val) {
root = removeHelper(root, val);
return root;
}
/* 递归删除节点(辅助方法) */
2022-12-11 02:44:48 +08:00
private TreeNode removeHelper(TreeNode node, int val) {
if (node == null)
return null;
/* 1. 查找节点,并删除之 */
2022-12-11 02:44:48 +08:00
if (val < node.val)
node.left = removeHelper(node.left, val);
else if (val > node.val)
node.right = removeHelper(node.right, val);
else {
if (node.left == null || node.right == null) {
TreeNode child = node.left != null ? node.left : node.right;
// 子节点数量 = 0 ,直接删除 node 并返回
2022-12-11 02:44:48 +08:00
if (child == null)
return null;
// 子节点数量 = 1 ,直接删除 node
2022-12-11 02:44:48 +08:00
else
node = child;
} else {
// 子节点数量 = 2 ,则将中序遍历的下个节点删除,并用该节点替换当前节点
TreeNode temp = getInOrderNext(node.right);
2022-12-11 02:44:48 +08:00
node.right = removeHelper(node.right, temp.val);
node.val = temp.val;
}
}
updateHeight(node); // 更新节点高度
2022-12-11 02:44:48 +08:00
/* 2. 执行旋转操作,使该子树重新恢复平衡 */
node = rotate(node);
// 返回子树的根节点
2022-12-11 02:44:48 +08:00
return node;
}
/* 获取中序遍历中的下一个节点(仅适用于 root 有左子节点的情况) */
private TreeNode getInOrderNext(TreeNode node) {
if (node == null)
return node;
// 循环访问左子节点,直到叶节点时为最小节点,跳出
2022-12-11 02:44:48 +08:00
while (node.left != null) {
node = node.left;
}
return node;
}
/* 查找节点 */
2022-12-11 02:44:48 +08:00
public TreeNode search(int val) {
TreeNode cur = root;
// 循环查找,越过叶节点后跳出
2022-12-11 02:44:48 +08:00
while (cur != null) {
// 目标节点在 cur 的右子树中
2022-12-11 02:44:48 +08:00
if (cur.val < val)
cur = cur.right;
// 目标节点在 cur 的左子树中
2022-12-11 02:44:48 +08:00
else if (cur.val > val)
cur = cur.left;
// 找到目标节点,跳出循环
2022-12-11 02:44:48 +08:00
else
break;
}
// 返回目标节点
2022-12-11 02:44:48 +08:00
return cur;
}
}
public class avl_tree {
static void testInsert(AVLTree tree, int val) {
tree.insert(val);
System.out.println("\n插入节点 " + val + "AVL 树为");
2022-12-11 02:44:48 +08:00
PrintUtil.printTree(tree.root);
}
static void testRemove(AVLTree tree, int val) {
tree.remove(val);
System.out.println("\n删除节点 " + val + "AVL 树为");
2022-12-11 02:44:48 +08:00
PrintUtil.printTree(tree.root);
}
public static void main(String[] args) {
/* 初始化空 AVL 树 */
AVLTree avlTree = new AVLTree();
/* 插入节点 */
// 请关注插入节点后AVL 树是如何保持平衡的
2022-12-11 02:44:48 +08:00
testInsert(avlTree, 1);
testInsert(avlTree, 2);
testInsert(avlTree, 3);
testInsert(avlTree, 4);
testInsert(avlTree, 5);
testInsert(avlTree, 8);
testInsert(avlTree, 7);
testInsert(avlTree, 9);
testInsert(avlTree, 10);
testInsert(avlTree, 6);
/* 插入重复节点 */
2022-12-11 02:44:48 +08:00
testInsert(avlTree, 7);
/* 删除节点 */
// 请关注删除节点后AVL 树是如何保持平衡的
testRemove(avlTree, 8); // 删除度为 0 的节点
testRemove(avlTree, 5); // 删除度为 1 的节点
testRemove(avlTree, 4); // 删除度为 2 的节点
2022-12-11 02:44:48 +08:00
/* 查询节点 */
2022-12-11 02:44:48 +08:00
TreeNode node = avlTree.search(7);
System.out.println("\n查找到的节点对象为 " + node + ",节点值 = " + node.val);
2022-12-11 02:44:48 +08:00
}
}