AVL树实现

AVL 树，相当于在二叉搜索树(BST)中再增加一个平衡因子的变量，用来存储当前结点左右子树高度的差值

struct avl_node {
    struct avl_node *parent;
    struct avl_node *left;
    struct avl_node *right;
    int key;
    /* the same as bst_node on the above */

    int factor;                 /* left_height - right_height */
};


struct avl_root {
    struct avl_node *avl_node;
};

由AVL定义可见，其平衡因子只可能有三种值0，-1，1；在插入、删除时，结点的平衡因子可能会变化成2、-2，称此结点为不平衡结点，这时就需要对AVL 树的进行调整。

AVL 树的平衡调整

AVL不平衡结点最多有四种可能，见下图：

称之为LL，LR，RL，RR，对于LL，RR，只需要一次旋转就行了，对于 LR和RL ，需要多做一次旋转

static struct avl_node* avl_balance(struct avl_node *y, struct avl_root *root)
{
    struct avl_node *x, *w;

    if (y->factor == 2) {      /* left is high */
        x = y->left;
        if (x->factor == 1) {  /* LL */
            bst_rotate_right((struct bst_node *)y, (struct bst_node **)&root->avl_node);
            x->factor = y->factor = 0;
            return x;
        }
        else if (x->factor == -1) { /* LR */
            w = x->right;
            bst_rotate_left((struct bst_node *)x, (struct bst_node **)&root->avl_node);
            bst_rotate_right((struct bst_node *)y, (struct bst_node **)&root->avl_node);
            if (w->factor == 0) 
                x->factor = y->factor = 0;
            else if (w->factor == -1)
                x->factor = 1, y->factor = 0;
            else
                x->factor = 0, y->factor = -1;
            w->factor = 0;
            return w;
        }
        else {                  /* factor == 0, only used for delete */
            bst_rotate_right((struct bst_node *)y, (struct bst_node **)&root->avl_node);
            x->factor = -1;
            y->factor = 1;
            return x;
        }
    }
    else {                      /* right is high, factor is -2 */
        x = y->right;
        if (x->factor == -1) {   /* RR */
            bst_rotate_left((struct bst_node *)y, (struct bst_node **)&root->avl_node);
            x->factor = y->factor = 0;
            return x;
        }
        else if (x->factor == 1) { /* RL */
            w = x->left;
            bst_rotate_right((struct bst_node *)x, (struct bst_node **)&root->avl_node);
            bst_rotate_left((struct bst_node *)y, (struct bst_node **)&root->avl_node);
            if (w->factor == 0)
                x->factor = y->factor = 0;
            else if (w->factor == 1)
                x->factor = -1, y->factor = 0;
            else
                x->factor = 0, y->factor = 1;
            w->factor = 0;
            return w;
        }
        else {                 /* factor == 0, only used for delete */
            bst_rotate_left((struct bst_node *)y, (struct bst_node **)&root->avl_node);
            x->factor = 1;
            y->factor = -1;
            return x;
        }
    }
    return 0;
}

此函数为AVL平衡调整函数，为理解AVL树的精髓。它分成了两大段，一段处理平衡因子为2，一段处理平衡因子为-2，以下详细描述平衡因子为2的情况：

有三种情况需要处理：(父结点y，左子结点x，孙结点w，请参考“二叉搜索树的旋转”)

(1) 左结点平衡因子为1，即LL形式，直接一次右旋就可以了，注意此时结点y、x平衡因子均为0

(2) 左结点平衡因子为-1，即LR形式，先左旋，将结点w转上去，然后再右旋，使得w取代y成为当前子树的根结点，这时需要根据原有w的平衡因子来更新y x w的平衡因子

(3) 左结点平衡因子为0，只要有删除时才会出现这种情况，直接右旋，然后更新平衡因子

AVL 树的插入

void avl_insert(struct avl_node *node, struct avl_root *root)
{
    struct avl_node *p = root->avl_node, *parent = NULL;

    /* find which position to be inserted and find the first un balance */
    while (p) {
        parent = p;
        if (node->key < p->key)
            p = p->left;
        else
            p = p->right;
    }

    node->parent = parent;
    if (parent == NULL) {
        root->avl_node = node;
    }
    else {
        if (node->key < parent->key)
            parent->left = node;
        else 
            parent->right = node;
    }

    /* adjust balance factor, may be using rotations */
    for (p = node;parent;) {
        if (parent->left == p)
            parent->factor++;
        else 
            parent->factor--;
        
        if (parent->factor == 0)
            break;
        else if (parent->factor == -2 || parent->factor == 2) {
            avl_balance(parent, root);
            break;
        }
        p = parent;
        parent = parent->parent;
    }
}

AVL 插入时，首先类似BST的插入，然后从插入结点往上回溯，更新祖先结点的平衡因子，如果某祖先的平衡因子更新后为0，说明从此结点往上平衡因子均不需要改变，则调整结束。否则找到第一个不平衡结点对其调整，当这个结点调整完后，AVL树必定重新平衡，可以看到AVL 树的插入最多需要一次平衡调整，最多两次旋转

AVL 树的删除

static void avl_del_balance(int dir, struct avl_node *parent, struct avl_root *root)
{
    struct avl_node *node;

    if (dir == 1) {
        parent->factor++;
        if (parent->factor == 2)
            parent = avl_balance(parent, root);
    }
    else {
        parent->factor--;
        if (parent->factor == -2)
            parent = avl_balance(parent, root);
    }
    if (parent->factor != 0)
        return;
    node = parent;
    parent = parent->parent;
        
    while (parent) {
        if (parent->right == node) {
            parent->factor++;
            if (parent->factor == 2) 
                parent = avl_balance(parent, root);
        }
        else {
            parent->factor--;
            if (parent->factor == -2)
                parent = avl_balance(parent, root);
        }
        if (parent->factor != 0)
            break;
        node = parent;
        parent = parent->parent;
    }
}


void avl_delete(struct avl_node *node, struct avl_root *root)
{
    int dir = 0;                /* 0 means left, 1 means right */
    struct avl_node *child, *parent;

    if (node->left == NULL)
        child = node->right;
    else if (node->right == NULL)
        child = node->left;
    else {        /* use successor instead of node */
        struct avl_node *old = node, *left;

        node = node->right;
        while ((left = node->left) != NULL)
            node = left;
        child = node->right;
        parent = node->parent;

        if (child)
            child->parent = parent;

        if (old == parent) {/* successor is just the right child of node */
            parent->right = child;
            dir = 1;
            parent = node;
        }
        else
            parent->left = child;

        /* update successor as old node */
        node->parent = old->parent;
        node->factor = old->factor;        
        node->right = old->right;
        node->left = old->left;
        if (old->parent) {
            if (old->parent->left == old)
                old->parent->left = node;
            else
                old->parent->right = node;
        }
        else
            root->avl_node = node;

        old->left->parent = node;
        if (old->right)
            old->right->parent = node;

        goto balance;
    }

    /* only used for node is at most one degree node. */
    parent = node->parent;
    if (child)
        child->parent = parent;
    if (parent) {
        if (parent->left == node)
            parent->left = child;
        else {
            dir = 1;
            parent->right = child;
        }
    }
    else
        root->avl_node = child;

balance:
    if (parent)
        avl_del_balance(dir, parent, root);
}

删除相对复杂，首先是BST的删除，然后再从删除结点的父结点往上回溯并更新平衡因子，如果发现某祖先结点变为不平衡结点，则进行平衡调整。如果某祖先结点的平衡因子不为0，则调整结束，注意删除、插入的平衡调整函数相同，均为avl_balance。可以看到删除最多需要调整logn次，即最多有logn * 2的旋转操作。

在使用随机数进行测试时，AVL 树的删除相比红黑树要慢10%-20%，但其插入操作仅比红黑树慢5%以内