AVL树-C实现

最新推荐文章于 2023-07-01 17:02:10 发布
最新推荐文章于 2023-07-01 17:02:10 发布
阅读量595 收藏
点赞数
分类专栏： Coding 文章标签： c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/calkee/article/details/52092582
版权

我一直对平衡二叉树感兴趣，数据结构和算法妙趣横生，仔细体会，对编程莫大裨益。花了一个星期的业余时间，初步写完了AVL Tree，目前还在继续查找Bug中。
AVL树使用平衡因子来决定是否对树进行旋转。对树进行旋转有四种情况。但首先是某个平衡因子的值达到了2或者-2，再根据该节点的子节点的平衡因子是1还是-1，进行相应的旋转。
关于AVL的一些特性，可以参考国外教材《算法和数据结构 C语言描述》这本书。

#include <stdio.h>
#include <stdlib.h>

typedef struct AVLNode {
    void *value;
    struct AVLNode *parent;
    struct AVLNode *lchild;
    struct AVLNode *rchild;
    int gap;
}AVLNode , *Node;

typedef struct AVLTree {
    Node root;
    int (*Compare) (void *value1 , void *value2);
}Tree , *AVLTree;


static Node Search (AVLTree avltr , void *value);
static Node NodeInitial (void *value);
static AVLTree TreeInitial (int (*Compare) (void *value1 , void *value2));
static void ReplaceNode (AVLTree avltr , Node node1 , Node node2);
static void Insert (AVLTree avltr , Node avlnode);
static void Delete (AVLTree avltr , Node avlnode);
static void AVLPrint (Node root);
static void FreeAVL (Node root);

static Node FindSubMax (Node avlnode);
static Node FindSubMin (Node avlnode);
static Node FindMax (AVLTree avltr);
static Node FindMin (AVLTree avltr);
static Node FindSuccessor (Node avlnode);

void LeftRotate (AVLTree avltr , Node avlnode);
void RightRotate (AVLTree avltr , Node avlnode);
void LeftRightRotate (AVLTree avltr , Node avlnode);
void RightLeftRotate (AVLTree avltr , Node avlnode);
void AVLInsertBalance (AVLTree avltr , Node avlnode);
void AVLDeleteBalance (AVLTree avltr , Node avlnode);


void LeftRotate (AVLTree avltr , Node avlnode) {
    Node righttree = avlnode->rchild;
    Node pa_node = avlnode->parent;
    Node rlchild = righttree->lchild;

    righttree->parent = pa_node;
    if(pa_node == NULL) {
        avltr->root = righttree;
    } else if(pa_node->lchild == avlnode) {
        pa_node->lchild = righttree;
    } else {
        pa_node->rchild = righttree;
    }

    avlnode->parent = righttree;
    righttree->lchild = avlnode;

    avlnode->rchild = rlchild;
    if(rlchild != NULL) {
        rlchild->parent = avlnode;
    }
}

void RightRotate (AVLTree avltr , Node avlnode) {
    Node lefttree = avlnode->lchild;
    Node pa_node = avlnode->parent;
    Node lrchild = lefttree->rchild;

    lefttree->parent = pa_node;
    if(pa_node == NULL) {
        avltr->root = lefttree;
    } else if(pa_node->lchild == avlnode) {
        pa_node->lchild = lefttree;
    } else {
        pa_node->rchild = lefttree;
    }

    avlnode->parent = lefttree;
    lefttree->rchild = avlnode;

    avlnode->lchild = lrchild;
    if(lrchild != NULL) {
        lrchild->parent = avlnode;
    }
}

void LeftRightRotate (AVLTree avltr , Node avlnode) {
    LeftRotate(avltr , avlnode->rchild);
    RightRotate(avltr , avlnode);
}

void RightLeftRotate (AVLTree avltr , Node avlnode) {
    RightRotate(avltr , avlnode->lchild);
    LeftRotate(avltr , avlnode);
}

int IntComp (void *value1 , void *value2) {
    if (*(int *)value1 > *(int *)value2) return 1;
    if (*(int *)value1 < *(int *)value2) return -1;
    return 0;
}

static AVLTree TreeInitial (int (*Compare) (void *value1 , void *value2)) {
    AVLTree tree = (AVLTree) malloc (sizeof (Tree));
    printf ("Size of Tree is %d\n",sizeof(Tree));
    tree->Compare = Compare;
    tree->root = NULL;
    return tree;
}

static Node NodeInitial (void *value) {
    printf("Initial Node.\n");
    Node avlnode = (Node) malloc (sizeof (AVLNode));
    if (avlnode == NULL) printf("Initial Node with error.\n");
    avlnode->gap = 0;
    avlnode->lchild = NULL;
    avlnode->parent = NULL;
    avlnode->rchild = NULL;
    avlnode->value = value;
    printf ("Initilized Node value is %d.\n",*(int *)avlnode->value);
    return avlnode;
}

static Node Search (AVLTree avltr , void *value) {
    Node root = avltr->root;
    while (root != NULL) {
        if(avltr->Compare(root->value , value) == 0) {
            return root;
        } else if (avltr->Compare(root->value , value) < 0) {
            root = root->rchild;
        } else {
            root = root->lchild;
        }
    }
    return NULL;
}

static Node FindSubMax (Node avlnode) {
    Node node = avlnode;
    while (node->rchild != NULL) {
        node = node->rchild;
    }
    return node;
}

static Node FindSubMin (Node avlnode) {
    Node node = avlnode;
    while (node->lchild !=NULL) {
        node = node->lchild;
    }
    return node;
}

static Node FindMax (AVLTree avltr) {
    Node node = avltr->root;
    if(node == NULL) {
        return NULL;
    } else {
        return FindSubMax(node);
    }
}

static Node FindMin (AVLTree avltr) {
    Node node = avltr->root;
    if (node == NULL) {
        return NULL;
    } else {
        return FindSubMin(node);
    }
}

static Node FindSuccessor (Node avlnode) {
    Node node = avlnode;
    if (node->rchild != NULL) {
        return FindSubMin (node->rchild);
    } else {
        Node pa = node->parent;
        while ( pa != NULL && node == pa->rchild ) {
            node = pa;
            pa = pa->parent;
        }
        return pa;
    }
}

static void ReplaceNode (AVLTree avltr , Node node1 , Node node2) {
    if (avltr->Compare(node1->value , node2->value)!=0) {
        return;
    } else {
        node1->value = node2->value;
    }
}

static void Insert (AVLTree avltr , Node avlnode) {
    if (avlnode == NULL) {
        return;
    }
    if (avltr == NULL) {
        return;
    }
    if (avltr->root == NULL) {
        avltr->root = avlnode;      
    } else {
        Node node = avltr->root;
        Node pa_node = NULL;
        while (node != NULL) {
            pa_node = node;
            if (avltr->Compare(node->value,avlnode->value) < 0) {
                node = node->rchild;
            } else if (avltr->Compare(node->value,avlnode->value) > 0) {
                node = node->lchild;
            } else {
                ReplaceNode(avltr,node,avlnode);
                return;
            }
        }
        avlnode->parent = pa_node;
        if(avltr->Compare(pa_node->value , avlnode->value) >0) {
            pa_node->lchild = avlnode;
            pa_node->gap++; 
        } else {
            pa_node->rchild = avlnode;
            pa_node->gap--;
        }

        AVLInsertBalance (avltr , pa_node);
    }
}

static void Delete (AVLTree avltr , Node avlnode) {
    if (avltr == NULL || avltr->root == NULL) return;

    Node p_node = NULL , d_node = NULL , s_node = NULL;

    if(avlnode->lchild != NULL && avlnode->rchild != NULL) {
        d_node = FindSuccessor(avlnode);
    } else {
        d_node = avlnode;
    }
    p_node = d_node->parent;
    if (d_node->rchild != NULL) {
        s_node = d_node->rchild;
    } else {
        s_node = d_node->lchild;
    }
    if (p_node->lchild == d_node) {
        p_node->lchild = s_node;
        p_node->gap--;
    } else {
        p_node->rchild = s_node;
        p_node->gap++;
    }
    if (s_node != NULL) {
        s_node->parent = p_node;
    }
    if (d_node != avlnode) {
        avlnode->value = d_node->value;
    }

    AVLDeleteBalance(avltr , p_node);
    free(d_node);
}

void AVLInsertBalance (AVLTree avltr , Node avlnode) {
    Node p_node = avlnode->parent;
    Node node = avlnode;
    while (p_node != NULL) {
        if (p_node->lchild == node) {
            p_node->gap++;
        } else {
            p_node->gap--;
        }

        if (p_node->gap == 0){
            return;
        }
        else if (p_node->gap == 1 || p_node->gap == -1) {
            node = p_node;
            p_node = p_node->parent;
        }
        else if (p_node->gap > 1) {
            if (node->gap == 1) {
                p_node->gap-=2;
                node->gap-=1;
                RightRotate(avltr , p_node);
                return;
            }
            if (node->gap == -1) {
                p_node->gap-=2;
                node->gap+=1;
                LeftRightRotate(avltr , p_node);
                return;
            }
        } 
        else {
            if (node->gap == -1) {
                p_node->gap+=2;
                node->gap+=1;
                LeftRotate(avltr , p_node);
                return;
            }
            if (node->gap == 1) {
                p_node->gap+=2;
                node->gap-=1;
                RightLeftRotate (avltr , p_node);
                return;
            }
        }
    }
}

void AVLDeleteBalance (AVLTree avltr , Node avlnode) {
    Node node = avlnode;
    Node pa_node = avlnode;
    while (pa_node != NULL) {
        node = pa_node;
        if (node->gap == 2) {
            Node lch_node = node->lchild;
            if (lch_node->gap == 1) {
                node->gap-=2;
                lch_node->gap-=1;
                RightRotate(avltr , node);
                pa_node = lch_node->parent;
                if (pa_node != NULL) {
                    if (pa_node->lchild == lch_node) {
                        pa_node->gap--;
                    } else {
                        pa_node->gap++;
                    }   
                }
            }
            if (lch_node->gap == -1) {
                node->gap-=2;
                lch_node->gap+=1;
                LeftRightRotate(avltr , node);
                Node new_root = lch_node->rchild;
                pa_node = new_root->parent;
                if (pa_node != NULL) {
                    if (pa_node->lchild == new_root) {
                        pa_node->gap--;
                    } else {
                        pa_node->gap++;
                    }
                }
            }
        }

        if (node->gap == -2) {
            Node rch_node = node->rchild;
            if (rch_node->gap == -1) {
                node->gap+=2;
                rch_node->gap+=1;
                LeftRotate (avltr , node);
                pa_node = rch_node->parent;
                if (pa_node != NULL) {
                    if (pa_node->lchild == rch_node) {
                        pa_node->gap--;
                    } else {
                        pa_node->gap++;
                    }
                }
            }

            if (rch_node->gap == 1) {
                node->gap+=2;
                rch_node->gap-=1;
                RightLeftRotate (avltr , node);
                Node new_root = rch_node->lchild;
                pa_node = new_root->parent;
                if (pa_node != NULL) {
                    if (pa_node->lchild == new_root) {
                        pa_node->gap--;
                    } else {
                        pa_node->gap++;
                    }
                }
            }       
        }

        if (node->gap == 0) {
            pa_node = node->parent;
            if (pa_node != NULL) {
                if (pa_node->lchild == node) {
                    pa_node->gap--;
                } else {
                    pa_node->gap++;
                }   
            }   
        }

        if (node->gap == 1 || node->gap == -1) return;
    }   
} 

static void AVLPrint (Node root) {
    Node node = root;
    if (node != NULL) {
        AVLPrint (node->lchild);
        printf("%d:%d  ",*(int *)node->value,node->gap);
        AVLPrint (node->rchild);
    }
}

static void FreeAVL (Node root) {
    Node node = root;
    if (node != NULL) {
        FreeAVL (node->lchild);
        free(node);
        FreeAVL (node->rchild);
    }
}

void main (void) {
    AVLTree avltr = TreeInitial (IntComp);
    int a = 100;
    Node node1 = NodeInitial (&a);
    Insert (avltr , node1);
    int b = 56;
    Node node2 = NodeInitial (&b);
    Insert (avltr , node2);
    int c = 32;
    Node node3 = NodeInitial (&c);
    Insert (avltr , node3);
    int d = 67;
    Node node4 = NodeInitial (&d);
    Insert (avltr , node4);
    int e = 21;
    Node node5 = NodeInitial (&e);
    Insert (avltr , node5);
    int f = 18;
    Node node6 = NodeInitial (&f);
    Insert (avltr , node6);
    int g = 17;
    Node node7 = NodeInitial (&g);
    Insert (avltr , node7);
    AVLPrint (avltr->root);
    printf("\n");
    Delete (avltr , node3);
    AVLPrint (avltr->root);
}
calkee
关注
专栏目录
AVL树及C语言实现
IT_Linux
03-28 9597
概念   平衡二叉树(Balanced binary tree)是由苏联数学家Adelson-Velskii and Landis于1962年首先提出的，所以又称为AVL树。 定义：平衡二叉树或为空树,或满足如下性质的二叉树:  （1）本身首先是一棵二叉搜索树   （2）左右子树深度之差的绝对值不超过1;   （3）左右子树仍然为平衡二叉树. 平衡因子BF=左子树深度－右子树深度.
平衡二叉树 AVL树 实现 C语言
su_1998的博客
12-16 1608
平衡树
AVL树的C语言实现
11-30
AVL树的C语言实现
avl树的c实现
一步一脚印
10-15 791
一.简介：一看到AVL树，首先联想到岛国动作片有木有，不过AVL树是得名于它的发明者 G.M. Adelson-Velsky 和 E.M. Landis。 AVL树其实是平衡二叉树的限定版， 二.性质 （1）.不仅仅具有平衡二叉树的所有性质（注：平衡二叉树性质：左节点的值 （2）.每个节点左右子树高度的差最多为1。这是什么意思呢？给个例子大家就明白了 如：
AVL树（C实现）
hys__handsome的博客
10-23 138
#include<stdio.h> #include<stdlib.h> //分别定义平衡因子数 #define LH +1 #define EH 0 #define RH -1 typedef int ElemType; //定义二叉排序树 typedef struct BSTNode{//BST二叉搜索树 ElemType data; int bf;//balance flag; 存放平衡因子 struct BSTNode *lchild,*rchild; }*.
AVL树（c实现）
u010049696的专栏
03-20 615
最近阅读java的TreeMap源码，发觉是使用红黑树实现内部的数据管理，所以开始学习编写红黑树。然后发现要想理解红黑树还是要从基础的二叉平衡树的开始。于是，最终决定拿AVL树开刀。 网络上有很多AVL树的各种语言实现版本，个人偏爱c的绝对控制性编程，所以选择了c实现。令人庆幸的是，一个非常简易的AVL树c实现被我找到。现在就在其基础上加上个人理解把AVL树实现描述如下：
AVL树C实现
computer vision, sixth sense, robot, AI
09-01 403
#include "avltree.h" #include "fatal.h" #include #include struct AvlNode {     ElementType Element;     AvlTree  Left;     AvlTree  Right;     int      Height; }; AvlTree MakeEmpty(
AVL-Tree-in-C：c中的AVL树。 最新更新9820
02-18
在`AVL-Tree-in-C-master`这个压缩包中，应该包含了实现AVL树的C源代码，包括节点定义、插入、删除、旋转等函数的实现。通过阅读和分析这些代码，你可以更深入地理解AVL树的内部工作原理和C语言中如何实现数据结构。...
红黑树-基于C语言实现的红黑树数据结构.zip
最新发布
03-21
- 转换操作：在插入和删除过程中，可能需要将红黑树转换成其他数据结构，如AVL树，以满足特定需求。 在实际应用中，红黑树广泛用于各种场景，如C++标准库中的STL map和set，它们底层就是基于红黑树实现的。红黑树的...
avl树 C实现
you-know-who的博客
04-04 362
头文件： #ifndef _Avl_Tree_H #define _Avl_Tree_H struct AvlNode; typedef struct AvlNode *AvlTree; typedef struct
AVL树（C语言实现）
jiqi0053的博客
01-16 451
截取了插入和删除部分 原文地址https://www.cnblogs.com/skywang12345/p/3576969.html #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #include &lt;ctype.h&gt; typedef struct tNode { int data; struct tNode* ...
AVL树C语言实现
AresDing的专栏
03-17 616
参考: https://www.cnblogs.com/skywang12345/p/3576969.html AVLTree.h #ifndef _AVL_TREE_H_ #define _AVL_TREE_H_ typedef int Type; struct AVLTreeNode { Type key; int height; struct AVLTreeNode *left; struct AVLTreeNode *right; }; // 获取AVL树的高度
AVL树C语言的实现
个人公众号: 码小菜
11-09 554
AVL树(一)之 图文解析 和 C语言的实现
AVL树的实现(C语言实现)
rainxbow的专栏
02-15 983
最近恶补数据结构，不过抱着小侄女实在复习不进去。。。这才复习完树 当时对于平衡树就没有一个系统的了解  具体的感念就不贴了，仔细说一说如何调整平衡二叉树 如果插入破坏了原有的平衡，“麻烦结点”在发现者右子树的右边，因而叫 RR 插入，需要RR 旋转（右单旋） 做如下调整 “麻烦结点”在发现者左子树的左边，因而叫 LL 插入，需要LL 旋转（左单旋）
平衡二叉排序树之AVL树（C语言实现）
zhao_Tao_WA的博客
07-01 967
本文详细介绍了平衡二叉排序树中的AVL树，对失衡类型和不同失衡类型的调整方式做了细致的描写，并用C语言实现了AVL树
平衡二叉树（AVL树）C语言实现
qq_54517101的博客
05-11 670
#include "stdio.h" #include "stdlib.h" #include "math.h" #include "time.h" typedef struct Node /* 结点结构 */ { int data; /* 结点数据 */ int balance; /* 结点的平衡因子 */ struct Node* lchild, * rchild; /* 左右孩子指针 */ } Node, *Tree; int r_rotate(Tree* T) .
AVL树(一)之 图文解析 和 C语言的实现
Become hunger become strong
08-03 597
概要 本章介绍AVL树。和前面介绍"二叉查找树"的流程一样，本章先对AVL树的理论知识进行简单介绍，然后给出C语言的实现。本篇实现的二叉查找树是c语言版的，后面章节再分别给出C++和Java版本的实现。 建议：若您对"二叉查找树"不熟悉，建议先学完"二叉查找树"再来学习AVL树。 目录 1. AVL树的介绍 2. AVL树的C实现 3. AVL树的C实现(完整源码) 4. AVL树的
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值