平衡二叉树(AVL)

最新推荐文章于 2025-09-10 15:24:29 发布
转载 最新推荐文章于 2025-09-10 15:24:29 发布 · 50 阅读 · 0 ·
CC 4.0 BY-SA版权
原文链接：http://www.cnblogs.com/venow/archive/2012/08/09/2629094.html
文章标签：

#数据结构与算法 

#include "stdafx.h"
#include <iostream>
#include <iomanip>
#include <stack>
#include <queue>
#include <Windows.h>
using namespace std;

typedef struct _Node
{
    int data;
    struct _Node *left;
    struct _Node *right;
    int bf;              //平衡因子
    _Node()
    {
        data = 0;
        left = NULL;
        right = NULL;
        bf = 0;
    }
}Node, *_PNode;

//******************************************AVL**********************************************begin

//参考 维基百科 AVL : http://zh.wikipedia.org/wiki/AVL%E6%A0%91
//                  http://www.cnblogs.com/abatei/archive/2008/11/17/1335031.html

//右旋
_PNode AVLLLTree(_PNode pNode)
{
    _PNode pNewNode = pNode->left;
    pNode->left = pNewNode->right;
    pNewNode->right = pNode;
    if (pNewNode->bf == 1)
    {
        pNode->bf = 0;
        pNewNode->bf = 0;
    }
    else
    {
        pNode->bf = 1;
        pNewNode->bf = -1;
    }
    return pNewNode;
}

//左旋
_PNode AVLRRTree(_PNode pNode)
{
    _PNode pNewNode = pNode->right;
    pNode->right = pNewNode->left;
    pNewNode->left = pNode;
    if (pNewNode->bf == -1)
    {
        pNode->bf = 0;
        pNewNode->bf = 0;
    }
    else
    {
        pNode->bf = -1;
        pNewNode->bf = 1;
    }
    return pNewNode;
}

//先右旋再左旋
_PNode AVLLRTree(_PNode pNode)
{
    _PNode pLeft = pNode->left;
    _PNode pNewNode = pLeft->right;
    pLeft->right = pNewNode->left;
    pNode->left = pNewNode->right;
    pNewNode->left = pLeft;
    pNewNode->right = pNode;
    switch (pNewNode->bf )
    {
    case 1:
        pLeft->bf = 0;
        pNode->bf = -1;
        break;
    case -1:
        pLeft->bf = 1;
        pNode->bf = 0;
        break;
    }
    pNewNode->bf = 0;
    return pNewNode;
}

//先左旋再右旋
_PNode AVLRLTree(_PNode pNode)
{
    _PNode pRight = pNode->right;
    _PNode pNewNode = pRight->left;
    pRight->left = pNewNode->right;
    pNode->right = pNewNode->left;
    pNewNode->left = pNode;
    pNewNode->right = pRight;
    switch (pNewNode->bf)
    {
    case 1:
        pNode->bf = 0;
        pRight->bf = -1;
        break;
    case -1:
        pNode->bf = 1;
        pRight->bf = 0;
        break;
    }
    pNewNode->bf = 0;
    return pNewNode;
}

_PNode pAvlRoot = NULL;    //AVL的根节点
stack<_PNode> sAvl;        //保存从根节点到插入点的路径节点

bool AVLRotateTree(_PNode pNode, int bf)
{
    bool bTallChange = true;
    _PNode pChild;
    _PNode pNewNode;
    if (2 == bf)
    {
        pChild = pNode->left;
        if (1 == pChild->bf)
        {
            pNewNode = AVLLLTree(pNode);
        }
        else if (-1 == pChild->bf)
        {
            pNewNode = AVLLRTree(pNode);
        }
        else
        {
            pNewNode = AVLLLTree(pNode);
            bTallChange = false;
        }
    }
    else if (-2 == bf)
    {
        pChild = pNode->right;
        if (1 == pChild->bf)
        {
            pNewNode = AVLRLTree(pNode);
        }
        else if (-1 == pChild->bf)
        {
            pNewNode = AVLRRTree(pNode);
        }
        else
        {
            pNewNode = AVLRRTree(pNode);
            bTallChange = false;
        }
    }
    if (!sAvl.empty())
    {
        _PNode pParent = sAvl.top();
        if (pParent->data > pNewNode->data)
        {
            pParent->left = pNewNode;
        }
        else if (pParent->data < pNewNode->data)
        {
            pParent->right = pNewNode;
        }
    }
    else
    {
        pAvlRoot = pNewNode;
    }
    return bTallChange;
}

//插入节点
void AVLInsertNode(int key)
{
    if (BSTSearch(pAvlRoot, key))  //找到，不能插入直接返回
    {
        return;
    }
    _PNode pNode = new Node;
    pNode->data = key;
    if (NULL == pAvlRoot)
    {
        pAvlRoot = pNode;
        return;
    }
    while (!sAvl.empty()) //清空栈
    {
        sAvl.pop();
    }
    _PNode p = pAvlRoot;
    while (NULL != p)
    {
        sAvl.push(p);
        if (key < p->data)
        {
            p = p->left;
        }
        else if (key > p->data)
        {
            p = p->right;
        }
    }
    _PNode pre = sAvl.top();
    if (key < pre->data)
    {
        pre->left = pNode;
    }
    else if (key > pre->data)
    {
        pre->right = pNode;
    }
    int bf;
    while (!sAvl.empty())
    {
        pre = sAvl.top();
        sAvl.pop();
        bf = (pre->data > key) ? 1 : -1;
        pre->bf += bf;
        bf = pre->bf;
        if (bf == 0)
        {
            break;
        }
        else if (2 == bf || -2 == bf)
        {
            AVLRotateTree(pre, bf);
            break;
        }
    }
}

//删除节点
void AVLRemoveNode(int key)
{
    _PNode pNode = pAvlRoot;
    while (!sAvl.empty())
    {
        sAvl.pop();
    }
    while (NULL != pNode)
    {
        if (key < pNode->data)
        {
            sAvl.push(pNode);
            pNode = pNode->left;
        }
        else if (key > pNode->data)
        {
            sAvl.push(pNode);
            pNode = pNode->right;
        }
        else
        {
            _PNode pPreNode = sAvl.top();
            if (NULL == pNode->left || NULL == pNode->right)  //3、该节点只有一条子树
            {
                if (NULL != pNode->left)
                {
                    if (pNode == pAvlRoot)
                    {
                        pAvlRoot = pNode->left;
                    }
                    else if (pPreNode->left == pNode)
                    {
                        pPreNode->left = pNode->left;
                    }
                    else
                    {
                        pPreNode->right = pNode->left;
                    }
                }
                else
                {
                    if (pNode == pAvlRoot)
                    {
                        pAvlRoot = pNode->right;
                    }
                    else if (pPreNode->left == pNode)
                    {
                        pPreNode->left = pNode->right;
                    }
                    else
                    {
                        pPreNode->right = pNode->right;
                    }
                }
            }
            else  //4、该节点有左右子树
            {
                _PNode pPre = pNode;
                sAvl.push(pNode);
                _PNode pSearch = pNode->right;
                while (NULL != pSearch->left)  //5、找该节点右子树的最小值,即真正删除的点
                {
                    sAvl.push(pSearch);
                    pPre = pSearch;
                    pSearch = pSearch->left;
                }
                sAvl.pop();   //删除的点没用，将删除的点弹栈
                pNode->data = pSearch->data;
                if (pPre->left == pSearch)
                {
                    pPre->left = pSearch->right;
                }
                else
                {
                    pPre->right = pSearch->right;
                }
            }
            int bf;
            while (!sAvl.empty())
            {
                pPreNode = sAvl.top();
                sAvl.pop();
                bf = (pPreNode->data > key) ? -1 : 1;
                pPreNode->bf += bf;
                bf = pPreNode->bf;
                if (0 != bf)
                {
                    if (1 == bf || -1 == bf || !AVLRotateTree(pPreNode, bf))
                    {
                        break;
                    }
                }
            }
            break;
        }
    }
}
//******************************************AVL***********************************************end

转载于:https://www.cnblogs.com/venow/archive/2012/08/09/2629094.html

平衡二叉树AVL
Emperor10的博客
08-21 915
文章目录一、 相关概念1.1 AVL定义1.2 平衡因子1.3 AVL的作用二、 失衡调整2.1 LL型2.2 RR型2.3 LR型2.4 RL型 一、 相关概念 1.1 AVL定义 平衡二叉树又称为AVL树，它或者是颗空树，或者是具有下列性质的二叉排序树： 左右两个子树的高度差值不超过1； 它的左右子树也是一颗平衡二叉树； 1.2 平衡因子 某节点的左子树与右子树的高度差即为该节点的平衡因子BF。 按照定义我们可以得到，AVL上所有结点的平衡因子只可能是 -1，0 或 1。 下面这张图中标出了每一
平衡二叉树 AVL
喜欢吃冰棍de谷利文君的博客
03-07 965
平衡二叉树 AVL 先弄清楚几个概念： 1）满二叉树：除了叶子节点，都是满的； 2）完全二叉树：整体而言，空缺的节点一定是位于树的右下方；整棵树的叶子节点最大深度值和最小深度值，相差不会超过1； 3）平衡二叉树：对于任意一个节点，左子树和右子树的高度差不能超过1。 1 平衡因子 通过平衡因子可以判断出是否为平衡二叉树，这决定了是否需要进行左旋转或右旋转操作。 第一步，标注节点的高度；节点的高度=...
【数据结构】详解平衡二叉树AVL旋转操作(附相关C++代码)
weixin_50941083的博客
05-16 2083
本文介绍了什么是平衡二叉树，并详解了它的旋转操作。
平衡二叉树（AVL）
热门推荐
lucyLee的博客
09-05 1万+
1. 概述 1.1 定义 平衡二叉树，全称为平衡二叉搜索树 它是由苏联数学家Adelson-Velsky 和 Landis提出来的，因此平衡二叉树又叫AVL树 平衡二叉树的定义是一种递归定义，要求每个节点都具有以下特性： 可以是一棵空树 左子树和右子树高度之差的绝对值不超过1（左右子树的高度差可以为0、1和 -1） 左子树和右子树均为平衡二叉树 为什么平衡二叉树是二叉搜索树？ 之前，在学习二叉搜索树时，增删该查的效率最坏为O(n)O(n)O(n)。此时，二叉树退化成一条链 若二叉搜索树尽可能的平衡
平衡二叉树 avl
Calmye的博客
11-14 315
平衡二叉树（AVLTree）
2301_80785428的博客
08-21 1853
平衡二叉树，又称AVL树，用于解决二叉排序树高度不确定的情况，如果二叉排序树的子树间的高度相差太大，就会让二叉排序树操作的时间复杂度升级为O(n)，为了避免这一情况，为最坏的情况做准备，就出现了，使树的高度尽可能的小，其本质还是一棵二叉搜索树。
平衡搜索二叉树（AVL树）
m0_69323023的博客
01-09 2686
AVL树详解
C语言-实现顺序二叉树和平衡二叉树AVL
mike_jun的博客
04-10 1248
在实现二叉树之前先看下结构体的一些使用方法数组是保存一系列相同的数据。在实际问题中，一组数据往往有很多种不同的数据类型。例如，登记学生的信息，可能需要用到 char型的姓名，int型或 char型的学号，int型的年龄访问其中的各个元素，用结构成员运算符点（.）。即访问成员的一般形式是：结构变量名 . 成员名如 a.name 表示学生 a 的姓名。1）结构体的成员逐个赋值2）整体赋值也可以在初始化的时候赋值3）整体拷贝如上每次使用结构体均需要写struct，可以使用typedef 简化书写。
平衡二叉树AVL树
weixin_45863060的博客
04-06 1755
平衡二叉树（AVL树） 定义： AVL树是一颗特殊的二叉查找树，它具有保持平衡要求的特性，AVL树的每一个节点的左子树和右子树的高度差要求最大为1，如果超过1将破坏平衡特性，将不再是一颗平衡二叉树。 平衡条件的维持： 为什么需要维持平衡： AVL树需要时刻保持其平衡的特性，但这样的特性可能会在插入和删除的同时被打破，插入和删除新的节点造成的高度变化可能会使某些节点的左右子树的高度差超过1，所以我们需要在插入和删除的同时维护AVL树的平衡特性。 讨论如何维持AVL树的平衡： 明确平衡被破坏的位置 在讨论AV
动画讲解平衡二叉树AVL
jinking01的专栏
02-27 2025
前言 Wiki:在计算机科学中，AVL树是最早被发明的自平衡二叉查找树。在AVL树中，任一节点对应的两棵子树的最大高度差为1，因此它也被称为高度平衡树。查找、插入和删除在平均和最坏情况下的时间复杂度都是 O(logn）。增加和删除元素的操作则可能需要借由一次或多次树旋转，以实现树的重新平衡。AVL 树得名于它的发明者 G. M. Adelson-Velsky 和 Evgenii Landis，...
平衡二叉树AVL操作模板
09-04
平衡二叉树 AVL 操作模板 平衡二叉树 AVL 操作模板是平衡二叉树的一种实现方式，通过 AVL 操作模板，可以对树进行插入、删除、查找等操作，并且保持树的平衡状态。 概念 1. 平衡二叉树：是一种自平衡二叉树，具有...
二叉树的应用：二叉排序树BST和平衡二叉树AVL的构造 课设作业 完整代码
02-10
平衡二叉树（Balanced Binary Tree）又被称为AVL树。具有以下性质：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。构造与调整方法。 实验目的： 二叉排序树的实现...
java-平衡二叉树AVL的实现
04-23
在Java编程领域，平衡二叉树（特别是AVL树）是一种高效的数据结构，它通过保持树的高度平衡来确保查找、插入和删除操作的最优化。AVL树是最早被提出的自平衡二叉搜索树，由G. M. Adelson-Velsky和E. M. Landis于1962...
二叉树的前中后序遍历(迭代法)
mrjieke6的博客
09-07 1282
本文系统介绍了二叉树前序、中序和后序遍历的迭代实现方法。前序遍历采用栈结构，按;根→右→左 ;顺序入栈；中序遍历先全部左子树入栈再访问节点；后序遍历则通过修改前序遍历顺序为"根→右→左 ;后反转结果。三种遍历时间复杂度均为O(n)，空间复杂度最坏O(n)。与递归实现相比，迭代方法避免了栈溢出风险，处理大型树更稳定。每种遍历方式都配有详细代码解析、执行示例和复杂度分析，并讨论了实际应用场景，为掌握树结构操作提供了系统指导。
每日算法刷题Day67:9.9:leetcode bfs10道题，用时2h30min
2301_80044595的博客
09-09 564
2.与[[十.图论算法-基础遍历#3. 1162. 地图分析(中等,学习)]]一模一样，找每个1到各自最近的0的最短距离，即多源最短路径距离，所以将所有0入队列，向四周扩散，告诉1已经扩散的层数，即距离。所以要反过来，将所有满足条件的点当做多个源点，向外扩散，从而告诉待求点当前扩散的层数，即最短距离。，是Dijkstra算法，但因为边权只有0和1，所以用0-1BFS来优化Dijkstra，双端队列队首入0，队尾入1，保证每次队首都是边权(代价)最小的。的视频包含所有你好友的好友观看过的视频，以此类推。
【无标题】
最新发布
Leeyy
09-10 621
过拟合是指模型在训练集上表现很好，但在测试集上表现较差的现象。
【牛客刷题-剑指Offer】BM18 二维数组中的查找：一题四解，从暴力到最优
字节卷动
09-06 184
方法时间复杂度空间复杂度优点缺点适用场景暴力遍历On×mOn×mO1O(1)O1简单直接，易实现效率低，不适合大数据量小规模数据二分查找Omlog⁡nOmlognO1O(1)O1利用行有序，效率较高未利用列有序特性行数较少时Z字形查找OnmO(n + m)OnmO1O(1)O1最优解，利用行列有序无各种规模数据递归分治平均优于OnmO(nm)OnmOlog⁡nmOlognm。
【动态规划：简单多状态dp问题】删除并获得点数 && 粉刷房子
lirendada的博客
09-07 1034
文章摘要 本文介绍了两个动态规划问题：删除并获得点数和粉刷房子。对于前者，通过将原数组映射到有序连续数组转化为类似打家劫舍的问题，利用状态转移方程求解最大点数。后者则通过定义三种颜色状态，使用二维数组记录每个房子涂不同颜色的最小花费，确保相邻房子颜色不同。两个问题均通过动态规划高效解决，展示了如何将复杂问题转化为经典模型进行处理。代码实现中，前者采用预处理和状态转移，后者利用虚拟位置保证初始化正确性，最终返回最小值作为结果。
C语言深度入门系列：第八篇 - 结构体、联合体与枚举：程序世界的复合数据类型大师
而世之奇伟、瑰怪，非常之观，常在于险远，而人之所罕至焉，故非有志者不能至也！
09-10 434
复合数据类型是C语言程序设计的高级特性，掌握了它们，您就能够构建出复杂而高效的数据结构，为实现大型程序打下坚实基础。这些概念在后续学习数据结构、算法以及系统编程时将发挥重要作用。
平衡二叉树avl
04-22
### AVL树的定义 AVL树是一种自平衡二叉搜索树，以其发明者G.M.Adelson-Velsky和E.M.Landis的名字命名[^3]。它通过维护树的高度平衡来确保操作的时间复杂度保持在O(log n)级别。具体来说，在AVL树中，任意节点的两个子树的高度差（称为平衡因子）最多为1。 #### 平衡条件 - 对于任何一个节点，其左子树和右子树都必须是AVL树。 - 节点的平衡因子范围限定为{-1, 0, 1}。 --- ### AVL树的实现 以下是基于C++语言的一个典型AVL树实现框架： #### 结构体定义 ```cpp struct AVLNode { int key; int height; AVLNode* left; AVLNode* right; AVLNode(int k) : key(k), height(1), left(nullptr), right(nullptr) {} }; ``` #### 获取高度函数 用于计算某个节点的高度。 ```cpp int getHeight(AVLNode* node) { if (node == nullptr) return 0; return node->height; } ``` #### 更新高度函数 每次修改树结构后都需要更新节点的高度。 ```cpp void updateHeight(AVLNode* node) { if (node != nullptr) { node->height = std::max(getHeight(node->left), getHeight(node->right)) + 1; } } ``` #### 左旋操作 当右子树过重时执行左旋。 ```cpp AVLNode* rotateLeft(AVLNode* y) { AVLNode* x = y->right; AVLNode* T2 = x->left; // 执行旋转 x->left = y; y->right = T2; // 更新高度 updateHeight(y); updateHeight(x); return x; // 新的根节点 } ``` #### 右旋操作 当左子树过重时执行右旋。 ```cpp AVLNode* rotateRight(AVLNode* x) { AVLNode* y = x->left; AVLNode* T2 = y->right; // 执行旋转 y->right = x; x->left = T2; // 更新高度 updateHeight(x); updateHeight(y); return y; // 新的根节点 } ``` #### 插入操作 插入过程中可能会破坏平衡，因此需要进行相应的旋转调整。 ```cpp AVLNode* insert(AVLNode* root, int key) { if (root == nullptr) { return new AVLNode(key); } if (key < root->key) { root->left = insert(root->left, key); } else if (key > root->key) { root->right = insert(root->right, key); } else { return root; // 不允许重复键值 } // 更新当前节点的高度 updateHeight(root); // 计算平衡因子并判断是否失衡 int balanceFactor = getHeight(root->left) - getHeight(root->right); // 进行必要的旋转调整 if (balanceFactor > 1 && key < root->left->key) { return rotateRight(root); // 单右旋 } if (balanceFactor < -1 && key > root->right->key) { return rotateLeft(root); // 单左旋 } if (balanceFactor > 1 && key > root->left->key) { root->left = rotateLeft(root->left); // 先左旋再右旋 return rotateRight(root); } if (balanceFactor < -1 && key < root->right->key) { root->right = rotateRight(root->right); // 先右旋再左旋 return rotateLeft(root); } return root; } ``` --- ### 应用场景 AVL树适用于那些频繁查询而较少插入或删除的应用场合。由于其严格的平衡约束，使得查找效率非常高，但在大量动态数据集中的表现可能不如红黑树灵活。常见的应用领域包括但不限于： - 数据库索引设计：快速定位记录的位置。 - 编译器优化：存储符号表以便高效访问变量信息。 - 文件系统的元数据管理：加速文件检索速度。 ---
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值