AVL树C语言实现

最新推荐文章于 2022-05-11 22:58:33 发布
最新推荐文章于 2022-05-11 22:58:33 发布
阅读量573 收藏 5
点赞数 2
分类专栏： Program Theory
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Auris/article/details/114945997
版权

参考: 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树的高度
int avltree_height(struct AVLTreeNode *tree);

// 前序遍历AVL树
void avltree_preorder(struct AVLTreeNode *tree);

// 中序遍历AVL树
void avltree_inorder(struct AVLTreeNode *tree);

// 后序遍历AVL树
void avltree_postorder(struct AVLTreeNode *tree);

// (递归实现)查找AVL树键值为key的节点
struct AVLTreeNode* avltree_search(struct AVLTreeNode *tree, Type key);

// (非递归实现)查找AVL树键值为key的节点
struct AVLTreeNode* avltree_iterative_search(struct AVLTreeNode *tree, Type key);

// 查找最小节点, 也就是AVL树最左节点
struct AVLTreeNode* avltree_min(struct AVLTreeNode *tree);

// 查找最大节点, 也就是AVL树最右节点
struct AVLTreeNode* avltree_max(struct AVLTreeNode *tree);

// 插入节点 返回新的根节点, 因为插入的节点有可能替换根节点
struct AVLTreeNode* avltree_insert(struct AVLTreeNode *tree, Type key);

// 删除节点 返回新的根节点, 因为删除的节点可能就是根节点
struct AVLTreeNode* avltree_delete(struct AVLTreeNode *tree, Type key);

// 销毁AVL树
void avltree_destroy(struct AVLTreeNode *tree);


#endif
AVLTree.c
#include "AVLTree.h"
#include <stdio.h>
#include <stdlib.h>

#define HEIGHT(p)   ((p==NULL) ? 0 : (((struct AVLTreeNode*)(p))->height))
#define MAX(a, b)   ((a) > (b) ? (a) : (b))

// 获取AVL树的高度
int avltree_height(struct AVLTreeNode *tree)
{
    return HEIGHT(tree);
}

// 前序遍历AVL树
void avltree_preorder(struct AVLTreeNode *tree)
{
    if (tree) {
        printf("%d ", tree->key);
        avltree_preorder(tree->left);
        avltree_preorder(tree->right);
    }
}

// 中序遍历AVL树
void avltree_inorder(struct AVLTreeNode *tree)
{
    if (tree) {
        avltree_inorder(tree->left);
        printf("%d ", tree->key);
        avltree_inorder(tree->right);
    }
}

// 后序遍历AVL树
void avltree_postorder(struct AVLTreeNode *tree)
{
    if (tree) {
        avltree_postorder(tree->left);
        avltree_postorder(tree->right);
        printf("%d ", tree->key);
    }
}

// (递归实现)查找AVL树键值为key的节点
struct AVLTreeNode* avltree_search(struct AVLTreeNode *tree, Type key)
{
    if (tree==NULL || key==tree->key) {
        return tree;
    }

    if (tree->key > key)
        return avltree_search(tree->left, key);
    else
        return avltree_search(tree->right, key);
}

// (非递归实现)查找AVL树键值为key的节点
struct AVLTreeNode* avltree_iterative_search(struct AVLTreeNode *tree, Type key)
{
    while ((tree != NULL) && (tree->key != key)) {
        if (key < tree->key)
            tree = tree->left;
        else
            tree = tree->right;
    }

    return tree;
}

// 查找最小节点, 也就是AVL树最左节点
struct AVLTreeNode* avltree_min(struct AVLTreeNode *tree)
{
    if (tree == NULL)
        return tree;

    while (tree->left != NULL)
        tree = tree->left;

    return tree;
}

// 查找最大节点, 也就是AVL树最右节点
struct AVLTreeNode* avltree_max(struct AVLTreeNode *tree)
{
    if (tree == NULL)
        return tree;

    while (tree->right != NULL)
        tree = tree->right;

    return tree;
}

// LL: 左左对应的情况 左单旋转, 返回旋转后的根节点
static struct AVLTreeNode* LL_Rotation(struct AVLTreeNode *tree)
{
    struct AVLTreeNode *k1;

    k1 = tree->left;
    tree->left = k1->right;
    k1->right = tree;

    tree->height = MAX(HEIGHT(tree->left), HEIGHT(tree->right)) + 1;
    k1->height = MAX(HEIGHT(k1->left), tree->height) + 1;

    return k1;
}

// RR: 右右对应的情况 右单旋转, 返回旋转后的节点
static struct AVLTreeNode* RR_Rotation(struct AVLTreeNode *tree)
{
    struct AVLTreeNode *k1;

    k1 = tree->right;
    tree->right = k1->left;
    k1->left = tree;

    tree->height = MAX(HEIGHT(tree->left), HEIGHT(tree->right)) + 1;
    k1->height = MAX(HEIGHT(k1->left), tree->height) + 1;

    return k1;
}

// LR: 左右对应的情况 左双旋转, 返回旋转后的节点
static struct AVLTreeNode* LR_Rotation(struct AVLTreeNode *tree)
{
    // 对tree的左子树进行RR旋转
    tree->left = RR_Rotation(tree->left);

    // 对tree进行LL旋转
    return LL_Rotation(tree);
}

// RL: 右左对应的情况 右双旋转, 返回旋转后的节点
static struct AVLTreeNode* RL_Rotation(struct AVLTreeNode *tree)
{
    // 对tree的右子树进行LL旋转
    tree->right = LL_Rotation(tree->right);

    // 对tree进行RR旋转
    return RR_Rotation(tree);
}

// 创建一个AVL树的节点
static struct AVLTreeNode* avltree_create_node(Type key, struct AVLTreeNode *left, struct AVLTreeNode *right)
{
    struct AVLTreeNode *p = NULL;

    p = (struct AVLTreeNode*)malloc(sizeof(struct AVLTreeNode));
    if (p == NULL)
        return NULL;

    p->height = 0;
    p->key = key;
    p->left = left;
    p->right = right;

    return p;
}


// 插入节点 返回新的根节点, 因为插入的节点有可能替换根节点
struct AVLTreeNode* avltree_insert(struct AVLTreeNode *tree, Type key)
{
    if (tree == NULL) {
        tree = avltree_create_node(key, NULL, NULL);
        if (tree == NULL) {
            printf("avltree_create_node failed. \r\n");
            return NULL;
        }
    } else if (key < tree->key) {
        // key 小于 root->key 应该插入到左子树中去
        tree->left = avltree_insert(tree->left, key);
        // 插入后, 需要判断平衡 进行调整
        if ((HEIGHT(tree->left) - HEIGHT(tree->right)) == 2) {
            if (key < tree->left->key) {
                // 是由于插入到LL导致的失衡, LL旋转调整
                tree = LL_Rotation(tree);
            } else {
                // 是由于插入到LR导致的失衡, LR旋转调整
                tree = LR_Rotation(tree);
            }
        }
    } else if (key > tree->key) {
        // key 大于 root->key 应该插入到右子树中去
        tree->right = avltree_insert(tree->right, key);
        if ((HEIGHT(tree->right) - HEIGHT(tree->left)) == 2) {
            if (key > tree->right->key) {
                // 是由于插入到RR导致的失衡, RR旋转调整
                tree = RR_Rotation(tree);
            } else {
                // 是由于插入到RL导致的失衡, RL旋转调整
                tree = RL_Rotation(tree);
            }
        }
    } else {
        printf("avltree_insert failed, the key has existed. \r\n");
    }

    tree->height = MAX(HEIGHT(tree->left), HEIGHT(tree->right)) + 1;    // 更新一下tree的高度数值

    return tree;
}

static struct AVLTreeNode* __avltree_delete(struct AVLTreeNode *tree, struct AVLTreeNode *node)
{
    struct AVLTreeNode *t = NULL;
    if (tree==NULL || node==NULL)
        return NULL;

    if (node->key < tree->key) {
        // 要删除的节点在tree的左子树中
        tree->left = __avltree_delete(tree->left, node);
        // 删除该节点以后, 看一下tree是否失衡了, 需要调整
        if ((HEIGHT(tree->right) - HEIGHT(tree->left)) == 2) {
            t = tree->right;
            if (t->right > t->left) {
                // RR 
                tree = RR_Rotation(tree);
            } else {
                // RL
                tree = RL_Rotation(tree);
            }
        }
    } else if (node->key > tree->key) {
        // 要删除的节点在tree的右子树中
        tree->right = __avltree_delete(tree->right, node);
        if ((HEIGHT(tree->left) - HEIGHT(tree->right)) == 2) {
            t = tree->left;
            if (t->left > t->right) {
                // LL
                tree = LL_Rotation(tree);
            } else {
                // LR
                tree = LR_Rotation(tree);
            }
        }
    } else {
        // tree正是要删除的节点
        if (tree->left==NULL) {
            // tree的左子树为空 删除tree节点 返回tree的右子树
            t = tree;
            tree = tree->right;
            free(t);
        } else if (tree->right==NULL) {
            // tree的右子树为空 删除tree节点 返回tree的左子树
            t = tree;
            tree = tree->left;
            free(t);
        } else {
            // tree的左右子树都不为空
            if (HEIGHT(tree->left) > HEIGHT(tree->right)) {
                // tree的左子树比右子树高, 找出左子树最大节点, 将该最大节点赋值给tree, 删除该最大节点
                t = avltree_max(tree->left);
                tree->key = t->key;
                tree->left = __avltree_delete(tree->left, t);   // __avltree_delete 返回的肯定是AVL树
            } else {
                // tree的左子树不必右子树高, 找出右子树最小节点, 将该最小节点赋值给tree, 删除该最小节点
                t = avltree_min(tree->right);
                tree->key = t->key;
                tree->right = __avltree_delete(tree->right, t); // // __avltree_delete 返回的肯定是AVL树
            }
        }
    }

    return tree;
}

// 删除节点 返回新的根节点, 因为删除的节点可能就是根节点
struct AVLTreeNode* avltree_delete(struct AVLTreeNode *tree, Type key)
{
    struct AVLTreeNode *node = NULL;

    #if 1       // 采用递归查找
    node = avltree_search(tree, key);
    #else       // 采用非递归查找
    node = avltree_iterative_search(tree, key);
    #endif
    if (node) {
        tree = __avltree_delete(tree, node);
    }

    return tree;        // 返回删除该节点以后的tree树根节点
}

// 销毁AVL树
void avltree_destroy(struct AVLTreeNode *tree)
{
    if (tree == NULL)
        return;

    if (tree->left)
        avltree_destroy(tree->left);

    if (tree->right)
        avltree_destroy(tree->right);

    free(tree);
}
main.c
#include <stdio.h>
#include "AVLTree.h"

static int arr[] = {3,2,1,4,5,6,7,16,15,14,13,12,11,10,8,9};
#define TBL_SIZE(a) ((sizeof(a))/(sizeof(a[0])))

int main(int argc, char* argv[])
{
    int i = 0, len = 0;
    struct AVLTreeNode *root = NULL;

    printf("== 高度: %d \r\n", avltree_height(root));
    printf("== 依次添加: ");
    len = TBL_SIZE(arr);
    for (i = 0; i < len; i++) {
        printf("%d ", arr[i]);
        root = avltree_insert(root, arr[i]);
    }
    printf("\r\n");

    printf("== 前序遍历: ");
    avltree_preorder(root);
    printf("\r\n");

    printf("== 中序遍历: ");
    avltree_inorder(root);
    printf("\r\n");

    printf("== 后序遍历: ");
    avltree_postorder(root);
    printf("\r\n");

    printf("== 高度: %d \r\n", avltree_height(root));
    printf("== 最小值: %d \r\n", avltree_min(root)->key);
    printf("== 最大值: %d \r\n", avltree_max(root)->key);

    return 0;
}
AresDing
关注
  • 2
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
AVL树（C语言实现）
mayfly_strive的博客
02-09 2332
AVL树的相关操作，包括插入，删除，查找，调整。（C语言实现）
C语言 平衡二叉搜索树（AVL树）
m0_73070900的博客
06-30 267
AVL树是一种自平衡的二叉搜索树，它在插入和删除操作后能够通过旋转操作来保持树的平衡。AVL树是由苏联数学家G.M. Adelson-Velsky和E.M. Landis于1962年提出的，其名称即来源于他们的姓氏的首字母。
AVL树的C语言实现
浮生Spider
08-03 574
AVL树是带有平衡条件的二叉查找树。之所以需要平衡是因为有的二叉查找树很糟糕，像这样   上一篇文章中二叉查找树的删除总是用右子树的左子树叶子来代替删除节点操作容易造成左子树比右子树深很多的情况（每次删除的都是右子树的节点）。一颗AVL树是其每个节点的左子树和右子树高度最多差1的二叉查找树。空树的高度定义为-1.因为添加了平衡条件，所以我们在编写AVL树的基本操作时需要加入是否平衡的判断，以及
AVL树的基础实现c语言
Mrlie的博客
01-08 559
#include<stdio.h> #include<stdlib.h> typedef struct avltree { int data; struct avltree* left; struct avltree* right; int height; }avl; int geth(avl *p); //获取高度 int getmax(int a, int b); //获得最大值 avl* insert(avl *p, int x); //插入并调整 avl* .
平衡二叉树（AVL树）C语言实现
qq_54517101的博客
05-11 589
#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语言实现
06-21
2. **C语言实现AVL树** - **数据结构**：首先，我们需要定义一个结构体来表示AVL树节点，包含键值、平衡因子、左子树和右子树的指针。 - **初始化**：创建空AVL树，通常用NULL表示。 - **查找操作**：从根节点...
C语言数据结构之平衡二叉树（AVL树）实现方法示例
08-28
C语言数据结构之平衡二叉树（AVL树）实现方法示例 本文将详细介绍C语言数据结构之平衡二叉树（AVL树）实现方法，并结合实例形式分析了C语言平衡二叉树的相关定义与使用技巧。 知识点一：AVL树的定义 AVL树是一种...
基于C语言实现哈夫曼树.zip
最新发布
05-10
例如，使用自平衡二叉查找树（如AVL树或红黑树）作为优先队列，可以简化哈夫曼树构建过程。 以上就是基于C语言实现哈夫曼树的基本思路和关键步骤。在实践中，还需要处理各种边界情况，如处理空文本、处理非ASCII...
若干平衡树的C语言实现_C语言_平衡树_
09-29
在C语言中实现平衡树，通常会涉及到AVL树、红黑树或者Treap等经典的数据结构。 **AVL树** AVL树是最先被提出的自平衡二叉搜索树，由G. M. Adelson-Velsky和E. M. Landis于1962年提出，因此得名。AVL树的关键特性是...
AVL树的c语言实现代码（添加和删除）
01-06
这个代码是关于AVL树的添加和删除的实现
AVL树（c实现）
u010049696的专栏
03-20 599
最近阅读java的TreeMap源码，发觉是使用红黑树实现内部的数据管理，所以开始学习编写红黑树。然后发现要想理解红黑树还是要从基础的二叉平衡树的开始。于是，最终决定拿AVL树开刀。 网络上有很多AVL树的各种语言实现版本，个人偏爱c的绝对控制性编程，所以选择了c实现。令人庆幸的是，一个非常简易的AVL树c实现被我找到。现在就在其基础上加上个人理解把AVL树实现描述如下：
AVL树的创建--C语言实现
Phyloser的博客
03-08 2167
AVL树是一种自平衡（Self-balancing）二叉查找树（Binary Search Tree），要求任何一个节点的左子树和右子树的高度之差不能超过1。 AVL树的插入操作首先会按照普通二叉查找树的插入操作进行，不同的是在成功插入一个节点后会向上进行回溯，判断路径中的每一个节点左子树和右子树高度之差，如果相差大于1，则进行旋转操作使得树重新达到平衡状态，旋转的本质其实是为当前不平衡的子树选择一
AVL树C语言代码
Pwnpanda的博客
02-26 1328
普通的二叉查找树很容易导致某一侧的子树高度远远超过另一侧，这就导致了搜索效率的降低。AVL树（自平衡二叉查找树的诞生就是为了解决此类问题），和之前的BST树很类似，但是要添加上平衡因子，并在插入或删除某结点后进行平衡 #include&amp;lt;stdio.h&amp;gt; #include&amp;lt;stdlib.h&amp;gt; typedef int ElemType; typedef struct Avl...
AVL树的实现(C语言实现)
rainxbow的专栏
02-15 961
最近恶补数据结构，不过抱着小侄女实在复习不进去。。。这才复习完树 当时对于平衡树就没有一个系统的了解  具体的感念就不贴了，仔细说一说如何调整平衡二叉树 如果插入破坏了原有的平衡，“麻烦结点”在发现者右子树的右边，因而叫 RR 插入，需要RR 旋转（右单旋） 做如下调整 “麻烦结点”在发现者左子树的左边，因而叫 LL 插入，需要LL 旋转（左单旋）
C语言 AVL树
fpk2014的博客
05-28 822
AVL树简介 实现过程 代码实现 AVL树简介 AVL树的基本操作一般涉及运做同在不平衡的二叉查找树所运做的同样的算法。但是要进行预先或随后做一次或多次所谓的”AVL 旋转”。 AVL树的模拟过程可以看链接：AVLtree 对于AVL树的详细简介和实现过程可以参照链接：数据结构图文解析之：AVL树详解及C++模板实现 我在这里主要是选出重点：AVL...
AVL树（C实现）
hys__handsome的博客
10-23 102
#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语言实现
L_Aster的专栏
12-13 3117
MARK一篇关于AVL树的博客文章：数据结构图文解析之：AVL树详解及C++模板实现 一、AVL结构定义 struct AVLNode { int val; struct AVLNode *left,*right; int height;//AVL树的高度 }; typedef struct AVLNode AVLNode; 注：在节点中添加高度标记的原因在于，...
AVL树原理及实现（C语言实现以及Java语言实现）
weixin_30258027的博客
11-17 323
欢迎探讨，如有错误敬请指正 如需转载，请注明出处http://www.cnblogs.com/nullzx/ 1. AVL定义 AVL树是一种改进版的搜索二叉树。对于一般的搜索二叉树而言，如果数据恰好是按照从小到大的顺序或者从大到小的顺序插入的，那么搜索二叉树就对退化成链表，这个时候查找，插入和删除的时间都会上升到O(n)，而这对于海量数据而言，是我们无法忍受的。即使是一颗由完全随机的数据构造...
用c语言实现AVL树
05-26
AVL树是一种平衡二叉树，C语言中可以通过结构体和指针来实现AVL树。下面是一个简单的AVL树实现示例，包括AVL树的创建、插入、删除和遍历操作。 ```c #include #include // 定义AVL树节点结构体 struct node { ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值