平衡二叉树--AVL 的原理及实现

最新推荐文章于 2024-08-06 23:23:19 发布
最新推荐文章于 2024-08-06 23:23:19 发布
阅读量3.7k 收藏 147
点赞数 40
分类专栏： 数据结构 文章标签： 平衡二叉树 AVL 树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/alzzw/article/details/97613193
版权

 

 

平衡二叉树

  1. 前言：

        对于平衡二叉树，其实是二叉搜索树的进阶版；

  • 即平衡二叉树一定是二叉搜索树
  • 每个节点的左子树和右子树的高度差的绝对值至多为1

 

       对于普通的二叉搜索树（7，3，10，12，5，1，9），其树为：

                                                               

但是如果我们的数据是这样的（1，2，3，4，5，6），那树的样子为：

                                                            

如果是这样，我们查找数字6的效率就大大降低，那有什么方法能解决呢？

那就是平衡二叉树：

2.概述：

  •  在二叉搜索树的特点的基础上,平衡二叉树还要求对于任意节点X,X的左、右子树的深度相差最大不能超过1。如果某种操作（一般是插入和删除操作）破坏了这种平衡性，就要对树中不平衡的结点进行“旋转”来修复平衡性。

  • 本平衡二叉搜索树的实现和之前的二叉搜索树实现很类似，都是包含了自定义的比较器。它们实现的不同点主要体现在平衡二叉搜索树的插入和删除操作要相对复杂一点，因为在元素插入或删除后，如果树的平衡性被破坏了还要进行平衡性的修复。因为实现中需要频繁的计算左子树和右子树的高度差，所以我们在树中的节点里维护了一个表示当前结点的高度的变量。

  • 来看这棵树：

                                                                       

                                                                                             图1

            数字9这棵树的左子树的高度为2，没有右子树，所以差的绝对值为2，可知整个5这棵树不是一棵平衡二叉树；

 

  • 再来看这棵树：

                                                               

                                                                                            图2

             这棵树把7旋转到9的位置，然后把整棵树变成了平衡二叉树；

3.概念：

  • 平衡因子：将二叉树上节点的左子树高度减去右子树高度的值称为该节点的平衡因子BF(Balance Factor)。
  • 平衡二叉树就是一棵二叉树上所有节点的平衡因子的绝对值小于1的树

以图2为例：

  •     节点5的左子树高度为3，右子树高度为3，BF= 3-3 = 0；
  •     节点3的左子树高度为2，右子树高度为1，BF= 2-1 = 1；
  •     节点1的左子树高度为0，右子树高度为1，BF= 0-1 = -1；
  •     节点4的左子树高度为0，右子树高度为0，BF= 0-1 = 0；
  •     以此类推

最小不平衡子树：距离插入节点最近的，且平衡因子的绝对值大于1的节点为根的子树.

 

首先我们先讲解一下平衡调整规则：       

1.LL型调整：

由于在A的左孩子(L)的左子树(L)上插入新结点，使原来平衡二叉树变得不平衡，此时A的平衡因子由1增至2。下面图1是LL型的最简单形式。显然，按照大小关系，结点B应作为新的根结点，其余两个节点分别作为左右孩子节点才能平衡，A结点就好像是绕结点B顺时针旋转一样。

 

LL型调整的一般形式如下图2所示，表示在A的左孩子B的左子树BL(不一定为空)中插入结点(图中阴影部分所示)而导致不平衡( h 表示子树的深度)。这种情况调整如下：①将A的左孩子B提升为新的根结点；②将原来的根结点A降为B的右孩子；③各子树按大小关系连接(BL和AR不变，BR调整为A的左子树)。

                                     

代码实现：

BTNode *ll_rotate(BTNode *y)
{
    BTNode *x = y->left;
    y->left = x->right;
    x->right = y;   
 
    y->height = max(height(y->left), height(y->right)) + 1;
    x->height = max(height(x->left), height(x->right)) + 1;
 
    return x;
}


 
2. RR型调整：

由于在A的右孩子(R)的右子树(R)上插入新结点，使原来平衡二叉树变得不平衡，此时A的平衡因子由-1变为-2。图3是RR型的最简单形式。显然，按照大小关系，结点B应作为新的根结点，其余两个节点分别作为左右孩子节点才能平衡，A结点就好像是绕结点B逆时针旋转一样。

 

RR型调整的一般形式如下图4所示，表示在A的右孩子B的右子树BR(不一定为空)中插入结点(图中阴影部分所示)而导致不平衡( h 表示子树的深度)。这种情况调整如下：

将A的右孩子B提升为新的根结点；
将原来的根结点A降为B的左孩子
各子树按大小关系连接(AL和BR不变，BL调整为A的右子树)。


                                                                     图4  一般形式的RR型调整

代码实现：

BTNode *rr_rotate(struct Node *y)
{
    BTNode *x = y->right;
    y->right = x->left;
    x->left = y;
    
 
    y->height = max(height(y->left), height(y->right)) + 1;
    x->height = max(height(x->left), height(x->right)) + 1;
 
    return x;
}


 
3. LR型调整：

由于在A的左孩子(L)的右子树(R)上插入新结点，使原来平衡二叉树变得不平衡，此时A的平衡因子由1变为2。图5是LR型的最简单形式。显然，按照大小关系，结点C应作为新的根结点，其余两个节点分别作为左右孩子节点才能平衡。

                                                          

LR型调整的一般形式如下图6所示，表示在A的左孩子B的右子树(根结点为C，不一定为空)中插入结点(图中两个阴影部分之一)而导致不平衡( h 表示子树的深度)。这种情况调整如下：①将B的右孩子C提升为新的根结点；②将原来的根结点A降为C的右孩子；③各子树按大小关系连接(BL和AR不变，CL和CR分别调整为B的右子树和A的左子树)。

                                                                      图6  一般形式的LR型调整

3.1 代码实现：

BTNode* lr_rotate(BTNode* y)
{
    BTNode* x = y->left;
    y->left = rr_rotate(x);
    return ll_rotate(y);
}


4. RL型调整：

由于在A的右孩子(R)的左子树(L)上插入新结点，使原来平衡二叉树变得不平衡，此时A的平衡因子由-1变为-2。图7是RL型的最简单形式。显然，按照大小关系，结点C应作为新的根结点，其余两个节点分别作为左右孩子节点才能平衡。


                                                         图7  最简单的RL型调整

RL型调整的一般形式如下图8所示，表示在A的右孩子B的左子树(根结点为C，不一定为空)中插入结点(图中两个阴影部分之一)而导致不平衡( h 表示子树的深度)。这种情况调整如下：①将B的左孩子C提升为新的根结点；②将原来的根结点A降为C的左孩子；③各子树按大小关系连接(AL和BR不变，CL和CR分别调整为A的右子树和B的左子树)。


                                                                             图8  一般形式的RL型调整

4.1 代码实现

Node* rl_rotate(Node* y)
{
    Node * x = y->right;
    y->right = ll_rotate(x);
    return rr_rotate(y);
}

                                              

4.实现：

通过平衡二叉树的性质创建，而不是创建普通的二叉排序树

如果给定一个数组     arr[3，2，1，4，5，6，7，10，9，8]

二叉排序树：                                                                                        平衡二叉树：

                                                                        

创建过程：

                    旋转后->                

  • 3->2->1,当进行到1之后，可以看出节点3的左子树高度为2，右子树高度为0，BF为2-0=0；所以要进行LL旋转
  • 旋转后->
  • 当到节点5的时候右边不平衡了，此时要进行RR调整

                                                

  • 当插入到6的时候又不平衡了，对于节点2的BF=2，所以进行RR调整：但是你会发现出现中间图的样子，这时应该对节点3进行抛弃，事实上一棵树右子树最左边的节点可以放在这棵树左子树最右边的位置，就有了第三张图的样子；
  •                  旋转->
  • 插入7，不平衡，进行RR调整，

 旋转后->         

  • 插入10和9后不平衡，节点7进行RL调整

        

  • 此时最后一个节点8插入，最小不平衡子树为6

         旋转后->      

 

这样我们的平衡二叉树就构建完了；

树与二叉树：https://blog.csdn.net/alzzw/article/details/97283324

线索二叉树：https://blog.csdn.net/alzzw/article/details/97423394
哈夫曼树：https://blog.csdn.net/alzzw/article/details/97809047

二叉搜索（排序）树；https://blog.csdn.net/alzzw/article/details/97563011
B树~B+树：https://blog.csdn.net/alzzw/article/details/97633941
红黑树：https://blog.csdn.net/alzzw/article/details/97770753

下面是完整的代码实现：包括（插入，删除及遍历）

#include<stdio.h>
#include<stdlib.h>
 
typedef struct Node
{
    int key;
    struct Node *left;
    struct Node *right;
    int height;
}BTNode;
 
int max(int a, int b);
 
 
int height(struct Node *N)
{
    if (N == NULL)
        return 0;
    return N->height;
}
 
int max(int a, int b)
{
    return (a > b) ? a : b;
}
 
BTNode* newNode(int key)
{
    struct Node* node = (BTNode*)malloc(sizeof(struct Node));
    node->key = key;
    node->left = NULL;
    node->right = NULL;
    node->height = 1;
    return(node);
}
 
BTNode* ll_rotate(BTNode* y)
{
    BTNode *x = y->left;
    y->left = x->right;
    x->right = y;
 
    y->height = max(height(y->left), height(y->right)) + 1;
    x->height = max(height(x->left), height(x->right)) + 1;
 
    return x;
}
 
BTNode* rr_rotate(BTNode* y)
{
    BTNode *x = y->right;
    y->right = x->left;
    x->left = y;
 
    y->height = max(height(y->left), height(y->right)) + 1;
    x->height = max(height(x->left), height(x->right)) + 1;
 
    return x;
}
 
int getBalance(BTNode* N)
{
    if (N == NULL)
        return 0;
    return height(N->left) - height(N->right);
}
 
BTNode* insert(BTNode* node, int key)
{
 
    if (node == NULL)
        return newNode(key);
 
    if (key < node->key)
        node->left = insert(node->left, key);
    else if (key > node->key)
        node->right = insert(node->right, key);
    else
        return node;
 
    node->height = 1 + max(height(node->left), height(node->right));
 
 
    int balance = getBalance(node);
 
 
 
    if (balance > 1 && key < node->left->key) //LL型
        return ll_rotate(node);
 
 
    if (balance < -1 && key > node->right->key)     //RR型
        return rr_rotate(node);
 
 
    if (balance > 1 && key > node->left->key)     //LR型
    {
        node->left = rr_rotate(node->left);
        return ll_rotate(node);
    }
 
    if (balance < -1 && key < node->right->key)     //RL型
    {
        node->right = ll_rotate(node->right);
        return rr_rotate(node);
    }
 
    return node;
}
 
 
BTNode * minValueNode(BTNode* node)
{
    BTNode* current = node;
 
    while (current->left != NULL)
        current = current->left;
 
    return current;
}
 
BTNode* deleteNode(BTNode* root, int key)
{
 
    if (root == NULL)
        return root;
 
    if (key < root->key)
        root->left = deleteNode(root->left, key);
 
    else if (key > root->key)
        root->right = deleteNode(root->right, key);
 
    else
    {
        if ((root->left == NULL) || (root->right == NULL))
        {
            BTNode* temp = root->left ? root->left : root->right;
 
            if (temp == NULL)
            {
                temp = root;
                root = NULL;
            }
            else
                *root = *temp;
            free(temp);
        }
        else
        {
            BTNode* temp = minValueNode(root->right);
 
            root->key = temp->key;
 
            root->right = deleteNode(root->right, temp->key);
        }
    }
 
 
    if (root == NULL)
        return root;
 
    root->height = 1 + max(height(root->left), height(root->right));
 
    int balance = getBalance(root);
 
 
    if (balance > 1 && getBalance(root->left) >= 0) //LL型
        return ll_rotate(root);
 
 
    if (balance > 1 && getBalance(root->left) < 0) //LR型
    {
        root->left = rr_rotate(root->left);
        return ll_rotate(root);
    }
 
    if (balance < -1 && getBalance(root->right) <= 0) //RR型
        return rr_rotate(root);
 
    if (balance < -1 && getBalance(root->right) > 0)  //Rl型
    {
        root->right = ll_rotate(root->right);
        return rr_rotate(root);
    }
 
    return root;
}
 
 
void preOrder(struct Node *root)
{
    if (root != NULL)
    {
        printf("%d ", root->key);
        preOrder(root->left);
        preOrder(root->right);
    }
}
 
int main()
{
    BTNode *root = NULL;
 
    root = insert(root, 9);
    root = insert(root, 5);
    root = insert(root, 10);
    root = insert(root, 0);
    root = insert(root, 6);
    root = insert(root, 11);
    root = insert(root, -1);
    root = insert(root, 1);
    root = insert(root, 2);
    printf("前序遍历：\n");
    preOrder(root);
 
    /* The constructed AVL Tree would be
                     9
                    /  \
                   1    10
                 /  \     \
                0    5     11
               /    /  \
              -1   2    6
    */
    
    root = deleteNode(root, 10);
    /* The AVL Tree after deletion of 10
                       1
                     /   \
                    0     9
                  /     /  \
                -1     5     11
                     /  \
                    2    6
    */
    printf("\n");
    printf("前序遍历：\n");
    preOrder(root);
    return 0;
}

 

参考： 

https://blog.csdn.net/isunbin/article/details/81707606

阿尔兹
关注
专栏目录
AVL平衡二叉树
蚂蚁的博客
08-11 1687
平衡二叉树定义 AVL树也就是所谓的平衡二叉树，查找、删除、插入最坏情况下为O(log n)，维持树的平衡只需要几次旋转即可。保证任意一个节点的左子树高度与右子树高度相差不大于1，默认树为空时高度为0。 节点结构 为了后续操作简洁性，先给出节点结构 final class node{ int value=0;//键值 int height=1;//节点高度 node left=nul
平衡二叉树实现
06-30
使用C++模板类实现的平衡二叉树
平衡二叉树的实现原理
a639735331的博客
03-28 837
更多免费学习视频请访问www.java123.wang 友情链接博主 B站主页 1.概念 平衡二叉树建立在二叉排序树的基础上，目的是使二叉排序树的平均查找长度更小，即让各结点的深度尽可能小。平衡二叉树定义：平衡二叉树是一棵二叉树，其可以为空，或满足如下2个性质：①左右子树深度之差的绝对值不大于1。②左右子树都是平衡二叉树。平衡因子的概念：结点的平衡因子 = 结点的左子树深度 — 结点的右子树...
【平衡二叉树】数据结构—平衡二叉树
最新发布
qq_64108165的博客
08-06 792
【数据结构】平衡二叉树
关于平衡二叉树的原理
foreverbright的博客
12-17 380
平衡二叉排序树是 1、左子树与右子树的高度之差的绝对值小于等于1 2、左子树和右子树也是平衡二叉排序树 那么如何维持一棵平衡二叉排序树呢？原理又是什么呢？ LL型平衡二叉排序树的证明， LR, RR,RL与之同理 设 Bh 为二叉树左子树高， Ar 为A右子树高，BL为B的左子树，BR为B的右子树S为新加的节点 Bh - Ar = 2 Bh = Bl + 1(B) + 1(S) Bl...
广工数据结构课程设计大作业-平衡二叉树-Java实现（数据结构期末）
11-13
这个大作业旨在让学生深入理解数据结构中的平衡二叉树原理，并能用Java这一常用编程语言实现相关算法。通过这个过程，学生不仅可以提升编程能力，还能掌握解决实际问题的方法，为今后的软件开发工作打下坚实基础。
二叉树-基于C++实现的平衡二叉树.zip
04-26
本压缩包文件“二叉树-基于C++实现的平衡二叉树.zip”包含了一个关于使用C++编程语言实现平衡二叉树的实例，这对于我们理解平衡二叉树的原理和实际操作至关重要。 平衡二叉树（Balanced Binary Tree）是一种特殊的...
java-平衡二叉树AVL的实现
04-23
在Java编程领域，平衡二叉树（特别是AVL树）是一种高效的数据结构，它通过保持树的高度平衡来确保查找、插入和删除操作的最优化。AVL树是最早被提出的自平衡二叉搜索树，由G. M. Adelson-Velsky和E. M. Landis于1962...
平衡二叉树（纯C++实现）
03-04
包含AVL树的创建，删除，查找等等功能，我使用的是VS2010的编译器，可能用版本低的编译器无法打开
平衡二叉树-AVL树的实现
12-10
平衡二叉树是一种特殊的二叉树结构，其中每个节点的两个子树的高度差不超过1，以确保树的平衡，从而优化查找、插入和删除等操作的时间复杂度。AVL树是最早被提出的自平衡二叉搜索树，由G. M. Adelson-Velsky和E. M. ...
python-leetcode面试题解之第110题平衡二叉树-题解.zip
04-29
常见的平衡二叉树类型有AVL树和红黑树等。 第110题的描述是检查给定的二叉树是否为平衡二叉树。要解决这个问题，我们可以采用递归的方法，对每个节点进行深度优先搜索（DFS）或广度优先搜索（BFS）。对于DFS，我们...
Java广联达元素平衡_数据结构—平衡二叉树(AVL树)的原理以及Java代码的完全实现...
weixin_34737524的博客
02-24 221
平衡二叉树(AVL树)，顾名思义，是一颗很“平衡”的树，它的平衡是相对于排序二叉树来说的。为了避免极端情况下二叉搜索树节点分布不均匀，甚至退化为链表，影响查找效率，我们引入了平衡二叉树，即让树的结构看起来尽量“均匀”，左右子树的节点数和层级尽量一样多。本文详细介绍了平衡二叉树的概念和实现原理，并且提供了Java代码的完全实现。文章目录1 平衡二叉树的概述2 平衡二叉树的实现原理2.1 单旋转2.2...
平衡二叉树（AVL）--查找、删除、插入（Java实现）
weixin_34244102的博客
05-08 278
前言 前面一篇文章，笔者就二叉查找树进行了一些解释与实现，这篇文章笔者将会就平衡二叉树 做一些总结与实现。读者若不了解二叉查找树的话，可以参考这篇文章： http://blog.csdn.net/kiritor/article/...
平衡二叉树(AVL树)原理
雾林小妖的博客
12-28 464
平衡二叉树(AVL树)原理
评论 7
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

阿尔兹

如果觉得有用就推荐给你的朋友吧

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值