AVL树的详细实现(C++)

AVL树的实现(C++) Implement of AVL_Tree using CppImplement of AVL_Tree using Cpp 阅读详情
AI摘要

AVL树是二叉搜索树的一种改进,确保了树的平衡,从而提高查找效率。当插入或删除节点导致不平衡时,AVL树会通过四种旋转(LL、RR、LR、RL)来调整平衡。本文详细介绍了AVL树的定义、失衡情况、旋转操作以及其实现,包括节点的平衡因子和高度计算,同时提供了C++代码示例。

AVL树概念

前面已经介绍了二叉搜索树,但是二叉搜索树在某些情况下会出现极度不平衡,其树形结构便退化成了链表,查找效率也会下降。于是出现了 AVL 树,AVL 树保证了二叉搜索树的平衡,引入了平衡监督机制,也就是在插入结点时,树中某一部分不平衡度超过一个阈值后将出发平衡调整操作,这样便保证了树的平衡度在可接受的范围内,最大的好处就是提高了搜索的效率。

AVL 树是一种平衡二叉树,其名字来源于发明者的名字(Adelson-Velskii 以及 Landis)。AVL树的递归定义如下:

  1. 左右子树的高度差小于等于 1。
  2. 其每一个子树均为平衡二叉树。

通过这两个性质就可以判定一棵树是否为平衡二叉树了。

如下图就是一颗平衡二叉树,任何节点的两个子树的高度最大差别为 1:

AVL树的详细实现-图1

而下图不是一颗平衡二叉树,因为结点 7 的两颗子树高度相差为 2。

AVL树的详细实现-图2

AVL 树的查找、插入和删除在平均和最坏情况下均为 O(logn)。

如果在 AVL 树种插入或删除节点后,使得高度之差大于 1。此时,AVL 树的平衡状态就被破坏,不再是平衡二叉树,为了维持一个平衡状态,需要对其进行旋转处理。

平衡二叉树加入了“平衡因子”概念,定义为:

某个结点的左子树的高度减去右子树的高度得到的差值。AVL 树的所有结点的平衡因子的绝对值都不超过 1。

为了计算平衡因子,自然需要在节点种引入高度这一属性。高度一般定义为左右子树高度的最大值。下面将会详细介绍 AVL 树的详细实现。

AVL树的失衡调整

失衡

在 AVL 树中进行插入或删除节点后,可能导致 AVL 树失去平衡。这种失衡可以概括为 4 中姿态:

(1)LL 失衡:LeftLeft,也称为“左左”。插入或删除一个节点后,根节点的左子树的左子树还有非空子节点,导致“根的左子树的高度”比“根的右子树的高度”大 2,导致 AVL 树失去了平衡。如下图:

AVL树的详细实现-图3
(2)LR 失衡:LeftRight,也称为“左右”。插入或删除一个节点后,根节点的左子树的右子树还有非空子节点,导致“根的左子树的高度”比“根的右子树的高度”大 2,导致 AVL 树失去了平衡。如下图:

AVL树的详细实现-图4

(3)RL 失衡:RightLeft,称为“右左”。插入或删除一个节点后,根节点的右子树的左子树还有非空子节点,导致“根的右子树的高度”比“根的左子树的高度”大 2,导致 AVL 树失去了平衡。

AVL树的详细实现-图5

(4)RR 失衡:RightRight,称为“右右”。插入或删除一个节点后,根节点的右子树的右子树还有非空子节点,导致“根的右子树的高度”比“根的左子树的高度”大 2,导致 AVL 树失去了平衡。

AVL树的详细实现-图6

旋转

LL 旋转

LL 失衡的情况,可以通过一次左旋转将 AVL 树恢复平衡,如下图:

AVL树的详细实现-图7

可以发现,只通过一次旋转就可以恢复为 AVL 树。对于 LL 旋转,可以这样理解:

LL 旋转是围绕“失去平衡的 AVL 根节点”进行的,也就是节点 k2,由于是 LL 情况,即“左左情况”,用手抓着“左孩子,即 k1”使劲向左摇,将 k1 变成了根节点,而 k2 变成了 k1 的右子树,而“k1 的右子树”变成了“k2 的左子树”。

代码如下:

AVLTreeNode<T> *leftLeftRotation(AVLTreeNode<T> *&k2)
{
    AVLTreeNode<T> *k1 = k2->m_leftChild;
    k2->m_leftChild = k1->m_rightNode;
    k1->m_rightNode = k2;
    k2->m_height = std::max(height(k2->m_leftChild), height(k2->m_rightNode)) + 1;
    k1->m_height = std::max(height(k1->m_leftChild), k2->m_height) + 1;
    return k1;
}
RR 旋转

理解了 LL 之后,RR 旋转就相当容易理解了。RR 就是与 LL 堆成的情况,RR 恢复平衡的旋转方法如下:

AVL树的详细实现-图8

RR 旋转也只需要一次即可。对于 RR 旋转,可以这样理解:

RR 旋转是围绕“失去平衡的 AVL 根节点”进行的,也就是节点 k1,由于是 RR 情况,即“右右情况”,用手抓着“右孩子,即 k2”使劲向右摇,将 k2 变成了根节点,而 k1 变成了 k2 的左子树,而“k1 的右子树”变成了“k2 的左子树”。

代码如下:

AVLTreeNode<T> *rightRightRotation(AVLTreeNode<T> *&k1)
{
    AVLTreeNode<T> *k2 = k1->m_rightNode;
    k1->m_rightNode = k2->m_leftChild;
    k2->m_leftChild = k1;

    k1->m_height = std::max(height(k1->m_leftChild), height(k1->m_rightNode)) + 1;
    k2->m_height = std::max(height(k2->m_rightNode), k1->m_height) + 1;
    return k2;
}
LR 旋转

LR 失衡情况,需要经过两次旋转才能让 AVL 树恢复平衡。如下图:

AVL树的详细实现-图9

第一次旋转是围绕 k1 进行的 RR 旋转,第二次旋转是围绕 k3 进行的 LL 旋转。

代码如下:

AVLTreeNode<T> *leftRightRotation(AVLTreeNode<T> *&k3)
{
    k3->m_leftChild = rightRightRotation(k3->m_leftChild);
    return leftLeftRotation(k3);
}
RL 旋转

RL 旋转是和 LR 对称的情况,RL 恢复平衡的旋转方法如下:

AVL树的详细实现-图10

第一次旋转是围绕 k3 进行的 LL 旋转,第二次是围绕 k1 进行的 RR 旋转。

代码如下:

AVLTreeNode<T> *rightLeftRotation(AVLTreeNode<T> *&k1)
{
    k1->m_rightNode = leftLeftRotation(k1->m_rightNode);
    return rightRightRotation(k1);
}

AVL树的实现

节点定义

template <typename T>
struct AVLTreeNode
{
    T m_key;                  // 关键字
    int m_height;             // 高度
    AVLTreeNode *m_leftChild; // 左孩子
    AVLTreeNode *m_rightNode; // 右孩子
    AVLTreeNode(T value, AVLTreeNode *l, AVLTreeNode *r) : m_key(value), m_height(0), m_leftChild(l), m_rightNode(r) {}
};

详细代码实现

注意:关于 AVL 树的各种二叉树的通用接口之前的二叉树篇幅中已经实现过,这里不再赘述,仅实现了 AVL 树中重要的接口。

#include <iostream>
using namespace std;

template <typename T>
struct AVLTreeNode
{
    T m_key;                  // 关键字
    int m_height;             // 高度
    AVLTreeNode *m_leftChild; // 左孩子
    AVLTreeNode *m_rightNode; // 右孩子
    AVLTreeNode(T value, AVLTreeNode *l, AVLTreeNode *r) : m_key(value), m_height(0), m_leftChild(l), m_rightNode(r) {}
};

template <typename T>
class AVLTree
{
public:
    AVLTree() : m_root(NULL) {}
    ~AVLTree() { destroy(m_root); }

public:
    // 中序遍历
    void inOrder() { inOrder(m_root); }

    // 先序遍历
    void preOrder() { preOrder(m_root); }

    // 树的高度
    int height() { return height(m_root); }

    // 查找AVL树种值为key的结点(递归)
    AVLTreeNode<T> *search(T key) { return search(m_root, key); }

    // 查找AVL树种值为key的结点(非递归)
    AVLTreeNode<T> *iterativeSearch(T key) { return iterativeSearch(m_root, key); }

    // 查找最小结点,返回最小结点的键值
    T minimum()
    {
        AVLTreeNode<T> *p = minimum(m_root);
        if (p != NULL)
            return p->m_key;
        return (T)NULL;
    }

    // 查找最大结点,返回最大结点的键值
    T maximum()
    {
        AVLTreeNode<T> *p = maximum(m_root);
        if (p != NULL)
            return p->m_key;
        return (T)NULL;
    }

    // 将键值为key的结点插入到AVL中
    void insert(T key) { insert(m_root, key); }

    // 删除键值为key的结点
    void remove(T key)
    {
        AVLTreeNode<T> *z = search(m_root, key);
        if (z != NULL)
            m_root = remove(m_root, z);
    }

    // 销毁AVL树
    void destroy() { destroy(m_root); }

private:
    void inOrder(AVLTreeNode<T> *node)
    {
        if (node == NULL)
            return;
        inOrder(node->m_leftChild);
        cout << node->m_key << " ";
        inOrder(node->m_rightNode);
    }

    void preOrder(AVLTreeNode<T> *node)
    {
        if (node == NULL)
            return;
        cout << node->m_key << " ";
        preOrder(node->m_leftChild);
        preOrder(node->m_rightNode);
    }

    int height(AVLTreeNode<T> *node)
    {
        return node != NULL ? node->m_height : 0;
    }

    void destroy(AVLTreeNode<T> *&tree)
    {
        if (tree == NULL)
            return;
        if (tree->m_leftChild != NULL)
            destroy(tree->m_leftChild);
        if (tree->m_rightNode != NULL)
            destroy(tree->m_rightNode);
        delete tree;
    }

    AVLTreeNode<T> *search(AVLTreeNode<T> *node, T key)
    {
        if (node == NULL || node->m_key == key)
            return node;
        if (key < node->m_key)
            return search(node->m_leftChild, key);
        else
            return search(node->m_rightNode, key);
    }

    AVLTreeNode<T> *iterativeSearch(AVLTreeNode<T> *node, T key)
    {
        while ((node != NULL) && (node->m_key != key))
        {
            if (key < node->m_key)
                node = node->m_leftChild;
            else
                node = node->m_rightNode;
        }
        return node;
    }

    AVLTreeNode<T> *minimum(AVLTreeNode<T> *node)
    {
        if (node == NULL)
            return NULL;
        while (node->m_leftChild != NULL)
        {
            node = node->m_leftChild;
        }
        return node;
    }

    AVLTreeNode<T> *maximum(AVLTreeNode<T> *node)
    {
        if (node == NULL)
            return NULL;
        while (node->m_rightNode != NULL)
        {
            node = node->m_rightNode;
        }
        return node;
    }

    AVLTreeNode<T> *insert(AVLTreeNode<T> *&node, T key)
    {
        if (node == NULL)
        {
            node = new AVLTreeNode<T>(key, NULL, NULL);
        }
        else if (key < node->m_key) // key插入node的左子树的情况
        {
            node->m_leftChild = insert(node->m_leftChild, key);
            // 插入节点后,如果AVL树失衡,需要进行相应调节
            if (height(node->m_leftChild) - height(node->m_rightNode) == 2)
            {
                if (key < node->m_leftChild->m_key)
                    node = leftLeftRotation(node);
                else
                    node = leftRightRotation(node);
            }
        }
        else if (key > node->m_key) // key插入node的右子树的情况
        {
            node->m_rightNode = insert(node->m_rightNode, key);
            // 插入节点后,如果AVL树失衡,需要进行相应调节
            if (height(node->m_rightNode) - height(node->m_leftChild) == 2)
            {
                if (key > node->m_rightNode->m_key)
                    node = rightRightRotation(node);
                else
                    node = rightLeftRotation(node);
            }
        }
        else
        {
            cout << "添加失败,不能添加相同的结点" << endl;
        }
        node->m_height = max(height(node->m_leftChild), height(node->m_rightNode)) + 1;
        return node;
    }

    AVLTreeNode<T> *remove(AVLTreeNode<T> *&node, AVLTreeNode<T> *z)
    {
        if (node == NULL || z == NULL)
            return NULL;

        if (z->m_key < node->m_key) // 待删除的节点在tree的左子树中
        {
            node->m_leftChild = remove(node->m_leftChild, z);
            // 删除节点后,如果AVL树失衡,需要进行相应调节
            if (height(node->m_rightNode) - height(node->m_leftChild) == 2)
            {
                AVLTreeNode<T> *r = node->m_rightNode;
                if (height(r->m_leftChild) > height(r->m_rightNode))
                    node = rightLeftRotation(node);
                else
                    node = rightRightRotation(node);
            }
        }
        else if (z->m_key > node->m_key) //待删除的节点在node的右子树中
        {
            // 删除节点后,如果AVL树失衡,需要进行相应调节
            node->m_rightNode = remove(node->m_rightNode, z);
            if (height(node->m_leftChild) - height(node->m_rightNode) == 2)
            {
                AVLTreeNode<T> *l = node->m_leftChild;
                if (height(l->m_rightNode) > height(l->m_leftChild))
                    node = leftRightRotation(node);
                else
                    node = leftLeftRotation(node);
            }
        }
        else //当前node就是要删除的节点
        {
            if ((node->m_leftChild != NULL) && (node->m_rightNode != NULL))
            {
                if (height(node->m_leftChild) > height(node->m_rightNode))
                {
                    if (height(node->m_leftChild) > height(node->m_rightNode))
                    {
                        /* 如果node节点的左子树比右子树高,则:
                         * (01)找出node的左子树中最大节点
                         * (02)将该最大节点的值赋值给node
                         * (03)删除该最大节点
                         * 相当于用node的左子树中最大节点作为node的替身
                         * 这种方式删除node左子树中最大节点之后,AVL树任然是平衡的
                         */
                        AVLTreeNode<T> *max = maximum(node->m_leftChild);
                        node->m_key = max->m_key;
                        node->m_leftChild = remove(node->m_leftChild, max);
                    }
                    else
                    {
                        /* 如果node节点的右子树比左子树高,则:
                         * (01)找出node的右子树中最小节点
                         * (02)将该最小节点的值赋值给node
                         * (03)删除该最小节点
                         * 相当于用node的右子树中最小节点作为node的替身
                         * 这种方式删除node右子树中最小节点之后,AVL树任然是平衡的
                         */
                        AVLTreeNode<T> *min = minimum(node->m_rightNode);
                        node->m_key = min->m_key;
                        node->m_rightNode = remove(node->m_rightNode, min);
                    }
                }
            }
            else
            {
                // 被删除的节点等于node,并且node有一个孩子
                // 将当前节点指向该孩子节点并删除当前节点
                AVLTreeNode<T> *tmp = node;
                node = node->m_leftChild != NULL ? node->m_leftChild : node->m_rightNode;
                delete tmp;
            }
        }
        return node;
    }

private:
    /* LL:左子树的左边失去平衡(左单旋转)
     *       k2              k1     
     *      /  \            /  \
     *     k1   z   ===>   x    k2
     *    /  \                 /  \
     *   x    y               y    z
     */

    AVLTreeNode<T> *leftLeftRotation(AVLTreeNode<T> *&k2)
    {
        AVLTreeNode<T> *k1 = k2->m_leftChild;
        k2->m_leftChild = k1->m_rightNode;
        k1->m_rightNode = k2;
        k2->m_height = std::max(height(k2->m_leftChild), height(k2->m_rightNode)) + 1;
        k1->m_height = std::max(height(k1->m_leftChild), k2->m_height) + 1;
        return k1;
    }

    /* RR:右子树的右边失去平衡(右单旋转)
     *       k1              k2     
     *      /  \            /  \
     *     x   k2   ===>   k1   z
     *        /  \        /  \   
     *       y    z      x    y  
     */
    AVLTreeNode<T> *rightRightRotation(AVLTreeNode<T> *&k1)
    {
        AVLTreeNode<T> *k2 = k1->m_rightNode;
        k1->m_rightNode = k2->m_leftChild;
        k2->m_leftChild = k1;

        k1->m_height = std::max(height(k1->m_leftChild), height(k1->m_rightNode)) + 1;
        k2->m_height = std::max(height(k2->m_rightNode), k1->m_height) + 1;
        return k2;
    }

    /* LR:左子树的右边失去平衡(左双旋转)
     *       k3               k3               k2
     *      /  \     RR      /  \     LL      /  \
     *     k1   D   ===>   k2    D   ===>   k1    k3
     *    /  \            /  \             /  \  /  \
     *   A    K2         k1   C           A    B C   D
     *       /  \       /  \
     *      B    C     A    B
     */
    AVLTreeNode<T> *leftRightRotation(AVLTreeNode<T> *&k3)
    {
        k3->m_leftChild = rightRightRotation(k3->m_leftChild);
        return leftLeftRotation(k3);
    }

    /* RL:右子树的左边失去平衡(右双旋转)
     *     k1               k1                K2
     *    /  \      LL     /  \      RR      /  \
     *   A    k3   ===>   A    k2   ===>   k1    K3
     *       /  \             /  \        /  \  /  \
     *      k2   D           B    k3     A    B C   D
     *     /  \                  /   \
     *    B    D                C     D
     */
    AVLTreeNode<T> *rightLeftRotation(AVLTreeNode<T> *&k1)
    {
        k1->m_rightNode = leftLeftRotation(k1->m_rightNode);
        return rightRightRotation(k1);
    }

private:
    AVLTreeNode<T> *m_root; // AVL树的根节点
};

int main()
{
    AVLTree<int> tree;
    tree.insert(3);
    tree.insert(2);
    tree.insert(1);
    tree.insert(4);
    tree.insert(5);
    tree.insert(6);
    tree.insert(7);

    tree.insert(16);
    tree.insert(15);
    tree.insert(14);
    tree.insert(13);
    tree.insert(12);
    tree.insert(11);
    tree.insert(10);
    tree.insert(8);
    tree.insert(9);

    tree.preOrder();
    cout << endl;
    tree.inOrder();
    cout << endl;

    tree.remove(8);
    tree.preOrder();
    cout << endl;
    tree.preOrder();
    cout << endl;

    return 0;
}

参考:
https://wangkuiwu.github.io/2013/02/02/avltree-cpp

AVL树(C语言实现) AVL树的相关操作,包括插入,删除,查找,调整。(C语言实现) 阅读详情

相关推荐

别再死记硬背了!用这5个Qt Design Studio小项目,彻底玩转核心组件

本文通过5个Qt Design Studio实战项目,帮助开发者深入理解核心组件的协作与应用。从动态登录界面到游戏化任务列表,每个项目都展示了组件属性与交互设计的巧妙结合,让你不再死记硬背,而是真正掌握Qt Design Studio的核心技能。

weixin_29202213的博客 272

C++——AVL树及其模拟实现

int _bf;

fsbwb的博客 408

8155平台multi-display(多屏显示)原理与配置

8155平台多屏互动原理与配置

漂流瓶の海岸 1608

数据结构(C++) : AVL树 实现篇

在二叉搜索树的基础上学习AVL树,通过大量图片学习AVL树的重点:左单旋,右单旋,左右双旋,右左双旋。同时写出验证函数,验证是否是AVL树

weixin_57761086的博客 3378

华为2021年天线工程师笔试题目回忆总结(持续更新)

1. 判定长线和短线 所谓长线是指传输线的几何长度和线上传输电磁波的波长的比值(即电长度)大于或接近于1。反之称为短线。是相对于波长而言的。 1000m的传输线,对于频率为50hz(即波长为6000km)的交流电来说,仍远小于波长,应视为短线。长线和短线的区别还在于:长线为分布参数电路,而短线是集总参数电路。 2. 判定传输线的容性和感性 传输线上的输入阻抗具有以下特点: 1/4波长变换性:感性负载与容性负载变换,开路与短路变换; 1/2波长重复性:相距1/2波长的整数倍的两个点输入阻抗都相等。1/4开路传

ludashi3的博客 9531

Vivado FFT IP核避坑指南:从Matlab数据生成到FPGA验证的完整流程

本文详细解析了Vivado FFT IP核从Matlab数据生成到FPGA验证的完整流程,重点解决跨平台数据一致性、IP核配置陷阱和验证方法论等核心问题。通过实战案例和避坑指南,帮助工程师高效实现FFT运算的硬件验证,确保结果与Matlab的误差控制在0.3%以内。

weixin_42543046的博客 399

【C++】AVL树

本文介绍了AVL树的实现

qq_67582098的博客 1341

Outlook总是提示登录微软,怎么办?

Outlook 2021反复弹出Microsoft登录窗口,可能是由于Modern Authentication身份验证机制或凭据问题导致。解决方案包括:1)通过注册表关闭Modern Authentication(适用于本地Exchange);2)清理Windows凭据管理器中的旧认证信息;3)手动配置Exchange服务器地址;4)通过注册表阻止Microsoft登录窗口弹出(适用于非M365环境)。建议按顺序尝试,尤其前两步通常能解决问题。经测试,步骤1和2已有效解决该问题。

剪刀石头布 4686

数据结构:AVL树(C++实现)

本文延续前文二叉搜索树,开启平衡二叉搜索树的篇章。在这一篇章中,我们将重点关注AVL树,这是一种严格平衡的二叉搜索树。AVL树通过精巧的平衡机制,确保了树的高度始终保持在对数级别,从而大大提升了查找、插入和删除操作的性能。本文将详细介绍AVL树的原理、平衡调整方法以及性能分析。通过对AVL树的学习,我们不仅深入理解了平衡二叉搜索树的原理和操作,还掌握了如何通过旋转来维护树的平衡性。这一过程加深了我们对平衡二叉树重要性的认识。

2301_79171011的博客 1312

ECB oracle——attack

基于ECB oracle的攻击方案前言什么是ECB方案步骤1.确定块大小和明文大小2.暴力破解求明文脚本代码 前言 参考文章:Breaking ECB by prepending your own message. 环境地址:ECB oracle 什么是ECB 分组密码中AES的一种模式(其他还有:CBC、ECB、CTR、OCF、CFB)如图每一块加密是分开的。 方案步骤 1.确定块大小和明文大小 先用一个字符"a"去encrypt返回32个字节的数据(64位16进制)依次用"aa",“aaa”…去en

weixin_44617902的博客 1311

37张图详解MAC地址、以太网、二层转发、VLAN

MAC 地址 每个网卡或三层网口都有一个 MAC 地址, MAC 地址是烧录到硬件上,因此也称为硬件地址。MAC 地址作为数据链路设备的地址标识符,需要保证网络中的每个 MAC 地址都是唯一的,才能正确识别到数据链路上的设备。 MAC 地址由 6 个字节组成。前 3 个字节表示厂商识别码,每个网卡厂商都有特定唯一的识别数字。后 3 个字节由厂商给每个网卡进行分配。厂商可以保证生产出来的网卡不会有相同 MAC 地址的网卡。 现在可以通过软件修改 MAC 地址,虚拟机使用物理机网卡的 MAC 地址,并不能保.

networktp的博客 4747

AVL树(C++实现)

我们实现的是KV模型的AVL树,为了方便后续的操作,这里AVL树结点定义为三叉链结构,并且引入平衡因子,方便判断每棵树的平衡情况,并且还需要一个初始化列表将结点成员全部初始化.//三叉链 AVLTreeNode < K , V > * _left;//存储键值对 int _bf;

清欢Allen的技术博客 1481

【PowerHarmony】电鸿蒙学习记录-准备工作

将获取的“PowerHarmony_PHM_SDK_V1.0.1.0.tar.gz”进行解压。将获取的“code_1.91.1-1720564633_amd64.deb”进行解压。打开后可见所有文件夹,即可进行编辑开发,VSCode也可打开终端进行编译等调试。选择主控类型,我是用的是gd32f470,我选gd32f4xx。Open Folder路径选中SDK解压后根目录即可。选择对应系统类型,我的是小型的,我选mini。选好后即完成工程创建。

Allenzhu的博客 2739

让我来告诉你如何实现AVL树(C++)

完整代码如下// 需要parent指针,后续更新平衡因子可以看到int _bf;// balance factor 平衡因子:_kv(kv), _bf(0){}public:while(cur)if (cur->_kv.first > kv.first) //pair重载了大小于运算符elseelse//连接到父亲节点//控制平衡//更新平衡因子elsebreak;//进行旋转。

记录学习与成长 3057

Statistics and Machine Learning Toolbox

Statistics and Machine Learning Toolbox(带书签),MATLAB统计学习工具

汉书HE8,好用的汇编代码编写工具

汉书HE8,好用的汇编代码编写工具早期编写汇编代码所用功能强大

AVL树的部分实现(c++)

AVL树的实现,使用

2401_83456040的博客 849

Devexpress16.2.6破解工具

Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具

数据结构初阶——AVL树的实现(C++)

摘要:AVL树是一种自平衡二叉搜索树,通过平衡因子限制确保树高在对数级别,保证插入、删除和查找操作的高效性。文章详细介绍了AVL树的基本规则、节点设计、插入操作(包括四种旋转调整情况)、删除操作的实现步骤,以及验证、查找和修改功能的方法。核心内容包括平衡因子的更新规则、单旋和双旋操作的具体实现,并通过代码示例展示了AVL树的关键操作流程。AVL树通过严格的平衡机制解决了普通二叉搜索树在极端情况下退化为链表的问题。

2301_80065652的博客 3255

蓝牙模块HM-10手册

蓝牙模块HM-10手册,该手册对蓝牙模块HM-10进行了详细的介绍和使用方法以及一些AT指令。

AVL树及其实现(C++)

一、AVL树简单介绍 在前面二叉搜索树中,我们可以看出它的查找销率非常高,最优可到达O(Log2(N)),但是当数据越接近有序的时候二叉搜索树将退化成一个链表,查找效率就能变成了O(N),因此,两位俄罗斯的数学家G.M.Adelson-Velskii和E.M.Landis(AVL的由来)发明了AVL树:当向二叉搜索树中插入新结点后,如果能保证每个结点的左右子树高度之差的绝对值不超过1(需要对树中...

weixin_43886592的博客 887

AVL树的实现(C++)

AVL树,即平衡二叉搜索树,并且其左右子树的高度相差小于等于1。 AVL树的实现,在于插入节点的同时,保持树的平衡性。共分为如下四种旋转: 1. 左单边右旋转 当在k1的左子树上插入节点以后,导致K2失去平衡后的旋转。 代码实现如下: /* * * 左单边向右旋转 */ void singleRotateWithLeft(Avl...

weixin_30908103的博客 158

AVL树的模拟实现(c++)

每次插入平衡因子后都需要对有关这个节点祖先的平衡因子进行更新,那么,什么时候更新结束呐,等节点的祖先的平衡因子等于零的时候更新结束,平衡因子等于0说明之前这颗子树的平衡因子是1或者-1,插入新的节点后树的高度没有变大,而是变得平衡了,此时就不需要更新平衡因子了,那么更新平衡因子的意义在哪里呢,如果更新新插入节点的平衡因子时,它的平衡因子变成-2或者2说明这棵子树不平衡了,需要调整了,此时不必更新平衡因子了,需要及时对这颗子树进行旋转。需要注意的是这里使用了,三叉链,目的是方便平衡因子的更新。

m0_68641696的博客 303

递归实现Avl树的删除、建立(C++)

通过递归实现Avl树的删除和建立(c++),如有不足之处望指出。 其中avl树的建立参考了《数据结构与算法分析》(C语言实现)。 现附上头文件和删除部分: #ifdef AvlNode #define AviNode struct AvlNode; typedef AvlNode *Position; typedef AvlNode *AvlTree; typedef int Element

z_Layman的博客 620

AVL树详解与实现(C++)

AVL树是一种自平衡二叉搜索树,通过平衡因子(左右子树高度差不超过1)确保高效查找。插入节点时需先按二叉搜索树规则插入,再更新平衡因子。当平衡因子超过±1时,通过四种旋转(右单旋、左单旋、左右双旋、右左双旋)恢复平衡。旋转操作能降低子树高度并保持平衡,确保树的高度始终为O(log n)。具体旋转类型的选择取决于插入位置导致的子树不平衡情况。

chengO_o的博客 457

数据结构进阶(C++) -- AVL树的实现

1962年,前苏联的科学家G.M.Adelson-Velsky和E.M.Landis 在论文《An algorithm for the organization of information》中发表了AVL树。AVL树是最先发明的自平衡二叉搜索树,AVL树可以是一棵空树,也可以是具备下列性质的二叉搜索树:1、它的左右子树都是AVL树。2、左右子树的高度差的绝对值不超过1。由此可见,AVL树是一棵高度平衡的二叉搜索树,通过控制高度差来控制平衡。

zy1215058242的博客 1052

平衡二叉搜索树:AVL树的实现与分析 以及 统一重平衡算法 (C++)

平衡二叉搜索树 既然二叉搜索树的性能主要取决于高度,故在节点数目固定的前提下,应尽可能地降低高度。 相应地,应尽可能地使兄弟子树的高度彼此接近,即全树尽可能地平衡。   等价变换 等价二叉搜索树:若两棵二叉搜索树的中序遍历序列相同,则称它们彼此等价;反之亦然。   旋转调整 最基本的修复手段,通过围绕特定节点的旋转,实现等价前提下的局部拓扑调整。 zig和zag:    ...

amoscykl的博客 1640

吃透 AVL 树!从概念到手撕实现,一篇搞定二叉平衡搜索树核心----《Hello C++ Wrold!》(21)--(C/C++)

AVL树是一种严格平衡的二叉搜索树,通过平衡因子(高度差绝对值≤1)确保树高始终为O(logn)。其核心在于插入节点后通过四种旋转操作(左旋、右旋、左右双旋、右左双旋)动态调整树结构。模拟实现时需注意:1)平衡因子更新规则:左子树插入减1,右子树插入加1;2)旋转后需重新计算平衡因子;3)双旋操作需处理中间节点的特殊平衡因子情况。相比普通BST,AVL树虽增加了插入删除的调整开销,但保证了最优查询效率,适用于读多写少的场景。

刃神太酷啦的博客 5207

C++实现AVL树

目录AVL树的概念AVL树的插入AVL树的四种旋转右单旋左单旋左右双旋右左双旋查找其他接口析构函数拷贝构造拷贝赋值 AVL树的概念 二叉搜索树虽可以缩短查找的效率,但如果数据有序或接近有序二叉搜索树将退化为单支树,查找元素相当于在顺序表中搜索元素,效率低下。因此,两位俄罗斯的数学家G.M.Adelson-Velskii和E.M.Landis在1962年发明了一种解决上述问题的方法:当向二叉搜索树中插入新结点后,如果能保证每个结点的左右子树高度之差的绝对值不超过1(需要对树中的结点进行调整),即可降低树的高.

m0_53421868的博客 2279
上一篇: 二叉搜索树的详细实现(C++)
下一篇: 解决VMware安装Windows11报错:这台电脑无法运行 Windows 11,这台电脑不符合安装此版本的 Windows 所需的最低系统要求。
code_peak
博客等级 码龄5年 403粉丝 67原创
评论 4
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

code_peak

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值