平衡二叉排序树之AVL树(C语言实现)

平衡二叉排序树之 A V L AVL AVL树(C语言实现)

A V L AVL AVL树性质

A V L AVL AVL树就是为了解决二叉排序树查找性能退化的问题

A V L AVL AVL树本质上也是二叉排序树,所以具备二叉排序树的所有性质

A V L AVL AVL树的学习重点,在于平衡条件以及平衡调整的相关学习

性质:
∣   H ( l e f t )   −   H ( r i g h t )   ∣   < =   1 |\ H(left)\ - \ H(right)\ | \ <= \ 1  H(left)  H(right)  <= 1
左子树和右子树的高度差,不超过1

优点:由于对每个节点的左右子树的树高做了限制,所以整棵树不会退化成一个链表

A V L AVL AVL树,改进的不是上限,而是下限

调整失衡操作

A V L AVL AVL树的插入和删除操作其实和二叉排序树的插入和删除操作是一样的,但是插入或删除节点以后可能破坏 A V L AVL AVL树的平衡条件,一旦破坏了平衡条件, A V L AVL AVL树就要触发平衡调整操作

接下来,就给大家介绍两种调整操作

A V L AVL AVL树——左旋:

pCBID8U.png

我们将 K1 作为旋转中心,当我们将 K1 向左旋转的时候,K1 下去了,K3 就上去了,作为左旋以后的根节点,此时 K1 就成为了 K3 的左孩子,可 K3 原来就有左子树,那么 K3 原来的左子树要去哪?K3 的左子树的值,是一定小于 K3 但是大于 K1 ,所以我们可以将 K3 的左子树作为 K1 的右子树

左旋后:

pCBIoxe.png

A V L AVL AVL树——右旋:

pCBII2D.png

与左旋相同,我们将 K1 作为旋转中心,将 K1 向右旋转,K1 向下,变成 K2 的右子树,K2 向上,K2 原来的右子树,变成 K1 的左子树。右旋和左旋是对称的

右旋后:

pCBI58O.png

左旋和右旋,本质上影响的是调整树高

失衡类型

A V L AVL AVL树一共有四种失衡类型

LL型:
pCBI4PK.png
LR型:
pCBIf56.png

RL型:
pCBIHrd.png
RR型:
pCBIbqA.png

K1 节点,是我们回溯过程中,遇到的第一个失衡的节点

LL型:左子树的左子树要更高

LR型:左子树的右子树要更高

RL型:右子树的左子树要更高

RR型:右子树的右子树要更高

失衡类型的调整

A V L AVL AVL树——LL型

pCBILVI.png

假设此时 A 的高度为h1B 的高度为 h2C 的高度为 h3D 的高度为 h4, 那么此时 h1 , h2 , h3 , h4 之间的关系是怎么样的?

既然是LL型失衡,K1 作为失衡节点,说明 K2 的高度要比 K3 的高度多2,K2 的高度为 h1 + 1,K3 的高度为 max( h3 , h4 ) + 1,所以可得以下等式
h 1 = m a x ( h 3 ,   h 4 ) + 2 = h 2 + 1 h1 = max(h3,\ h4) + 2 = h2 + 1 h1=max(h3, h4)+2=h2+1
当在 A V L AVL AVL树发生LL型失衡,就一定会有以上等式。只需对失衡节点进行一次大右旋即可;那么对于RR类型,就是对失衡节点进行一次大左旋即可。

pCBIOat.png

A V L AVL AVL树——LR类型

pCBIXIP.png

同样,假设此时 A 的高度为h1B 的高度为 h2C 的高度为 h3D 的高度为 h4, 那么此时 h1 , h2 , h3 , h4 之间的关系是怎么样的?

既然是LR型失衡,那么 K2 的高度应该比 K3 大1,K3 的高度又是 max( h2 , h3 ) + 1,K2 的高度又比 h4 高2,K3h1 高1,所以可得以下等式
m a x ( h 2 ,   h 3 ) = h 4 = h 1 max(h2,\ h3) = h4 = h1 max(h2, h3)=h4=h1
当发生LR型失衡,则一定有以上等式。先抓住失衡节点的左子树(K2)进行一次小左旋,左旋之后就变成了LL类型的失衡,最后再抓着 K1 进行大右旋即可;RL型失衡,就是对失衡节点的右子树进行小右旋,再对失衡节点进行大左旋

C语言代码实现 A V L AVL AVL

  1. 插入和删除后,注意重新计算树高字段
  2. 引入NIL节点,代替NULL,NULL不可访问,NIL是一个实际节点,可以访问
#include <stdio.h>
#include <stdlib.h>
#define L(n) (n->l)
#define R(n) (n->r)
#define H(n) (n->h)

typedef struct Node {
    int key, h;
    struct Node *l, *r;
} Node;

//__attribute__((constructor)):让该函数在main函数之前执行, NIL:虚拟空节点NIL,让访问假的空节点的操作是合法的
Node __NIL;
#define NIL (&__NIL)
__attribute__((constructor))
void init_NIL() {
    NIL->key = 0, NIL->h = 0;
    NIL->l = NIL->r = NIL;
    return ;
}

Node *getNewNode(int val) {
    Node *p = (Node *)malloc(sizeof(Node));
    p->key = val;
    p->h = 1;
    p->l = p->r = NIL;
    return p;
}

//树高维护
void update_height(Node *root) {
    root->h = (H(L(root)) > H(R(root)) ? H(L(root)) : H(R(root))) + 1;
    return ;
}

//左旋
Node *left_rotate(Node *root) {
    Node *new_root = root->r;
    root->r = new_root->l;
    new_root->l = root;
    update_height(root);
    update_height(new_root);
    return new_root;
}

//右旋
Node *right_rotate(Node *root) {
    Node *new_root = root->l;
    root->l = new_root->r;
    new_root->r = root;
    update_height(root);
    update_height(new_root);
    return new_root;
}

//销毁树
void clear(Node* root) {
    if (root == NIL) return ;
    clear(root->l);
    clear(root->r);
    free(root);
    return ;
}

//失衡调整
Node *maintain(Node *root) {
    //如果左右子树高度差不超过1,则未失衡,不用调整
    if (abs(H(L(root)) - H(R(root))) <= 1) return root;
    //如果是左子树发生了失衡
    if (root->l->h > root->r->h) {
        //如果是左子树的右子树发生了失衡,则是LR型,否则是LL型
        if (root->l->l->h < root->l->r->h) {
            root->l = left_rotate(root->l);
        }
        root = right_rotate(root);
    } else { //如果是右子树发生了失衡
        //如果是右子树的左子树发生失衡,则是RL型,否则是RR型
         if (root->r->r->h < root->r->l->h) {
            root->r = right_rotate(root->r);
        }
        root = left_rotate(root);
    }
    return root;
}

//插入操作
Node *insert(Node *root, int val) {
    if (root == NIL) return getNewNode(val);
    if (root->key == val) return root;
    if (root->key > val) root->l = insert(root->l, val);
    else root->r = insert(root->r, val);
    //维护树高
    update_height(root);
    //对在回溯的时候碰到的第一个失衡节点进行失衡调整
    return maintain(root);
}

//删除操作
Node *erase(Node *root, int val) {
    if (root == NIL) return root;
    if (root->key < val) root->r = erase(root->r, val);
    else if (root->key > val) root->l = erase(root->l, val);
    else {
        if (root->l == NIL || root->r == NIL) {
            Node *temp = root->l != NIL ? root->l : root->r;
            free(root);
            return temp;
        } else {
            Node *temp = root->l;
            while (temp->r != NIL) temp = temp->r;
            root->key = temp->key;
            root->l = erase(root->l, temp->key);
        }
    }
    //维护树高
    update_height(root);
    //对在回溯的时候碰到的第一个失衡节点进行失衡调整
    return maintain(root);
}

void print_node(Node *root) {
    printf("[ %d(%d) | %d, %d]\n",
        root->key, root->h,
        root->l->key,
        root->r->key
    );
    return ;
}

void output(Node *root) {
    if (root == NIL) return ;
    print_node(root);
    output(root->l);
    output(root->r);
    return ;
}

int main() {
    Node *root = NIL;
    int val, op;
    printf("输入形式: op   val\nop == 1代表插入,op == 0代表删除,op == -1结束\n");
    while (~scanf("%d%d", &op, &val)) {
        if (op == -1) break;
        switch(op) {
            case 0: {
                root = erase(root, val);
                printf("erase %d from AVL Tree\n", val);
            } break;
            case 1: {
                root = insert(root, val);
                printf("insert %d to AVL Tree\n", val);
            } break;
        }
        output(root);
        printf("\n");
    }

    clear(root);
    return 0;
}
  • 4
    点赞
  • 8
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
以下是一个简单的AVL树的Python实现代码示例: ```python # 定义AVL树节点类 class AVLNode: def __init__(self, key): self.key = key self.left = None self.right = None self.height = 1 # AVL树类 class AVLTree: def __init__(self): self.root = None # 获取节点的高度 def get_height(self, node): if node is None: return 0 return node.height # 获取节点的平衡因子 def get_balance(self, node): if node is None: return 0 return self.get_height(node.left) - self.get_height(node.right) # 更新节点的高度 def update_height(self, node): if node is None: return node.height = max(self.get_height(node.left), self.get_height(node.right)) + 1 # 执行左旋转操作 def left_rotate(self, z): y = z.right T2 = y.left y.left = z z.right = T2 self.update_height(z) self.update_height(y) return y # 执行右旋转操作 def right_rotate(self, z): y = z.left T3 = y.right y.right = z z.left = T3 self.update_height(z) self.update_height(y) return y # 插入节点 def insert(self, key): self.root = self._insert(self.root, key) def _insert(self, root, key): if root is None: return AVLNode(key) elif key < root.key: root.left = self._insert(root.left, key) else: root.right = self._insert(root.right, key) self.update_height(root) balance = self.get_balance(root) # 左旋 if balance > 1 and key < root.left.key: return self.right_rotate(root) # 右旋 if balance < -1 and key > root.right.key: return self.left_rotate(root) # 左右旋 if balance > 1 and key > root.left.key: root.left = self.left_rotate(root.left) return self.right_rotate(root) # 右左旋 if balance < -1 and key < root.right.key: root.right = self.right_rotate(root.right) return self.left_rotate(root) return root # 中序遍历 def inorder_traversal(self): self._inorder_traversal(self.root) def _inorder_traversal(self, root): if root: self._inorder_traversal(root.left) print(root.key, end=" ") self._inorder_traversal(root.right) ``` 这只是一个简单的AVL树实现,还可以根据需要进一步完善和扩展。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值