AVL树

AVL 树

  • AVL 树是一种平衡的二叉搜索树(BST),它的结构和操作与BST都是一致的,只是多加了一个平衡条件
  • AVL树的平衡条件是:它的任一节点的左子树和右子树的高度差的绝对值小于等于1

概念回顾:

  • 树的高度等于其根节点的高度
  • 节点的高度等于该节点与它最下面的叶子节点之间的边数

由定义可知,叶子节点的高度为0
为了便于计算,规定叶子节点的(假想的)子节点的高度为-1

那么判定一颗树是否是AVL树则是通过计算root节点的左右两个子节点的高度差,如果高度差的绝对值小于等于1,那么就是AVL树,否则不是。

最简单的办法就是在节点中存储节点的高度信息,这样可以迅速的计算出高度差(平衡因子)

废话不多说,用代码来描述更直接,下面是go语言的代码片段

// 节点类型
type node_t struct {
    Key    int
    height int
    left   *node_t
    right  *node_t
}

// 这是获取节点高度的get函数,避免每次获取高度都要判断node是否为nil
func height(node *node_t) int {
    if node == nil {
        return -1
    }
    return node.height
}

// 平衡因子:等于左子树的高度-右子树的高度
func balance_factor(node *node_t) int {
    if node == nil { // 空树,算作平衡
        return 0
    }
    return height(node.left) - height(node.right)
}

下面观察一下造成树不平衡的几种情况:

我们从空树开始构造,慢慢观察造成树不平衡的原因
先看只有一个节点的树:
这里写图片描述
很明显树是平衡的,节点3没有子节点,即左右两个子节点的高度都为-1,差为0,即:平衡

插入一个节点
插入一个节点可能出现的情况有两种,要么作为3的左子节点,要么作为3的右子节点,如图所示:
这里写图片描述
这两种情况,树都是平衡的:
左图节点3的平衡因子等于:0 - (-1) = 1
右图节点3的平衡因子等于:(-1) - 0 = -1

下面先考虑左图的情况,右图情况与左图是对称的,后面会给出对称的情况
我们继续插入一个节点,有3种可能:
第一种可能是插入的节点比3大,那么作为3的右子节点,例如:
这里写图片描述
上面的树是平衡的,不是我们要考虑的情况

第二种可能:插入的节点比1小(下面的左图)
第三种可能:插入的节点比3小,但是比1大(下面的右图)
这里写图片描述
左图节点3的平衡因子等于:1 - (-1) = 2
右图节点3的平衡因子等于:1 - (-1) = 2
这两种情况下树是不平衡的,那么在插入操作完成后需要对树进行调整(fix it),让树始终保持平衡
观察上面左图,根节点3有左节点1,左节点1有左节点0,这种情况称之为:left-left case
观察上面右图,根节点3有左节点1,左节点1有右节点2,这种情况称之为:left-right case

现在回过头来看看对称的情况
这里写图片描述
上图是对称的两种情况:
左图节点3的平衡因子等于:(-1) - 1 = -2
右图节点3的平衡因子等于:(-1) - 1 = -2
观察上面左图,根节点3有右节点5,右节点5有右节点6,这种情况称之为:right-right case
观察上面右图,根节点3有右节点5,右节点5有左节点4,这种情况称之为:right-left case

导致树不平衡的4种情况已经找到了,下面就要去fix it,使树重新平衡。
这4种情况两两对称,LL和RR对称,LR和RL对称。

我们先看LL和RR这两种情况

所谓fix就是让树重新平衡(AVL性质),且还是有序(BST性质)
再看下LL和RR这两种情况的树
这里写图片描述
对于LL的情况,只需要将节点1往上拉,使其成为根节点,节点3在重力作用下变成节点1的右节点,树再次平衡,且仍是有序的。
这个操作称之为对节点3应用一次向右旋转(single rotation),即把节点1作为支点,把节点3往下(顺时针)旋转。注意支点变成了根节点

这里写图片描述

同理,对于RR的情况,只需要将节点5往上拉,使其成为根节点,节点3在重力作用下变成节点5的左节点,树再次平衡,且仍是有序的。
这个操作称之为对节点3应用一次向左旋转(single rotation),即把节点5作为支点,把节点3往下(逆时针)旋转。注意支点变成了根节点

再看LR和RL这两种情况

这里写图片描述

这两种情况,如果只是简单的把节点1(左图)或节点5(右图)上拉就不好使了,因为树看起来是平衡了,但是却不是有序的了(不满足BST性质),如下图所示:
这里写图片描述

解决办法是做两次旋转(double rotation)
对于LR的情况:
先对根节点3的左子树根节点1应用一次向左旋转(以节点2为支点),将树转换成LL的情况后,再对根节点3应用一次右旋转
对于RL的情况:
先对根节点3的右子树根节点5应用一次向右旋转(以节点4为支点),将树转换成RR的情况后,再对根节点3应用一次左旋转

第一次旋转如下图所示:
这里写图片描述

第二次旋转如下图所示:

这里写图片描述

代码实现(golang)如下:

avl/node.go

package avl

// 节点类型
type node_t struct {
    Key    int
    height int
    left   *node_t
    right  *node_t
}

// 这是获取节点高度的get函数,避免每次获取高度都要判断node是否为nil
func height(node *node_t) int {
    if node == nil {
        return -1
    }
    return node.height
}

// 更新节点的高度信息
func update_height(node *node_t) {
    if node != nil {
        node.height = max(height(node.left), height(node.right)) + 1
    }
}

// 平衡因子:等于左子树的高度-右子树的高度
func balance_factor(node *node_t) int {
    if node == nil { // 空树,算作平衡
        return 0
    }
    return height(node.left) - height(node.right)
}

func max(x int, y int) int {
    if x > y {
        return x
    }
    return y
}

// 右转
func fix_ll_case(k2 *node_t) *node_t {
    k1 := k2.left
    k2.left = k1.right
    k1.right = k2
    update_height(k2)
    update_height(k1)
    return k1
}

// 左转
func fix_rr_case(k1 *node_t) *node_t {
    k2 := k1.right
    k1.right = k2.left
    k2.left = k1
    update_height(k1)
    update_height(k2)
    return k2
}

// 先左转后右转
func fix_lr_case(k3 *node_t) *node_t {
    k3.left = fix_rr_case(k3.left)
    return fix_ll_case(k3)
}

// 先右转后左转
func fix_rl_case(k1 *node_t) *node_t {
    k1.right = fix_ll_case(k1.right)
    return fix_rr_case(k1)
}

// 分4种情况分别fix
func rebalance(root *node_t) *node_t {
    bf := balance_factor(root)
    if bf == 2 {
        lbf := balance_factor(root.left)
        if lbf == 1 {
            root = fix_ll_case(root)
        } else {
            root = fix_lr_case(root)
        }
    } else if bf == -2 {
        rbf := balance_factor(root.right)
        if rbf == 1 {
            root = fix_rl_case(root)
        } else {
            root = fix_rr_case(root)
        }
    }
    return root
}

// 插入节点
func add(root *node_t, key int) *node_t {
    if root == nil {
        return &node_t{Key: key, height: 0}
    }
    if key < root.Key {
        root.left = add(root.left, key)
    } else if key > root.Key {
        root.right = add(root.right, key)
    }
    update_height(root)
    return rebalance(root)
}

// 删除节点,注意使用的技巧是:总是删除叶子节点
func remove(root *node_t, key int) *node_t {
    if root == nil {
        return nil
    }
    if root.Key == key {
        if root.height == 0 { // 叶子节点,直接删除
            root = nil
        } else if balance_factor(root) <= 0 { // 有右孩子
            root.Key = find_min(root.right).Key
            root.right = remove(root.right, root.Key)
        } else { // 有左孩子
            root.Key = find_max(root.left).Key
            root.left = remove(root.left, root.Key)
        }
    } else if key < root.Key {
        root.left = remove(root.left, key)
    } else {
        root.right = remove(root.right, key)
    }
    update_height(root)
    return rebalance(root)
}

func find_min(root *node_t) *node_t {
    if root == nil {
        return nil
    }
    node := root
    for node.left != nil {
        node = node.left
    }
    return node
}

func find_max(root *node_t) *node_t {
    if root == nil {
        return nil
    }
    node := root
    for node.right != nil {
        node = node.right
    }
    return node
}

func find(root *node_t, key int) *node_t {
    if root == nil {
        return nil
    }
    if key < root.Key {
        return find(root.left, key)
    }
    if key > root.Key {
        return find(root.right, key)
    }
    return root
}

创建一个tree类型,封装树的操作,便于使用:

avl/tree.go

package avl

type Tree_t struct {
    root *node_t
}

func (tree *Tree_t) Find(key int) *node_t {
    return find(tree.root, key)
}

func (tree *Tree_t) FindMin() *node_t {
    return find_min(tree.root)
}

func (tree *Tree_t) FindMax() *node_t {
    return find_max(tree.root)
}

func (tree *Tree_t) Add(key int) {
    tree.root = add(tree.root, key)
}

func (tree *Tree_t) Remove(key int) {
    tree.root = remove(tree.root, key)
}

对于节点高度信息的更新,只有在改变树结构的操作里更新高度信息,比如插入,删除,左转,右转操作
在插入和删除操作里,是在调用rebalance函数之前更新节点的高度信息,因为rebalance操作是根据树的高度信息来判定是否需要fix树结构的。

关于删除操作的技巧分析,参考:Binary Search Tree

07-07
AVL是一种自平衡的二叉查找,它确保了的高度始终保持在对数级别,从而保证了查找、插入和删除操作的时间复杂度为O(log n)。这种数据结构以它的发明者G.M. Adelson-Velsky和E.M. Landis的名字命名[^1]。 ### AVL的定义 - **平衡因子**:每个节点都有一个平衡因子,它是该节点左子的高度减去右子的高度。对于AVL来说,所有节点的平衡因子只能是-1, 0或1。 - **空**:如果T是空,则它自然是一个AVL。 - **非空**:若T不是空,则其左右子TL和TR都必须是AVL,并且对于任意节点,|HL - HR| ≤ 1(其中HL和HR分别表示左子和右子的高度)。 ### AVL的操作 当进行插入或删除操作时,可能会破坏AVL的平衡性,这时需要通过旋转来重新恢复平衡: - **单旋转**: - 左单旋(Single Rotate with Left)用于处理左孩子的左子过高。 - 右单旋(Single Rotate with Right)用于处理右孩子的右子过高。 - **双旋转**: - 左右双旋(Double Rotate with Left)用于处理左孩子的右子过高的情况。 - 右左双旋(Double Rotate with Right)用于处理右孩子的左子过高的情况。 这些旋转操作可以保持AVL的性质不变,并且能够快速地调整的结构以维持平衡。 ### AVL的实现 下面是一个简单的C语言代码示例,展示了如何定义AVL节点以及实现基本的插入操作。这个例子中包含了必要的函数声明和一些核心逻辑。 ```c #include <stdio.h> #include <stdlib.h> // 定义AVL节点结构体 typedef struct AvlNode { int element; struct AvlNode *left; struct AvlNode *right; int height; // 节点的高度 } *AvlTree, *Position; // 获取两个整数中的较大者 int max(int a, int b) { return (a > b) ? a : b; } // 计算给定节点的高度 static int Height(AvlTree T) { if (T == NULL) return -1; // 空节点高度为-1 else return T->height; } // 单旋转 - 左左情况 AvlTree singlerotatewithLeft(AvlTree K2) { Position K1 = K2->left; K2->left = K1->right; K1->right = K2; // 更新节点高度 K2->height = max(Height(K2->left), Height(K2->right)) + 1; K1->height = max(Height(K1->left), K2->height) + 1; return K1; // 新根 } // 单旋转 - 右右情况 AvlTree singlerotatewithRight(AvlTree K2) { Position K1 = K2->right; K2->right = K1->left; K1->left = K2; // 更新节点高度 K2->height = max(Height(K2->left), Height(K2->right)) + 1; K1->height = max(Height(K1->right), K2->height) + 1; return K1; // 新根 } // 双旋转 - 左右情况 AvlTree doublerotatewithLeft(AvlTree K3) { K3->left = singlerotatewithRight(K3->left); return singlerotatewithLeft(K3); } // 双旋转 - 右左情况 AvlTree doublerotatewithRight(AvlTree K3) { K3->right = singlerotatewithLeft(K3->right); return singlerotatewithRight(K3); } // 插入新元素到AVLAvlTree Insert(int x, AvlTree T) { if (T == NULL) { // 如果为空,创建新节点 T = (AvlTree)malloc(sizeof(struct AvlNode)); if (T == NULL) printf("Out of space!!!"); else { T->element = x; T->left = T->right = NULL; T->height = 0; // 新叶节点高度为0 } } else if (x < T->element) { // 向左子插入 T->left = Insert(x, T->left); // 检查并修复平衡 if (Height(T->left) - Height(T->right) == 2) { if (x < T->left->element) T = singlerotatewithLeft(T); // 左左旋转 else T = doublerotatewithLeft(T); // 左右旋转 } } else if (x > T->element) { // 向右子插入 T->right = Insert(x, T->right); // 检查并修复平衡 if (Height(T->right) - Height(T->left) == 2) { if (x > T->right->element) T = singlerotatewithRight(T); // 右右旋转 else T = doublerotatewithRight(T); // 右左旋转 } } // 更新高度 T->height = max(Height(T->left), Height(T->right)) + 1; return T; } ``` 上述代码提供了AVL的基本框架,包括节点定义、插入操作及必要的旋转方法。实际应用中可能还需要添加更多的功能,如删除节点、查找特定值等。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值