9. avltree

最新推荐文章于 2022-12-13 11:42:21 发布
最新推荐文章于 2022-12-13 11:42:21 发布
阅读量77 收藏
点赞数
文章标签： 数据结构与算法
原文链接：http://www.cnblogs.com/typewriter/p/6270158.html
版权

fatal.h

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

#define Error(Str)        FatalError(Str)
#define FatalError(Str)   fprintf(stderr, "%s\n", Str), exit(1)

avltree.h

typedef int ElementType;

#ifndef _AvlTree_H
#define _AvlTree_H

struct AvlNode;
typedef struct AvlNode *Position;
typedef struct AvlNode *AvlTree;

AvlTree MakeEmpty(AvlTree T);
Position Find(ElementType X, AvlTree T);
Position FindMin(AvlTree T);
Position FindMax(AvlTree T);
AvlTree Insert(ElementType X, AvlTree T);
AvlTree Delete(ElementType X, AvlTree T);
ElementType Retrieve(Position P);

void PreorderTraversal(AvlTree T);
void InorderTraversal(AvlTree T);
void PostorderTraversal(AvlTree T);
void LevelorderTraversal(AvlTree T);

#endif  /* _AvlTree_H */

queue.h

#ifndef _Queue_h
#define _Queue_h

struct QueueRecord;
typedef struct QueueRecord *Queue;

int IsEmptyQueue(Queue Q);
int IsFullQueue(Queue Q);
Queue CreateQueue(int MaxElements);
void DisposeQueue(Queue Q);
void MakeEmptyQueue(Queue Q);
void Enqueue(AvlTree X, Queue Q);
AvlTree Front(Queue Q);
void Dequeue(Queue Q);
AvlTree FrontAndDequeue(Queue Q);

#endif

avltree.c

#include "avltree.h"
#include "queue.h"
#include <stdlib.h>
#include "fatal.h"

struct AvlNode
{
    ElementType Element;
    AvlTree  Left;
    AvlTree  Right;
    int      Height;
};

AvlTree MakeEmpty(AvlTree T)
{
    if (T != NULL)
    {
        MakeEmpty(T->Left);
        MakeEmpty(T->Right);
        free(T);
    }
    return NULL;
}

Position Find(ElementType X, AvlTree T)
{
    if (T == NULL)
        return NULL;
    if (X < T->Element)
        return Find(X, T->Left);
    else if (X > T->Element)
        return Find(X, T->Right);
    else
        return T;             
}

Position FindMin(AvlTree T)
{
    if (T == NULL)
        return NULL;
    else if (T->Left == NULL)
        return T;
    else
        return FindMin(T->Left);    
}

Position FindMax(AvlTree T)
{
    if (T != NULL)
        while (T->Right != NULL)
            T = T->Right;

    return T;
}

static int Height(Position P)
{
    if (P == NULL)
        return -1;
    else
        return P->Height;
}

static int Max(int Lhs, int Rhs)
{
    return Lhs > Rhs ? Lhs : Rhs;
}

/* This function can be called only if K2 has a left child */
/* Perform a rotate between a node (K2) and its left child */
/* Update heights, then return new root */
static Position SingleRotateWithLeft(Position K2)
{
    Position K1;

    K1 = K2->Left;
    K2->Left = K1->Right;
    K1->Right = K2;

    K2->Height = Max(Height(K2->Left), Height(K2->Right)) + 1;
    K1->Height = Max(Height(K1->Left), K2->Height) + 1;

    return K1;  /* New root */
}

/* This function can be called only if K1 has a right child */
/* Perform a rotate between a node (K1) and its right child */
/* Update heights, then return new root */
static Position SingleRotateWithRight(Position K1)
{
    Position K2;

    K2 = K1->Right;
    K1->Right = K2->Left;
    K2->Left = K1;

    K1->Height = Max(Height(K1->Left), Height(K1->Right)) + 1;
    K2->Height = Max(Height(K2->Right), K1->Height) + 1;

    return K2;  /* New root */
}

/* This function can be called only if K3 has a left */
/* child and K3's left child has a right child */
/* Do the left-right double rotation */
/* Update heights, then return new root */
static Position DoubleRotateWithLeft(Position K3)
{
    /* Rotate between K1 and K2 */
    K3->Left = SingleRotateWithRight(K3->Left);

    /* Rotate between K3 and K2 */
    return SingleRotateWithLeft(K3);
}

/* This function can be called only if K1 has a right */
/* child and K1's right child has a left child */
/* Do the right-left double rotation */
/* Update heights, then return new root */
static Position DoubleRotateWithRight(Position K1)
{
    /* Rotate between K3 and K2 */
    K1->Right = SingleRotateWithLeft(K1->Right);

    /* Rotate between K1 and K2 */
    return SingleRotateWithRight(K1);
}

AvlTree Insert(ElementType X, AvlTree T)
{
    if (T == NULL)
    {
        /* Create and return a one-node tree */
        T = malloc(sizeof(struct AvlNode));
        if (T == NULL)
            FatalError("Out of space!!!");
        else
        {
            T->Element = X; T->Height = 0;
            T->Left = T->Right = NULL;
        }
    }
    else if (X < T->Element)
    {
        T->Left = Insert(X, T->Left);
        if (Height(T->Left) - Height(T->Right) == 2)
        {
            if (X < T->Left->Element)
                T = SingleRotateWithLeft(T);
            else
                T = DoubleRotateWithLeft(T);
        }
    }
    else if (X > T->Element)
    {
        T->Right = Insert(X, T->Right);
        if (Height(T->Right) - Height(T->Left) == 2)
        {
            if (X > T->Right->Element)
                T = SingleRotateWithRight(T);
            else
                T = DoubleRotateWithRight(T);
        }
    }
    /* Else X is in the tree already; we'll do nothing */

    T->Height = Max(Height(T->Left), Height(T->Right)) + 1;
    return T;
}

AvlTree Delete(ElementType X, AvlTree T)
{
    Position TmpCell;

    if (T == NULL)
        Error("Element not found");
    else if (X < T->Element)  /* Go left */
        T->Left = Delete(X, T->Left);
    else if (X > T->Element)  /* Go right */
        T->Right = Delete(X, T->Right);

    /* Found element to be deleted */
    else if (T->Left && T->Right)  /* Two children */
    {
        /* Replace with smallest in right subtree */
        TmpCell = FindMin(T->Right);
        T->Element = TmpCell->Element;
        T->Right = Delete(T->Element, T->Right);
    }
    else  /* One or zero children */
    {
        TmpCell = T;
        if (T->Left == NULL) /* Also handles 0 children */
            T = T->Right;
        else if (T->Right == NULL)
            T = T->Left;
        free(TmpCell);
    }

    if (T != NULL)
    {
        if (Height(T->Left) - Height(T->Right) == 2)
        {
            if (Height(T->Left->Left) >= Height(T->Left->Right))
                T = SingleRotateWithLeft(T);
            else
                T = DoubleRotateWithLeft(T);
        }
        else if (Height(T->Right) - Height(T->Left) == 2)
        {
            if (Height(T->Right->Right) >= Height(T->Right->Left))
                T = SingleRotateWithRight(T);
            else
                T = DoubleRotateWithRight(T);
        }

        T->Height = Max(Height(T->Left), Height(T->Right)) + 1;
    }

    return T;
}

ElementType Retrieve(Position P)
{
    return P->Element;
}

void PreorderTraversal(AvlTree T)
{
    if (T != NULL)
    {
        printf("%d\t", T->Element);
        PreorderTraversal(T->Left);
        PreorderTraversal(T->Right);
    }
}

void InorderTraversal(AvlTree T)
{
    if (T != NULL)
    {
        InorderTraversal(T->Left);
        printf("%d\t", T->Element);
        InorderTraversal(T->Right);
    }
}

void PostorderTraversal(AvlTree T)
{
    if (T != NULL)
    {
        PostorderTraversal(T->Left);
        PostorderTraversal(T->Right);
        printf("%d\t", T->Element);
    }
}

void LevelorderTraversal(AvlTree T)
{
    Queue Q;
    AvlTree TmpCell;

    if (T == NULL)
        return;

    Q = CreateQueue(80);
    Enqueue(T, Q);
    while (!IsEmptyQueue(Q))
    {
        TmpCell = FrontAndDequeue(Q);
        printf("%d\t", TmpCell->Element);
        if (TmpCell->Left != NULL)
            Enqueue(TmpCell->Left, Q);
        if (TmpCell->Right != NULL)
            Enqueue(TmpCell->Right, Q);
    }
}

queue.c

#include "avltree.h"
#include "queue.h"
#include "fatal.h"
#include <stdlib.h>

#define MinQueueSize ( 5 )

struct QueueRecord
{
    int Capacity;
    int Front;
    int Rear;
    int Size;
    AvlTree *Array;
};

int IsEmptyQueue(Queue Q)
{
    return Q->Size == 0;
}

int IsFullQueue(Queue Q)
{
    return Q->Size == Q->Capacity;
}

Queue CreateQueue(int MaxElements)
{
    Queue Q;

    if (MaxElements < MinQueueSize)
        Error("Queue size is too small");

    Q = malloc(sizeof(struct QueueRecord));
    if (Q == NULL)
        FatalError("Out of space!!!");

    Q->Array = malloc(sizeof(AvlTree) * MaxElements);
    if (Q->Array == NULL)
        FatalError("Out of space!!!");
    Q->Capacity = MaxElements;
    MakeEmptyQueue(Q);

    return Q;
}

void MakeEmptyQueue(Queue Q)
{
    Q->Size = 0;
    Q->Front = 1;
    Q->Rear = 0;
}

void DisposeQueue(Queue Q)
{
    if (Q != NULL)
    {
        free(Q->Array);
        free(Q);
    }
}

static int Succ(int Value, Queue Q)
{
    if (++Value == Q->Capacity)
        Value = 0;
    return Value;
}

void Enqueue(AvlTree X, Queue Q)
{
    if (IsFullQueue(Q))
        Error("Full queue");
    else
    {
        Q->Size++;
        Q->Rear = Succ(Q->Rear, Q);
        Q->Array[Q->Rear] = X;
    }
}

AvlTree Front(Queue Q)
{
    if (!IsEmptyQueue(Q))
        return Q->Array[Q->Front];
    Error("Empty queue");
    return 0;  /* Return value used to avoid warning */
}

void Dequeue(Queue Q)
{
    if (IsEmptyQueue(Q))
        Error("Empty queue");
    else
    {
        Q->Size--;
        Q->Front = Succ(Q->Front, Q);
    }
}

AvlTree FrontAndDequeue(Queue Q)
{
    AvlTree X = 0;

    if (IsEmptyQueue(Q))
        Error("Empty queue");
    else
    {
        Q->Size--;
        X = Q->Array[Q->Front];
        Q->Front = Succ(Q->Front, Q);
    }
    return X;
}

testavl.c

#include "avltree.h"
#include "queue.h"
#include <stdio.h>

int main()
{
    AvlTree T;
    int i;
    int j = 0;

    T = MakeEmpty(NULL);
    printf("Insert:\n");
    for (i = 0; i < 50; i++, j = (j + 7) % 50)
    {
        printf("%d\t", j);
        T = Insert(j, T);
    }
    printf("\n先序遍历：\n");
    PreorderTraversal(T);
    printf("\n中序遍历：\n");
    InorderTraversal(T);
    printf("\n后序遍历：\n");
    PostorderTraversal(T);
    printf("\n层序遍历：\n");
    LevelorderTraversal(T);
    printf("\n\n");

    printf("Delete:\n");
    for (i = 0; i < 50; i += 2)
    {
        printf("%d\t", i);
        T = Delete(i, T);
    }
    printf("\n先序遍历：\n");
    PreorderTraversal(T);
    printf("\n中序遍历：\n");
    InorderTraversal(T);
    printf("\n后序遍历：\n");
    PostorderTraversal(T);
    printf("\n层序遍历：\n");
    LevelorderTraversal(T);
    printf("\n\n");

    printf("Min is %d, Max is %d\n", Retrieve(FindMin(T)), Retrieve(FindMax(T)));

    return 0;
}

转载于:https://www.cnblogs.com/typewriter/p/6270158.html

weixin_30709061
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【算法】数据结构与算法分析学习笔记——第四章AVL树C语言实现
jyyyyyy
01-10 1635
看《数据结构与算法分析》第四章时介绍到了一个AVL树的东西 对于节点删除，书上只是提了一下惰性删除，也没有给出例程，这里就试着实现非惰性删除 实现的方法同二叉查找树，找一个左子树的最大节点进行替换，递归删除，并做及时的AVL树维护
AVLTree：具有以下操作的通用AVL树实现：插入，删除，搜索，上下限，最近的元素，范围内的值等
02-25
问题：AVL树目的：了解平衡二叉搜索树的端到端知识，以及如何将其有效地用于解决各种问题。 任务：通过以下操作实现AVL树。...9. Count the number of elements in the tree whose values fall into a given range.
C++之AVL树和红黑树
weixin_56054625的博客
09-27 690
因此，两位俄罗斯的数学家G.M.Adelson-Velskii和E.M.Landis在1962年发明了一种解决上述问题的方法：当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之差的绝对值不超过1(需要对树中的结点进行调整)，即可降低树的高度，从而减少平均搜索长度。因为AVL树也是二叉搜索树，可按照二叉搜索树的方式将节点删除，然后再更新平衡因子，只不过与删除不同的是，删除节点后的平衡因子更新，最差情况下一直要调整到根节点的位置。，更差的是在删除时，有可能一直要让旋转持续到根的位置。
c++ - 第17节 - AVL树和红黑树
qq_45113223的博客
12-13 425
{// 右子树-左子树的高度差int _bf;};注：1.AVL树使用三叉链，每个树结点中使用_parent成员变量保存其父节点的地址。2.树节点中有一个_bf成员变量，该成员变量是balance factor的缩写，记录该节点右子树-左子树的高度差。AVL树并没有规定必须要设计平衡因子，这里使用平衡因子只是一个实现的选择，方便控制平衡。1.3.AVL树的插入%5Cbullet%5Cbullet。
程序员修炼手册--AVLTree实现--附源代码
c-and-c++ It*s my life
06-04 301
AVLtree三叉链实现
数据结构之 AVL树（平衡二叉树）（C语言实现）
men_wen的博客
03-31 4978
AVL树（平衡二叉树）1. AVL树定义和性质AVL（Adelson-Velskii和Landis发明者的首字母）树时带有平衡条件的二叉查找树。二叉查找树的性能分析： 在一颗左右子树高度平衡情况下，最优的时间复杂度为O(log2nlog_2{n})，这与这半查找相同； 在一个只有右子树的二叉树中，最差的时间复杂度会脱变为线性查找O(n)。 二叉查找树的实现：二叉查找树的C语言实现由于二叉查找树存在以
avl.rar_avl_avl tree_binary tree_tree
09-20
AVL树，全称为Adelson-Velsky和Landis树，是最早被提出的自平衡二叉查找树（Binary Search Tree, BST），由俄罗斯计算机科学家Georgy Adelson-Velsky和Eduard Landis在1962年提出。AVL树的名字来源于这两位发明者的...
trees_programs.tar.gz_tree
09-14
3. **平衡二叉树**：左右子树的高度差不超过1，如AVL树和红黑树，确保查找效率。 4. **堆**：一种特殊的树形数据结构，满足堆性质（最大堆或最小堆）。 5. **B树**和**B+树**：常用于数据库和文件系统，支持高效的...
SimpleTree1.3.zip
02-03
5. **平衡树**：为了优化查找效率，可能会使用AVL树或红黑树等自平衡二叉查找树，它们在插入和删除后能自动调整，保持高度平衡。 6. **树的遍历和应用**：在实际问题中，如文件系统的目录结构、HTML DOM解析、...
05 ParentTree.rar
01-07
树的常见类型包括二叉树、满二叉树、完全二叉树、平衡二叉树（如AVL树、红黑树）、B树、B+树等。在这些树中，每个节点的子节点数量受到特定限制，从而拥有不同的特性，适用于不同的应用场景。 “ParentTree”可能...
AVL树头文件C语言(AVLTree.h)
让阳光照进心里
10-01 2150
我的第一颗AVL树.弄了一天,虽然还没有最终测试完毕./* AVLTree.h -- AVl树头文件 */ /* 数据类型定义 */ typedef int Item ; typedef struct node { Item item ; struct node * left ; struct node * right ; int height ; } Node ; typedef Node * Position ; typedef Position Tree ;
算法（6） —— AVL树
weixin_34161032的博客
09-06 89
AVL树二叉查找树的一种，所以其操作和二叉查找树的很多操作是相同的。 1. 1 #ifndef AVLTREE_H 2 #define AVLTREE_H 3 4 struct AvlNode; 5 typedef struct AvlNode *Position; 6 typedef struct AvlNode *AvlTree; 7 8 typ...
平衡二叉树(AVLTree)
艰难困苦如同欢乐，终将成为人生最后的财富
03-20 794
平衡二叉树（AVLTree）是指带平衡条件的二叉查找树。AVLTree要求每个节点的左子树和右子树的高度之差最多为1。当因为插入或删除操作导致AVLTree不满足该平衡条件时就需要进行调整操作，包括单旋转和双旋转操作。也正是因为需要时刻保持树的平衡条件，从而使得AVLTree的插入和删除操作较为复杂。
AVL树插入删除算法详解（有图） -- C++语言实现
热门推荐
FreeeLinux's blog
08-14 1万+
一：AVL树介绍 AVL树本质上还是一棵二叉搜索树，它的特点是： 1.本身首先是一棵二叉搜索树。 2.带有平衡条件：每个结点的左右子树的高度之差的绝对值（平衡因子）最多为1。在本文中用分别用-1，0，1定义左边树高，等高，右边树高。平衡因子用m_bf表示。 也就是说，AVL树，本质上是带了平衡功能的二叉查找树（二叉排序树，二叉搜索树）。 二：插入算法 由于AVL树具有BST树的
AVL 树
cai0612123的专栏
08-01 176
AVL Tree
AVL树的插入与删除
早起的虫儿灬
05-18 372
本来之前已经发了AVL树的插入，结果续写AVL树的删除时发现之前写的AVL插入有bug，于是乎将其删除了。折腾了一周多，终于将AVL树搞定了。。。不容易啊 //AVLTree.h #ifndef _AVLTREE_H_ #define _AVLTREE_H_ #include typedef int Element; typedef struct _AVLTreeNode { El
c avltree - 未测试
春来江水绿如蓝
09-06 1835
avltree.h typedef int ElementType; /* START: fig4_35.txt */ #ifndef _AvlTree_H #define _AvlTree_H struct AvlNode; typedef struct AvlNode *Position;
数据结构与算法4：二叉树2（平衡二叉树）
cling60的专栏
11-07 306
代码转自：http://www.cnblogs.com/skywang12345/p/3576969.html，图文并茂，此处只用于个人备份，感谢原作者skywang12345 avl_tree.h： #ifndef _AVL_TREE_H_ #define _AVL_TREE_H_ typedef int Type; typedef struct AVLTreeNode{
Construct an AVL tree from inserting the values 5, 2, 9, 6, 3, 8, 1 in that order. How many total rotations are needed during the construction of the tree to keep it balanced? A. 0 B. 1 C. 2 D. 3 E. 4
最新发布
05-24
To construct an AVL tree from inserting the values 5, 2, 9, 6, 3, 8, 1 in that order, we start with the root node 5 and then insert each subsequent node according to the rules of an AVL tree. ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值