平衡二叉树思想及C语言实现

最新推荐文章于 2024-09-07 14:22:27 发布
转载 最新推荐文章于 2024-09-07 14:22:27 发布 · 411 阅读 · 1
文章标签：

#c语言

本文介绍了平衡二叉树的概念及其关键特性，并深入探讨了AVL树的插入与平衡调整方法，包括单旋转与双旋转的具体实现。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >


形态匀称的二叉树称为平衡二叉树 (Balanced binary tree) ，其严格定义是：
　　一棵空树是平衡二叉树；若 T 是一棵非空二叉树，其左、右子树为 TL 和 TR ，令 hl 和 hr 分别为左、右子树的深度。当且仅当
　　　①TL 、 TR 都是平衡二叉树；
　　　② ｜ hl － hr ｜≤ 1；
时，则 T 是平衡二叉树。
【例】如图 8.3 所示。
         
             （a）平衡二叉树           （b）非平衡二叉树
                      图8.3 平衡二叉树与非平衡二叉树
相应地定义 hl － hr 为二叉平衡树的平衡因子 (balance factor) 。因此，平衡二叉树上所有结点的平衡因子可能是 -1 ， 0 ， 1 。换言之，若一棵二叉树上任一结点的平衡因子的绝对值都不大于 1 ，则该树是就平衡二叉树。
动态平衡技术
1.动态平衡技术
Adelson-Velskii 和 Landis 提出了一个动态地保持二叉排序树平衡的方法，其基本思想是：
　　在构造二叉排序树的过程中，每当插入一个结点时，首先检查是否因插入而破坏了树的平衡性，如果是因插入结点而破坏了树的平衡性，则找出其中 最小不平衡子树，在保持排序树特性的前提下，调整最小不平衡子树中各结点之间的连接关系，以达到新的平衡。通常将这样得到的平衡二叉排序树简称为 AVL 树。
2.最小不平衡子树
　　以离插入结点最近、且平衡因子绝对值大于 1 的结点作根结点的子树。为了简化讨论，不妨假设二叉排序树的最小不平衡子树的根结点为 A ，则调整该子树的规律可归纳为下列四种情况：
（1） LL 型：
　　新结点 X 插在 A 的左孩子的左子树里。调整方法见图 8.5(a) 。图中以 B 为轴心，将 A 结点从 B 的右上方转到 B 的右下侧，使 A 成为 B 的右孩子。
      
          图8.5 平衡调整的4种基本类型（结点旁的数字是平衡因子）
（2）RR 型：
　　新结点 X 插在 A 的右孩子的右子树里。调整方法见图 8.5(b) 。图中以 B 为轴心，将 A 结点从 B 的左上方转到 B 的左下侧，使 A 成为 B 的左孩子。
（3）LR 型：
　　新结点 X 插在 A 的左孩子的右子树里。调整方法见图 8.5(c) 。分为两步进行：第一步以 X 为轴心，将 B 从 X 的左上方转到 X 的左下侧，使 B 成为 X 的左孩子， X 成为 A 的左孩子。第二步跟 LL 型一样处理 ( 应以 X 为轴心 ) 。
（4）RL 型：
　　新结点 X 插在 A 的右孩子的左子树里。调整方法见图 8.5(d) 。分为两步进行：第一步以 X 为轴心，将 B 从 X 的右上方转到 X 的右下侧，使 B 成为 X 的右孩子， X 成为 A 的右孩子。第二步跟 RR 型一样处理 ( 应以 X 为轴心 ) 。
【例】
实际的插入情况，可能比图 8.5 要复杂。因为 A 、 B 结点可能还会有子树。现举一例说明，设一组记录的关键字按以下次序进行插入： 4 、 5 、 7 ， 2 、 1 、 3 、 6 ，其生成及调整成二叉平衡树的过程示于图 8.6 。
　　在图 8.6 中，当插入关键字为 3 的结点后，由于离结点 3 最近的平衡因子为 2 的祖先是根结点 5 。所以，第一次旋转应以结点 4 为轴心，把结点 2 从结点 4 的左上方转到左下侧，从而结点 5 的左孩子是结点 4 ，结点 4 的左孩子是结点 2 ，原结点 4 的左孩子变成了结点 2 的右孩子。第二步再以结点 4 为轴心，按 LL 类型进行转换。这种插入与调整平衡的方法可以编成算法和程序，这里就不再讨论了。

         图 8.6 二叉平衡树插入结点 ( 结点旁的数字为其平衡因子 )

代码实现：
utl.h

#ifndef UTL_H_
#define UTL_H_
/*
 *整理了一些常用的功能，如内存管理
 */
#include<stdio.h>
#include<stdlib.h>

/*申请内存*/
inline void*xalloc(int size)
{
    void *p;
    p = (void*)malloc(size);
    /*申请失败*/
    if(p==NULL)
    {
        printf("alloc error\n");
        exit(1);
    }
    return p;
}
/*内存释放*/
#define xfree(p)free(p)

#endif


avl.h

#ifndef AVL_H__
#define AVL_H__
/*
 *avl树数据结构及相关操作
 */
#include<stdio.h>
#include<stdlib.h>

struct AVLTree
{
    unsigned int nData;    /*存储数据*/
    struct AVLTree* pLeft;    /*指向左子树*/
    struct AVLTree* pRight;    /*指向右子树*/
    int nHeight;    /*树的平衡度*/
};

/*插入操作*/
struct AVLTree* insert_tree(unsignedint nData,struct AVLTree* pNode);

/*查找操作，找到返回1，否则，返回0*/
int find_tree(unsignedint data,struct AVLTree* pRoot);

/*删除操作,删除所有节点*/
void delete_tree(struct AVLTree** ppRoot);

/*打印操作*/
void print_tree(struct AVLTree* pRoot);

#endif


avl.c

#include"avl.h"

#include "utl.h"

static intMax(int a,int b);
static int Height(struct AVLTree* pNode);

/*旋转操作*/
static struct AVLTree* SingleRotateWithLeft(struct AVLTree* pNode);
static struct AVLTree* SingleRotateWithRight(struct AVLTree* pNode);
static struct AVLTree* DoubleRotateWithLeft(struct AVLTree* pNode);
static struct AVLTree* DoubleRotateWithRight(struct AVLTree* pNode);

struct AVLTree* insert_tree(unsignedint nData,struct AVLTree* pNode)
{
    if (NULL== pNode)
    {
        pNode = (struct AVLTree*)xalloc(sizeof(struct AVLTree));
        pNode->nData= nData;
        pNode->nHeight= 0;
        pNode->pLeft= pNode->pRight=NULL;
    }
    else if (nData < pNode->nData)    /*插入到左子树中*/
    {
        pNode->pLeft= insert_tree(nData, pNode->pLeft);
        if (Height(pNode->pLeft)- Height(pNode->pRight)== 2)    /*AVL树不平衡*/
        {
            if (nData< pNode->pLeft->nData)
            {
                /*插入到了左子树左边, 做单旋转*/
                pNode = SingleRotateWithLeft(pNode);
            }
            else
            {
                /*插入到了左子树右边, 做双旋转*/
                pNode = DoubleRotateWithLeft(pNode);
            }
        }
    }
    else if (nData > pNode->nData)    /*插入到右子树中*/
    {
        pNode->pRight= insert_tree(nData, pNode->pRight);
        if (Height(pNode->pRight)- Height(pNode->pLeft)== 2)    /*AVL树不平衡*/
        {
            if (nData> pNode->pRight->nData)
            {
                /*插入到了右子树右边, 做单旋转*/
                pNode = SingleRotateWithRight(pNode);
            }
            else
            {
                /*插入到了右子树左边, 做双旋转*/
                pNode = DoubleRotateWithRight(pNode);
            }
        }
    }

    pNode->nHeight=Max(Height(pNode->pLeft), Height(pNode->pRight))+ 1;

    return pNode;
}


/*删除树*/
void delete_tree(struct AVLTree** ppRoot)
{
    if (NULL== ppRoot||NULL==*ppRoot)
        return;

    delete_tree(&((*ppRoot)->pLeft));
    delete_tree(&((*ppRoot)->pRight));
    xfree(*ppRoot);
    *ppRoot = NULL;
}

/*中序遍历打印树的所有结点, 因为左结点 < 父结点 < 右结点, 因此打印出来数据的大小是递增的*/
void print_tree(struct AVLTree* pRoot)
{
    if (NULL== pRoot)
        return;

    static int n= 0;


    print_tree(pRoot->pLeft);
    printf("[%d]nData = %u\n",++n, pRoot->nData);
    print_tree(pRoot->pRight);
}

/*
 *查找操作，找到返回1，否则，返回0
 *data是待查找的数据
 *pRoot:avl树的指针
 */
int find_tree(unsignedint data,struct AVLTree* pRoot)
{
    static int k=1;    /*查找次数*/
    if (NULL== pRoot)
    {
        printf("not find %d times\n", k);
        return 0;
    }

    if(data== pRoot->nData)
    {
        printf("find:%d times\n", k);
        return 1;
    }
    else if(data< pRoot->nData)
    {
        ++k;
        return find_tree(data, pRoot->pLeft);
    }
    else if(data> pRoot->nData)
    {
        ++k;
        return find_tree(data, pRoot->pRight);
    }
}

static intMax(int a,int b)
{
    return (a > b ? a : b);
}

/*返回节点的平衡度*/
static int Height(struct AVLTree* pNode)
{
    if (NULL== pNode)
        return -1;

    return pNode->nHeight;
}

/********************************************************************
      pNode pNode->pLeft
      / \
  pNode->pLeft ==> pNode
      \     /
  pNode->pLeft->pRight pNode->pLeft->pRight
 *********************************************************************/
static struct AVLTree* SingleRotateWithLeft(struct AVLTree* pNode)
{
    struct AVLTree* pNode1;

    pNode1 = pNode->pLeft;
    pNode->pLeft= pNode1->pRight;
    pNode1->pRight= pNode;

    /*结点的位置变了, 要更新结点的高度值*/
    pNode->nHeight=Max(Height(pNode->pLeft), Height(pNode->pRight))+ 1;
    pNode1->nHeight=Max(Height(pNode1->pLeft), pNode->nHeight)+ 1;

    return pNode1;
}

/********************************************************************
  pNode pNode->pRight
  \ /
  pNode->pRight ==> pNode
  / \
  pNode->pRight->pLeft pNode->pRight->pLeft
 *********************************************************************/
static struct AVLTree* SingleRotateWithRight(struct AVLTree* pNode)
{
    struct AVLTree* pNode1;

    pNode1 = pNode->pRight;
    pNode->pRight= pNode1->pLeft;
    pNode1->pLeft= pNode;

    /*结点的位置变了, 要更新结点的高度值*/
    pNode->nHeight=Max(Height(pNode->pLeft), Height(pNode->pRight))+ 1;
    pNode1->nHeight=Max(Height(pNode1->pRight), pNode->nHeight)+ 1;

    return pNode1;
}

static struct AVLTree* DoubleRotateWithLeft(struct AVLTree* pNode)
{
    pNode->pLeft= SingleRotateWithRight(pNode->pLeft);

    return SingleRotateWithLeft(pNode);
}

static struct AVLTree* DoubleRotateWithRight(struct AVLTree* pNode)
{
    pNode->pRight= SingleRotateWithLeft(pNode->pRight);

    return SingleRotateWithRight(pNode);
}


测试：

#include

#include

#include "avl.h"

int main()
{
    int i,j;
    AVLTree* pRoot =NULL;

    srand((unsignedint)time(NULL));
    
    for (i = 0; i< 10;++i)
    {
            j = rand();
            printf("%d\n", j);
        pRoot = Insert(j, pRoot);
    }

    PrintTree(pRoot);

    DeleteTree(&pRoot);

    return 0;
}






删除节点

从AVL树中删除节点分为两个步骤：首先删除节点；然后调整平衡。删除操作对应为插入操作的逆向操作，调整平衡的时候也需要确定被删除节点的分支构型来选择合适的旋转方法。

// delete the given key from AVL tree.
avlnode* avl_delete(avltree* &tree, keyType key) {
 if (NULL == tree) {
  return NULL;
 }
 // delete the node with the given key
 if (key > tree->key) { // key exists in the right subtree
  tree->right = avl_delete(tree->right, key);
 } else if (key < tree->key) { // key exists in the left subtree
  tree->left = avl_delete(tree->left, key);
 } else {
  if (NULL != tree->left) { // when left is not NULL
   // find max node if left tree
   avlnode* dn = NULL;
   for (dn = tree->left; NULL != dn->right; dn = dn->right) {
   }
   // change the value
   tree->key = dn->key;
   // delete the max node
   tree->left = avl_delete(tree->left, dn->key);
  } else if (NULL != tree->right) { // when the right tree is not NULL
   // find the minimal node
   avlnode* dn = NULL;
   for (dn = tree->right; NULL != dn->left; dn = dn->left) {
   }
   // change the value
   tree->key = dn->key;
   // delete the minimal node
   tree->right = avl_delete(tree->right, dn->key);
  } else {   // when the node has no child
   free(tree);
   // the tree is Empty now, no need to do any operation
   return NULL;
  }
 }
 // adjust the tree to balance state after deletion
 if (height(tree->left) - height(tree->right) == 2) { // when the left subtree is too high
  if (height(tree->left->right) - height(tree->left->left) == 1) { // LR model
   tree = leftRightRotate(tree);
  } else { // LL model
   tree = singleRightRotate(tree);
  }
 } else if (height(tree->left) - height(tree->right) == -2) { // when the right subtree is too high
  if (height(tree->right->left) - height(tree->right->right) == 1) { // RL model
   tree = rightLeftRotate(tree);
  } else { // RR model
   tree = singleLeftRotate(tree);
  }
 } else {
  // the tree is already balanced, nothing to do ...
 }

 // recalculate the height of the tree.
 tree->height = maxh(height(tree->right), height(tree->left)) + 1;

 return tree;
}




URL:http://blog.youkuaiyun.com/whucyl/article/details/17289841



mchine_swift
关注
请要相信我，30分钟让你掌握AVL树（平衡二叉树）
BpLife
08-15 1万+
平衡二叉树定义(AVL)：它或者是一颗空树，或者具有以下性质的二叉树：它的左子树和右子树的深度之差(平衡因子)的绝对值不超过1，且它的左子树和右子树都是一颗平衡二叉树。 平衡因子(bf)：结点的左子树的深度减去右子树的深度，那么显然-1 #define EH 0,#define LH 1,#define RH -1.依次为等高，左高，右高。 我们都知道，平衡二叉树是在二叉排序树(B
平衡二叉树
最新发布
qq_73792226的博客
02-19 318
int val;int height;// 节点高度AVL 树通过旋转操作保持树的平衡，确保操作的时间复杂度为 O(log⁡n)O(logn)。插入和删除操作需要更新节点高度并检查平衡因子，必要时进行旋转。AVL 树适用于需要频繁插入、删除和查找的场景。
数据结构之 平衡二叉树
超纯的小白兔
10-01 2284
平衡二叉树，是一种二叉排序树，其中每个结点的左子树和右子树的高度差至多等于1。它是一种高度平衡的二叉排序树。高度平衡？意思是说，要么它是一棵空树，要么它的左子树和右子树都是平衡二叉树，且左子树和右子树的深度之差的绝对值不超过1。     将二叉树上结点的左子树深度减去右子树深度的值称为平衡因子BF，那么平衡二叉树上的所有结点的平衡因子只可能是-1、0和1。只要二叉树上有一个结点的平衡因子的绝
讲解平衡二叉树的实现（C语言）
weixin_62756978的博客
04-06 1846
讲解如何实现平衡二叉树的构造、增加节点、删除节点等操作。
数据结构之平衡二叉树C语言版
Cukor丘克的博客
04-16 4973
作者：Cukor Zhong 什么是平衡二叉树 平衡二叉树是具有平衡属性的有序二叉树，所谓的平衡即当前树的左右子树高度差的绝对值不超过1。因为平衡二叉树是由苏联数学家Adelson-Velskii和Landis提出，所以又称为AVL树。 平衡二叉树的基本特点 是特殊的有序二叉树 左右子树高度差的绝对值不超过1 左右子树仍然是平衡二叉树
平衡二叉树(C语言简单实现)
DFGOMC的博客
11-24 3858
平衡二叉树(C语言简单实现) 本文参考自《大话数据结构》 平衡二叉树是一种二叉排序树，其中每一个结点的左子树和右子树的高度差至多等于1 。 将二叉树上结点的左子树深度减去右子树深度的值称为平衡因子BF（Balance Factor）。 平衡二叉树首先必须是一棵二叉排序树，同时任一结点的左子树和右子树的高度差最多等于1 。 距离插入结点最近的，且平衡因子的绝对值大于1的结点为根的子树，我们称为最小不平衡子树 。 平衡二叉树实现原理 平衡二叉树构建的基本思想就是在构建二叉排序树的过程中，每当插入一个结点时，
数据结构--二叉树（C语言实现，超详细！！！）
2301_79381549的博客
09-07 3744
这段代码定义了一个简单的二叉树节点结构体，其中包含指向左子树和右子树的指针以及一个整数值。通过这种结构，我们可以构建一个二叉树，其中每个节点都有一个值，以及可能存在的左子树和右子树。// 首先，定义一个结构体类型别名BinTreeNode，这个结构体用于表示二叉树的节点。// left是一个指向左子树根节点的指针。// 在二叉树中，每个节点最多有两个子节点，这里left表示节点的左子树。// right是一个指向右子树根节点的指针。// 与left相似，right表示节点的右子树。
二叉树的C语言实现及遍历
sy1227081317的博客
01-23 2076
前言 树是一种十分重要的基础数据结构。很多实际问题都会抽象成树来解决。而这篇文章要讲的二叉树则是树中最基本又很重要的一种特殊树。它只的是每个节点的度不大于2的树。 基于二叉树还有很多衍生的树。查找树，红黑树，平衡树等等等等。 基础思路 二叉树可以很形象的看做是一个递归的产物。所以二叉树的问题，基本都可以用递归来解决。无论一颗二叉树是什么样子的。他都可以看做三部分：本节点，左子树，右子树。 左子树也可以看成本节点，左子树，右子树。这样的结构。 就像图片上这样。所以一个树的节点需要三部分。保存本节点的数据。
平衡二叉树的实现实例
09-04
主要介绍了平衡二叉树的实现实例,需要的朋友可以参考下
平衡二叉树的原理与实现（转载）
qq_43735840的博客
07-09 270
平衡二叉树
C语言实现平衡二叉树构建详解
在C语言中实现平衡二叉树的创建，需要掌握二叉树的基本概念、二叉搜索树的性质以及节点平衡的概念与调整方法。 ### 二叉树的基本概念 在开始实现之前，需要了解二叉树的定义及其基本操作，包括节点结构的定义、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值