平衡二叉树（AVL）的实现，附可运行C语言代码

最新推荐文章于 2024-08-05 09:07:05 发布
最新推荐文章于 2024-08-05 09:07:05 发布
阅读量1.3k 收藏 5
点赞数
分类专栏： 数据结构 文章标签： 数据结构 二叉树 c语言

转自：http://www.cnblogs.com/liuliuliu/p/3941748.html

最近几月一直在自学C语言和数据结构，先是写了排序二叉树，觉得平衡二叉树作为一个经典数据结构，有必要实现一下。

网上看了些资料，在AVL和红黑树之间考虑，最后个人还是倾向于AVL。

不同于标准AVL的是，笔者没有使用平衡因子，直接根据左右孩子的高度差值判断是否平衡。整个平衡二叉树是在普通二叉查找树的基础上修改得到的，对于学习数据结构的同学来说，这样逐步提高难度，写起来挑战性没那么大。

代码经测试是可以运行，并实现插入、删除、修改节点时都可以保持平衡。相对于普通二叉查找树，AVL在查找时效率高耗时短，但为了保持高度平衡，必须牺牲插入和删除操作的复杂度。本文将分步讲解如何编写平衡二叉树，全文最后附有完整代码。

当左右子树的高度差超过1时（即≥2，在实际处理时，等于2即为不平衡，进行调整操作，所以不会出现大于2的情况），整棵树失去平衡。写代码之前先了解AVL是如何使二叉树保持平衡，这里涉及到对节点的旋转操作，分四种情况，左左，右右，左右，右左。下面分别解释：

一、左左单旋转

在节点x的左孩子插入节点b

①x无右孩子，旋转节点a即可达到平衡

②x有右孩子c，旋转节点a后，根据a>c>x，需将节点c移动到a的左子树

函数代码如下：

复制代码 
 1 static BTNode *singleRotateLL(BTree *BT, BTNode *phead)
 2 {//不平衡情况为左左的单旋转操作
 3     BTNode *temp;
 4 
 5     if(phead == NULL)
 6         return 0;
 7 
 8     temp = phead->lchild;
 9     
10     if(temp->rchild != NULL){
11         phead->lchild = temp->rchild;
12         phead->lchild->height = tree_node_height(BT, phead->lchild);
13     }
14     else
15         phead->lchild = NULL;
16 
17     temp->rchild = phead;
18     if(temp->rchild->data == BT->phead->data){
19         BT->phead = temp;
20     }
21     phead = temp;
22     temp->rchild->height = tree_node_height(BT, temp->rchild);
23     temp->height = tree_node_height(BT, temp);
24     phead->height = tree_node_height(BT, phead);
25     
26     return phead;
27 }
复制代码

二、右右单旋转

在节点x的右孩子插入节点b

①x无左孩子，旋转节点a即可达到平衡

②x有左孩子c，旋转节点a后，根据x>c>a，需将节点c移动到a的右子树

函数代码如下：

复制代码 
 1 static BTNode *singleRotateRR(BTree *BT, BTNode *phead)
 2 {//不平衡情况为右右的单旋转操作
 3     BTNode *temp;
 4 
 5     if(phead == NULL)
 6         return 0;
 7 
 8     temp = phead->rchild;
 9 
10     if(temp->lchild != NULL){
11         phead->rchild = temp->lchild;
12         phead->rchild->height = tree_node_height(BT, phead->rchild);
13     }
14     else
15         phead->rchild = NULL;
16 
17     temp->lchild = phead;
18     if(temp->lchild->data == BT->phead->data){
19         BT->phead = temp;
20     }
21     phead = temp;
22     temp->lchild->height = tree_node_height(BT, temp->lchild);
23     temp->height = tree_node_height(BT, temp);
24     phead->height = tree_node_height(BT, phead);
25 
26     return phead;
27 }
复制代码

注：需要注意的是节点旋转后，节点赋值和高度的更新，初学者很容易忽略或是弄错赋值顺序

三、左右双旋转

在节点x的右孩子插入节点b

①x无左孩子，②x有左孩子c，这两种情况的处理相同，首先对x节点进行右右单旋转操作，然后对a节点进行左左单旋转操作

函数代码如下：

复制代码 
 1 static BTNode *doubleRotateLR(BTree *BT, BTNode *phead)
 2 {//不平衡情况为左右的双旋转操作
 3     BTNode *temp;
 4 
 5     if(phead == NULL)
 6         return 0;
 7 
 8     temp = phead->lchild;    
 9     phead->lchild = singleRotateRR(BT, temp);
10     temp = phead;
11     phead = singleRotateLL(BT, temp);
12 
13     return phead;
14 }
复制代码

四、右左双旋转

在节点x的右孩子插入节点b

①x无右孩子，②x有右孩子c，这两种情况的处理相同，首先对x节点进行左左单旋转操作，然后对a节点进行右右单旋转操作

函数代码如下：

复制代码 
 1 static BTNode *doubleRotateRL(BTree *BT, BTNode *phead)
 2 {//不平衡情况为右左的双旋转操作
 3     BTNode *temp;
 4 
 5     if(phead == NULL)
 6         return 0;
 7 
 8     temp = phead->rchild;
 9     phead->rchild = singleRotateLL(BT, temp);
10     temp = phead;
11     phead = singleRotateRR(BT, temp);
12 
13     return phead;
14 }
复制代码

 

弄清楚了怎样通过旋转达到平衡状态，接下来一步一步构造平衡二叉树。

第一步，我们要在二叉树的节点中加一个属性：高度，在后面的插入和删除函数中将会用到。

结构体代码如下：

1 typedef struct _BTNode{
2     TYPE data;
3     int height;         
4     struct _BTNode *lchild;
5     struct _BTNode *rchild;
6 }BTNode;

 

第二步，需要添加三个辅助函数，一是求节点的高度，而是遍历求树中每个节点的高度（在删除函数中会用到），三是求两个高度的最大值。

复制代码 
 1 static int tree_node_height(BTree *BT, BTNode *phead)
 2 {//求节点的高度，写成函数解决指针为空的情况，默认空节点的高度为-1，只有一个根节点的节点的高度为0，每多一层高度加1
 3     if(phead != NULL){
 4         if(phead->lchild == NULL && phead->rchild == NULL){
 5             return 0;
 6         }
 7         else{
 8             return phead->height = max_height(tree_node_height(BT, phead->lchild), tree_node_height(BT, phead->rchild)) + 1;
 9         }
10     }
11     else{
12         return -1;
13     }
14 }
15 
16 static void tree_height(BTree *BT, BTNode *phead)
17 {//遍历求树中每个节点的高度
18     if(phead == NULL)
19         return;
20 
21     tree_node_height(BT, phead);
22     if(phead->lchild != NULL)
23         tree_node_height(BT, phead->lchild);
24     if(phead->rchild != NULL)
25         tree_node_height(BT, phead->rchild);
26 }
27 
28 static int max_height(int height1, int height2)
29 {//求两个高度的最大值
30     if(height1 > height2)
31         return height1;
32     else
33         return height2;
34 }
复制代码

 第三步，插入

 插入操作与二叉查找树的操作基本相同，只是在插入后需判断是否平衡，如果不平衡，进行旋转调整。因为BTNode没有使用父节点属性，所以需要用变量存储插入位置，以便调整后可以接回到二叉树上。树顶的根节点需特殊处理

复制代码 
 1 static BOOL tree_add(BTree *BT, BTNode *phead, TYPE value)
 2 {//按序插入结点
 3     if(phead == NULL)
 4         return 0;
 5 
 6     if(phead->data == value)
 7         return 0;
 8 
 9     else{
10         if(phead->data > value){
11             if(phead->lchild == NULL){
12                 BTNode *newnode = (BTNode*)calloc(1, sizeof(BTNode));
13                 newnode->data = value;
14                 newnode->lchild = newnode->rchild = NULL;
15                 phead->lchild = newnode;
16             }
17             else{
18                 tree_add(BT, phead->lchild, value);
19 
20                 //判断插入节点后是否平衡，并调整
21                 BTNode *root;
22                 if(phead = BT->phead)
23                     root = phead;
24                 else
25                     root = phead->lchild;
26             
27                 if(tree_node_height(BT, root->lchild) - tree_node_height(BT, root->rchild) == 2){
28                     if(root->lchild->data > value){
29                         root = singleRotateLL(BT, root);
30                     }
31                     else{
32                         root = doubleRotateLR(BT, root);
33                     }
34                 }
35                 phead = root;
36             }
37         }
38         else{
39             if(phead->rchild == NULL){
40                 BTNode *newnode = (BTNode*)calloc(1, sizeof(BTNode));
41                 newnode->data = value;
42                 newnode->lchild = newnode->rchild = NULL;
43                 phead->rchild = newnode;                    
44             }
45             else{
46                 tree_add(BT, phead->rchild, value);
47                 
48                 //判断插入节点后是否平衡，并调整
49                 BTNode *root;
50                 if(phead = BT->phead)
51                     root = phead;
52                 else
53                     root = phead->rchild;
54                     
55                 if(tree_node_height(BT, root->rchild) - tree_node_height(BT, root->lchild) == 2){
56                     if(root->rchild->data < value){
57                         root = singleRotateRR(BT, root);
58                     }
59                     else{
60                         root = doubleRotateRL(BT, root);
61                     }
62                 }
63                 phead = root;
64             }            
65         }
66             phead->height = tree_node_height(BT, phead);
67             return 1;
68     }
69 
70     return 0;
71 }
复制代码

第四步，删除

平衡二叉树的删除操作比插入更复杂，因为删除后会引起一系列节点高度的改变，删除后将剩余子树接回二叉树时，要分三种情况处理，被删除节点是：顶部根节点、底部叶子（无子树）、普通节点。

复制代码 
 1 static BOOL tree_del(BTree *BT, BTNode **phead, TYPE value)
 2 {//删除结点
 3     BTNode *temp;
 4     BTNode *root;
 5     int flag;        //flag标记被删除的节点，默认顶部节点flag为0，左边节点flag为-1，右边节点flag为1
 6 
 7     if(*phead == NULL)
 8         return 0;
 9         
10     if(*phead == BT->phead){
11         flag = 0;
12         root = *phead;
13     }
14 
15     else if((*phead)->lchild != NULL){
16         flag = -1;
17         root = (*phead)->lchild;
18     }
19 
20     else if((*phead)->rchild != NULL){
21         flag = 1;
22         root = (*phead)->rchild;
23     }
24     else if((*phead)->lchild == NULL && (*phead)->rchild == NULL)
25         root = *phead;
26     
27     if(root->data == value){
28         if(root->lchild != NULL){
29             temp = BT->search_max(BT, &root->lchild, 1);
30             temp->lchild = root->lchild;
31              temp->rchild = root->rchild;
32             free(root);
33             root = temp;
34             if(flag == 0)
35                 BT->phead = root;
36             else
37                 (*phead)->lchild = root;
38         }
39         else if(root->rchild != NULL){
40             temp = BT->search_min(BT, &root->rchild, 1);   
41             temp->lchild = root->lchild;
42             temp->rchild = root->rchild;
43             free(root);
44             root = temp;
45             if(flag == 0)
46                 BT->phead = root;
47             else
48                 (*phead)->rchild = root;
49         }
50         else{
51             if(flag == 0)
52                 free(*phead);
53             else if(flag = -1){
54                 free((*phead)->lchild);
55                 (*phead)->lchild = NULL;
56             }
57             else if(flag = 1){
58                 free((*phead)->rchild);
59                 (*phead)->rchild = NULL;
60             }
61         }
62          
63         tree_height(BT, BT->phead);    //删除节点后，求每个节点的新高度
64 
65         if(flag == 0)
66             return 1;
67         if(flag == -1){
68             if(tree_node_height(BT, (*phead)->rchild) - tree_node_height(BT, (*phead)->lchild) == 2){
69                 if((*phead)->rchild->rchild != NULL){
70                     root = singleRotateRR(BT, *phead);
71                 }
72                 else{
73                     root = doubleRotateRL(BT, *phead);
74                 }
75             }
76         }
77         else{
78             if(tree_node_height(BT, (*phead)->lchild) - tree_node_height(BT, (*phead)->rchild) == 2){
79                 if((*phead)->lchild->lchild != NULL){
80                     root = singleRotateLL(BT, *phead);
81                 }
82                 else{
83                     root = doubleRotateLR(BT, *phead);
84                 }
85             }
86         }
87             
88         return 1;
89     }
90     else if(root->data > value)
91         return BT->del(BT, &root->lchild, value);
92     else
93         return BT->del(BT, &root->rchild, value);
94 
95     return 0;
96 }
复制代码

 

除了插入和删除操作，其他操作均与普通二叉查找树一样。

如果读者发现错误或有更好的处理方法，请指出，以便修改完善。 

ringrang
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
平衡二叉树 AVL树 实现 C语言
su_1998的博客
12-16 1534
平衡树
c语言实现平衡二叉树创建(AVL)
weixin_43322782的博客
11-27 1221
创建平衡二叉树 需要的辅助函数 创建树结点 计算每个节点高度 计算每个节点的平衡因子 插入新节点后对于出现的LL,RR,LR,RL型的子树处理问题 插入函数 构建一颗AVL平衡二叉树 本文章重点讲解第4个函数(在下文的step6,7,8,9)。 什么树不是平衡二叉树？ 存在一个树节点的平衡因子绝对值大于1(平衡因子=左子树高度-右子树高度) 例：下图结点‘7‘的平衡因子为(左子树高度3-右子树高度1)=2 不是二叉平衡树 step1:定义树结点 typedef struct node { in
实现平衡二叉树c语言编码,C语言平衡二叉树 AVL实现代码
weixin_34587189的博客
05-19 89
该楼层疑似违规已被系统折叠隐藏此楼查看此楼下面是头文件内容------------------------------------------------------------------------#ifndef TREE_H#define TREE_H#include typedef struct TREE__ *TREE;// 回调函数原型typedef VOID (*TREE_KEY_...
c语言平衡二叉树,C语言平衡二叉树 AVL实现代码
weixin_33514277的博客
05-19 73
该楼层疑似违规已被系统折叠隐藏此楼查看此楼下面是头文件内容------------------------------------------------------------------------#ifndef TREE_H#define TREE_H#include typedef struct TREE__ *TREE;// 回调函数原型typedef VOID (*TREE_KEY_...
【数据结构】平衡二叉树（插入、查找、删除）解析+完整代码
m0_61628700的博客
05-14 1271
平衡二叉树，简称平衡树（AVL树）树上任一结点的左右子树高度差不超过1。结点的平衡因子=左子树高-右子树高。
C语言-实现顺序二叉树和平衡二叉树AVL
mike_jun的博客
04-10 1077
在实现二叉树之前先看下结构体的一些使用方法数组是保存一系列相同的数据。在实际问题中，一组数据往往有很多种不同的数据类型。例如，登记学生的信息，可能需要用到 char型的姓名，int型或 char型的学号，int型的年龄访问其中的各个元素，用结构成员运算符点（.）。即访问成员的一般形式是：结构变量名 . 成员名如 a.name 表示学生 a 的姓名。1）结构体的成员逐个赋值2）整体赋值也可以在初始化的时候赋值3）整体拷贝如上每次使用结构体均需要写struct，可以使用typedef 简化书写。
【数据结构】平衡二叉树（AVL) C语言实现
crr411422的博客
04-05 1776
平衡二叉树，也称为 AVL 树，是一种二叉排序树，用于解决二叉排序树高度不确定的情况。可以是空树；左子树和右子树的高度之差的绝对值小于等于1；左子树和右子树也是平衡二叉树。插入结点后，最小不平衡子树的BF与它的子树的BF符号相反时，就需要对结点先进行一次旋转以使得符号相同后，再反向旋转一次才能够完成平衡操作。
C语言代码实现平衡二叉树|图解+详细代码
轻松学C语言
10-05 2472
点击蓝字关注我们来源于网络，侵删1. 什么是平衡二叉树平衡二叉树，我们也称【二叉平衡搜索树/AVL】,树中任何节点的两个子树的高度最大差别为1，巴拉巴拉。。。(https://baike.baidu.com/item/AVL树/10986648?fr=aladdin)但是有个注意的点: 平衡二叉树的前提是 二叉排序树(https://baike.baidu.com/item/二叉搜索树/70778...
C语言实现平衡二叉树
Arithmetic-logic
07-23 362
定义结构体 #define Type int typedef struct AVLNode { Type data; AVLNode* leftchild; AVLNode* rightchild; int bf;//平衡因子 }AVLNode; typedef struct AVLTree { AVLNode* root; }AVLTree; 插入结点 void InitAVLTree(AVLTree* avl) { avl->root = NULL; } bool Insert(
AVL平衡二叉树 c语言实现代码
@二老的博客
05-02 542
说明 在阅读下列代码时，为了保障能够轻松理解，请务必对指针和二叉排序树数据结构以及平衡原理有较深的了解 #include <stdio.h> #include <stdlib.h> //状态 typedef int status; #define TRUE 1 #define FLASE 0 //平衡因子 #define EH 0 //等高 #define LH 1 /...
数据结构与算法--栈
wumingzei的博客
08-02 1075
栈（Stack）是限定只能在表的一端进行插入和删除操作的线性表。允许插入和删除运算的一端称为栈顶（top），不允许插入和删除的另一端称为栈底（bottom）。在栈顶进行的插入操作称为入栈或进栈(push),在栈顶进行的删除操作称为出栈或退栈(pop)特点：后进先出（LIFO, Last In First Out）。栈的后进先出特性。顺序栈和链栈的入栈、出栈操作。栈在中缀表达式转换为后缀表达式中的应用。
数据结构——链式结构二叉树
2301_81888634的博客
08-02 651
我们已经学习了实现二叉树的两种方法：顺序结构（堆）和链式结构。敬请期待“二叉树OJ题”~
数据结构（其四）--特殊矩阵的存储
最新发布
sjj_1234567的博客
08-05 548
所以，aij 前面有 [n + ... + (n - i + 2)] + (j - i)个元素，中括号里的是此行往上的，那个j-i是当前行内aij 之前的元素。（对于aij），前(i - 1)行，有3(i - 1) - 1个元素(每行有三个元素，但第一行只有两个)；一维数组的地址是连续的，只要知道了起始地址（LOC，默认是a[0]的地址），就可以知道所有元素的地址。是第k + 1个元素，在前i-1行，与前i行之间，3(i - 1) - 1 < k + 1。获取常数项，数组下标就是 n*(n+1)/2。
【C语言】【数据结构】冒泡排序及优化
2401_86272648的博客
08-02 353
冒泡排序是一种简单的排序算法。一次从前往后地走访待排序的元素序列被称为一趟，每一趟都会把相邻的两个元素的错误顺序交换，将当前趟次中最大或者最小的元素像“冒泡泡”一样冒到最后面，反复地走访元素序列，直到所有元素都排好序。
数据结构：双向链表
2401_86551514的博客
08-03 468
这里的“带头”跟“头节点”是两个概念，带头链表里的头节点，实际为“哨兵位”，哨兵位节点不存储任何有效元素，只是站在这里“放哨 的” ，存在的意义： 遍历循环链表避免死循环。虽然有这么多的链表的结构，但是我们实际中最常用还是两种结构：单链表和双向带头循环链表，上一篇我们已经讲了单链表，今天就来了解一下双向链表并将其实现。顺序表和链表我们都学了，两者各有各的优缺点，根据需求的不通，运用在不同的场景。本篇的内容就到这里了，希望对各位有帮助，如果有错误欢迎指出。还是老样子，在头文件里写出我们需要功能的函数名。
数据结构第九讲：二叉树
2301_79761834的博客
08-03 672
数据结构第九讲：二叉树
【数据结构入门 】栈
KevinRay_0854的博客
08-02 613
通过构建一个栈，我们可以非常方便地实现后进先出的数据结构，使得我们能够高效地处理一些具有类似特性的问题。因此，了解和掌握栈的概念和操作是很重要的。在接下来的内容中，我们将详细介绍栈的基本原理、以及常见实现方式。希望通过本文的学习，读者能够深入理解栈，并能够在实际编程中熟练运用。
Redis 数据结构深度解析：跳跃表（Skiplist）
lssffy的博客
08-02 494
本文旨在全面解析跳跃表的设计原理、结构特点、实现方式以及其在Redis中的应用，并通过示例代码帮助读者深入理解跳跃表的工作机制。跳跃表是一种概率性的数据结构，基于多层链表，与平衡树和二分查找相比，跳跃表在实现上更为简单，同时保持了类似的平均时间复杂度和最坏时间复杂度。探讨跳跃表的变种和改进方法，如确定性跳跃表、压缩跳跃表等，以及它们在现代数据库和分布式系统中的潜在应用。Redis的跳跃表实现在保持数据结构本身优势的同时，进行了适应性的优化，以满足高并发和大数据量的需求。第三部分：跳跃表的效率和优化。
【数据结构】——二叉树OJ题
2302_78420373的博客
08-02 1148
我们先想想二叉树我们学习了哪些内容再来做题哈其实学习二叉树重要的思想——递归，我们可以通过后面的题目慢慢的理解。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值