AVL 平衡树的实现

已于 2024-06-04 14:33:10 修改
阅读量218 收藏
点赞数 1
文章标签： 算法
于 2024-06-03 11:19:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jhkwei/article/details/139409936
版权

看了，数据结构与算法分析，发现 AVL 平衡树相对于红黑树，更加简单明了，代码如下：

#ifndef AVLTREE_H
#define AVLTREE_H

#include <vector>

template<typename K, typename V>
class AVLNode{
public:

    AVLNode(){
        left = nullptr;
        right = nullptr;
        parent = nullptr;
        height = 1;
        layer = 0;
    }
    AVLNode(K k, V v){
        left = nullptr;
        right = nullptr;
        parent = nullptr;
        height = 1;
        key = k;
        value = v;
        layer = 0;
    }
    AVLNode *left;
    AVLNode *right;
    AVLNode *parent;
    K key;
    V value;
    int height;
    int layer;

};
template<typename K, typename V>
class AVLTree
{
public:
    AVLTree(int compare(K a, K b),int dump(int height, K &a, V &v))
    {
        root = nullptr;
        this->compare = compare;
        this->dump_t = dump;
    }

    ~AVLTree(){
        deleteNode(root);
    }

    void deleteNode(AVLNode<K,V> *node){
        if(node == nullptr){
            return;
        }
        deleteNode(node->left);
        deleteNode(node->right);
        delete node;
    }

    

    void insert(K key, V value){
          root = insertNode(root, key, value);
    }

    int max(int a, int b){
        if(a > b){
            return  a;
        }else{
            return b;
        }
    }

    int height(AVLNode<K,V> *node){
        if(node == nullptr){
            return 0;
        }
        return node->height;
    }

    int updateHeight(AVLNode<K,V> *node)
    {
         int h = max(height(node->left),height(node->right)) + 1;
         return h;
    }

    AVLNode<K,V> *signalRotateLeftChild(AVLNode<K,V> *k2){
        AVLNode<K,V> *k1 = k2->left;
        k2->left = k1->right;
        if(k2->left){
            k2->left->parent = k2;
        }
        k1->right = k2;


        k1->parent = k2->parent;
        k2->parent = k1;


        k2->height = updateHeight(k2);
        k1->height = updateHeight(k1);

        return k1;
    }

    AVLNode<K,V> *doubleRotateLeftChild(AVLNode<K,V> *k2){
        k2->left = signalRotateRightChild(k2->left);
        if(k2->left){
            k2->left->parent = k2;
        }
        return signalRotateLeftChild(k2);
    }


    AVLNode<K,V> *signalRotateRightChild(AVLNode<K,V> *k2){
        AVLNode<K,V> *k1 = k2->right;
        k2->right = k1->left;
        if(k2->right){
            k2->right->parent = k2;
        }
        k1->left = k2;

        k1->parent = k2->parent;
        k2->parent = k1;

        k2->height = updateHeight(k2);
        k1->height = updateHeight(k1);

        return k1;
    }

    AVLNode<K,V> *doubleRotateRightChild(AVLNode<K,V> *k2){
        k2->right = signalRotateLeftChild(k2->right);
        if(k2->right){
            k2->right->parent = k2;
        }
        return signalRotateRightChild(k2);
    }

    AVLNode<K,V> *insertNode(AVLNode<K,V> *node, K key, V value){

        if(node == nullptr){
            return new AVLNode<K,V>(key,value);
        }
        int result  = compare(key, node->key);
        if(result < 0){
            node->left = insertNode(node->left, key, value);
            if(node->left){
                node->left->parent = node;
            }
        }else if(result > 0){
            node->right = insertNode(node->right, key, value);
            if(node->right){
                node->right->parent = node;
            }
        }else{
            return  node;
        }
        int leftHeight = height(node->left);
        int rightHeight = height(node->right);
        if(leftHeight - rightHeight == 2){
            if(compare(key, node->left->key) < 0){
                node = signalRotateLeftChild(node);
            }else{
                node = doubleRotateLeftChild(node);
            }
        }else  if(rightHeight - leftHeight  == 2){
            if(compare(key, node->right->key) > 0){
                node = signalRotateRightChild(node);
            }else{
                node = doubleRotateRightChild(node);
            }
        }
        node->height = updateHeight(node);
        return node;
    }
    AVLNode<K,V> *findMin(AVLNode<K,V> *node){
        if(node == nullptr) {
            return node;
        }
        if(node->left == nullptr) {
            return node;
        }
        return findMin(node->left);
    }

    void remove(K key){
        root = remove(root,key);
    }

     AVLNode<K,V>  *remove(AVLNode<K,V> *node ,K key){
         if(node == nullptr){
             return node;
         }
       int result = compare(key,node->key);
       if(result == 0) {
           // 右枝还有叶子，找到右枝最小叶子，代替要删除的节点，
           // 否则直接删除此节点
            if(node->right){
               AVLNode<K,V> *rightMin = findMin(node->right);
               if(rightMin == nullptr) {
                   if(node->parent){
                       if(node->parent->left == node){
                           node->parent->left =  node->right;
                       }else{
                           node->parent->right =  node->right;
                       }
                   }
                   AVLNode<K,V> *temp;
                   temp = node->right;
                   if(temp){
                        temp->parent = node->parent;
                   }
                   delete node;
                   node = temp;
               }else {
                   node->key = rightMin->key;
                   node->right = remove(node->right, node->key);
                   if(node->right){
                       node->right->parent = node;
                   }
               }
            }else{
                AVLNode<K,V> *temp;
                temp = node->left;
                if(temp){
                     temp->parent = node->parent;
                }
                delete node;
                node = temp;
            }
       }else if(result < 0) {
           node->left = remove(node->left, key);
           if(node->left){
               node->left->parent = node;
           }
       }else {
           node->right = remove(node->right, key);
           if(node->right){
               node->right->parent = node;
           }
       }

       if(node == nullptr){
           return node;
       }

       if(height(node->left) - height(node->right) == 2) {
           int k1h = height(node->left->left);
           int k2h = height(node->left->right);

           if(k1h > k2h) {
               node = signalRotateLeftChild(node);
           }else {
               node = doubleRotateLeftChild(node);
           }
       }else if(height(node->right) - height(node->left) == 2) {
           int k1h = height(node->right->left);
           int k2h = height(node->right->right);
           if(k2h  > k1h) {
               node = signalRotateRightChild(node);
           }else {
               node = doubleRotateRightChild(node);
           }
       }
       node->height = max( height(node->right) , height(node->left))+1;
       return node;
   }


 AVLNode<K,V> *findMax(AVLNode<K,V> *node){
        if(node == nullptr) {
            return node;
        }
        if(node->right == nullptr) {
            return node;
        }
        return findMax(node->right);
    }

  //这个删除实现可能更好，更加容易理解
 void remove2(K key){
        root = remove2(root,key);
    }

     AVLNode<K,V>  *remove2(AVLNode<K,V> *node ,K key){
         if(node == nullptr){
             return node;
         }
       int result = compare(key,node->key);
       if(result == 0) {
           if(node->right == nullptr && node->left == nullptr){
               delete  node;
               node = nullptr;
           }else if(height(node->right) > height(node->left)){
               AVLNode<K,V> *find = findMin(node->right);
               node->key = find->key;
               node->right = remove2(node->right, node->key);
               if(node->right){
                   node->right->parent = node;
               }
           }else{
               AVLNode<K,V> *find = findMax(node->left);
               node->key = find->key;
               node->left = remove2(node->left, node->key);
               if(node->left){
                   node->left->parent = node;
               }
           }

       }else if(result < 0) {
           node->left = remove2(node->left, key);
           if(node->left){
               node->left->parent = node;
           }
       }else {
           node->right = remove2(node->right, key);
           if(node->right){
               node->right->parent = node;
           }
       }

       if(node == nullptr){
           return node;
       }

       if(height(node->left) - height(node->right) == 2) {
           int k1h = height(node->left->left);
           int k2h = height(node->left->right);

           if(k1h > k2h) {
               node = signalRotateLeftChild(node);
           }else {
               node = doubleRotateLeftChild(node);
           }
       }else if(height(node->right) - height(node->left) == 2) {
           int k1h = height(node->right->left);
           int k2h = height(node->right->right);
           if(k2h  > k1h) {
               node = signalRotateRightChild(node);
           }else {
               node = doubleRotateRightChild(node);
           }
       }
       node->height = max( height(node->right) , height(node->left))+1;
       return node;
   }


void updateLayer()
    {
        updateLayerNode(root,0);
    }

    void updateLayerNode(AVLNode<K,V> *node, int layer){
        if(node == nullptr){
            return;
        }
        node->layer = layer;
        updateLayerNode(node->left,layer+1);
        updateLayerNode(node->right,layer+1);
    }


     void dumpSpace(int h, int layer)
     {
         int count = 1;
         for(int i = 0;i < h+1 - layer;i++){
             count *= 2;
         }
         count = count-4;
         for(int i = 0;i < count;i++){
             printf(" ");
         }
     }

     void dumpSpace2(int h, int layer)
     {
         dumpSpace(h,layer);
         printf("    ");

     }

     void dump3(){
         if(root == nullptr){
             return;
         }
         updateLayer();
         std::vector<AVLNode<K,V> *>list;
         int count = 1;
         list.push_back(root);
         int layer = 1;
         int layerNum = 0;
         int layerCount = 1;

         while(list.size() > 0 && count > 0){
             AVLNode<K,V> *node = list.at(0);
             list.erase(list.begin());
             if(node){
                 count--;
                 if(dump_t){
                     dumpSpace(root->height, layerNum);
                     dump_t(node->height,node->key,node->value);
                     dumpSpace2(root->height, layerNum);
                 }
                 if(node->left){
                     count++;
                     list.push_back(node->left);
                 }else{
                     list.push_back(nullptr);
                 }
                 if( node->right){
                     count++;
                     list.push_back(node->right);
                 }else{
                     list.push_back(nullptr);
                 }
             }else{
                 list.push_back(nullptr);
                 list.push_back(nullptr);

                 dumpSpace(root->height, layerNum);
                 printf("___,");
                 dumpSpace2(root->height, layerNum);
             }
             layerCount--;
             if(layerCount == 0){
                 layerNum++;
                 layer *= 2;
                 layerCount = layer;
                 printf("\n");
             }
         }
         printf("\n");
     }

     void dump(){
         dumpNode(root, 0);
     }

     void dumpNode(AVLNode<K,V> *node, int layer){

         if(!node){
             return;
         }
         int n = node->height;
         for(int i = 0;i <= n;i++){
            printf(" ");
         }
         if(dump_t){
             dump_t(node->height, node->key, node->value);
         }
         dumpNode(node->left,layer+1);
         dumpNode(node->right,layer+1);
         printf("\n");
     }

     void dump2(){
         dumpNode2(root, 0);
     }

     void dumpNode2(AVLNode<K,V> *node, int layer){

         if(!node){
             return;
         }

         dumpNode2(node->left,layer+1);
         if(dump_t){
             dump_t(node->height, node->key, node->value);
         }
         dumpNode2(node->right,layer+1);
     }

private:
    AVLNode<K,V> *root;
    int (*compare)(K a, K b);
    int (*dump_t)(int height, K &a, V &v);
};

#endif // AVLTREE_H

简单测试代码：

#include "avltree.h"

int cmp(int a, int b){
    return  a - b;
}
int dump(int h, int &key, int &value)
{
    printf("%03d,",key);
    return 0;
}

void testAVL()
{
    AVLTree<int, int> *tree = new AVLTree<int,int>(cmp,dump);
    for(int i = 0;i < 20;i++){
       printf("\n-- insert: %d\n",i);
       tree->insert(i,i);
       tree->dump3();
    }
    tree->dump3();
    for(int i = 19;i  >= 0;i--){
        printf("\n-- remove: %d\n",i);
        tree->remove(i);
        tree->dump3();
    }
    tree->dump3();
}

int main(){

    testAVL();
    return 0;
}

jhkwei
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
平衡二叉树 AVL树 实现 C语言
su_1998的博客
12-16 1520
平衡树
平衡二叉（AVL）树
月守护的博客
12-15 946
在前面的系列文章中，我们讲过了二叉查找树的相关知识和实现（二叉树（一）–概述（附二叉搜索树实现））。在文章的最后，我们总结了二叉查找树的查找时间复杂度： 对于一个节点分布相对均衡的二叉查找树来说，如果节点总数是n，那么搜索节点的时间复杂度是O（logn）,和树的深度是一样的。 但对于极端情况（每次插入数据大小都是增大的，或者减小的），外形上看就只有一半的树，查找时间复杂度就会退化成O（n）的 为了解决二叉查找树查找时间复杂度退化的问题，需要二叉数据的自平衡，也就是本节要讲的平衡二叉树。通过自身的平衡调整
AVL树 C++ 实现
03-05
平衡二叉树(AVL)的C++实现。 用泛型写的。 IDE为VS2008 好像没别的了~ 就怎么个东西
手把手教你实现AVL树、平衡二叉树
weixin_61857742的博客
04-07 1459
今天，小编带大家一起来学习平衡二叉树（AVL树）吧。以下就简称AVL树了。 想必能点开这篇博客的朋友都是极度深爱计算机的，那今天就让我们一起揭开AVL树的神秘面纱吧！ 目录 一.基本概念 二.实现原理 （一）插入左子树 ①插入左子节点 ②插入右子节点 （二）插入右子树 ①插入右子节点 ②插入左子节点 （三）左旋转 （四）右旋转 三.代码实现 一.基本概念 AVL树得名于它的发明者G. M. Adelson-Velsky和E. M. Landis。 AVL树是搜索二叉树的一
详解AVL树（平衡二叉树）
热门推荐
水澹澹兮生烟
09-20 2万+
插入节点后对树进行旋转调整，分为四种情况。 1.右单旋 当一个平衡二叉树满足具有较高左子树时（如下图A），且要插入的节点插入到了较高左子树的左侧，此时进行右单旋。
平衡二叉排序树之AVL树（C语言实现）
zhao_Tao_WA的博客
07-01 662
本文详细介绍了平衡二叉排序树中的AVL树，对失衡类型和不同失衡类型的调整方式做了细致的描写，并用C语言实现了AVL树
【二叉树】用python实现AVL树
guofei_fly的博客
06-03 1443
AVL树是平衡的二叉搜索树，其任意节点的平衡因子（左子树高度-右子树高度）始终为-1、0或1。AVL树的结构能够解决普通BTS由于有序插入导致的退化为链表的情况。 AVL树在二叉搜索树实现的基础上，主要在添加和删除节点时更新子树相关节点的平衡因子，同时对不平衡的子树进行旋转操作。其机制较为复杂，本文先介绍相关的背景知识，在做代码的实现。 1. 背景知识 1.1 节点平衡因子的调整顺序 与普通二叉搜索树不同的是：添加节点后相关节点的平衡因子因做出调整。其基本规则包括： （1）若该节点为左节点，则其父节点的平衡
AVL平衡树插入非递归实现 C语言
luohui12的博客
09-22 1052
看了数据结构与算法树一章，决心写出AVL平衡树非递归插入算法。折腾两个晚上终于弄完，其中用到了C++中的栈模板，实在不想在写一个栈了。 总体实现思路如下： 1. 若为空直接创建树 2. 查找插入位置 3. 插入 4. 计算新树节点高度 5.平衡新树 AvlTree InsertWithoutRecursion(int X, AvlTree T) { /** insert node into
平衡树——AVL算法
_int_me的博客
05-02 1076
有关AVL树的解析
平衡二叉树（AVL树）
Xpccccc的博客
03-27 1326
平衡二叉树（AVL树）
avl.rar_avl_平衡树
09-20
AVL树是一种自平衡二叉查找树（BST），...为了理解并使用这个AVL树实现，你需要阅读和理解源代码，以及查看或遵循文本文件中的指示。理解AVL树的工作原理对于学习数据结构和算法，尤其是树形结构的优化，是非常有益的。
AVL平衡树及插入操作的C语言实现
06-21
AVL平衡树是一种自平衡的二叉搜索树（Binary Search Tree），由G. M. Adelson-Velsky和E. M. Landis于1962年提出，因此得名AVL树。在AVL树中，任何节点的两个子树的高度最大差别不超过1，这确保了树的平衡性，从而...
avl树实现hash表
12-29
在本项目中，我们将讨论如何结合这两种数据结构，利用avl树实现哈希表，以达到更好的性能效果。 首先，让我们了解一下avl树。avl树是一种自平衡二叉搜索树（BST），它的特点是任何节点的两个子树的高度最大差别不...
C++平衡Avl树实现.zip
08-20
总的来说，C++实现AVL树涉及到理解二叉搜索树、平衡树的概念，熟悉递归算法，掌握旋转操作的逻辑，以及编写相应的测试用例。通过这样的实现，我们可以创建一个高效的数据结构，用于处理大量数据的快速查找、插入和...
算法014：找到字符串中所有字母异位词
m0_62319039的博客
07-14 433
算法014：找到字符串中所有字母异位词
LC53最大子数组和、lc5最长回文子串、lc283移动零
m0_47536537的博客
07-14 201
请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。连续子数组 [4,-1,2,1] 的和最大，为 6。移动到数组的末尾，同时保持非零元素的相对顺序。，必须在不复制数组的情况下原地对数组进行操作。"aba" 同样是符合题意的答案。是数组中的一个连续部分。，编写一个函数将所有。LC53最大子数组和。
树状数组（Binary Indexed Tree, BIT）
qq_73702550的博客
07-12 395
树状数组（Binary Indexed Tree, BIT），也称为 Fenwick Tree，是一种用于高效处理数组前缀和查询和单点更新的数据结构。它能够在 (O(\log n)) 时间内完成单点更新和前缀和查询操作。
代码随想录算法训练营第三十二天
最新发布
weixin_44791877的博客
07-14 215
这道题自己思考ac出来了，主要是这道题需要使用二维的dp数组进行规划，由于动归是递推的，所以从结果向前思考，因此到右下角的方法只能由右下角这个格子或者左边这个格子走过来，因此右下角这个格子的方法数应该等于上一个格子的方法数加上左边这个格子的方法数。值得注意的是只有一行的或者一列的每个格子都只有1种方法，还有就是多行多列的边界格子也是只有一种方法，这个也是要初始化的。然后初始化边界的时候在障碍物之前的都初始化为1，障碍物以及障碍物之后的都初始化为0；首先几个特殊情况 当障碍物在起点或者终点的话直接返回0；
2024C++信息素养大赛-算法创意实践挑战_复赛真题（广东省）题目+参考答案和详细解析
m0_74586426的博客
07-12 940
2024C++信息素养大赛-算法创意实践挑战_复赛真题（广东省）题目+参考答案和详细解析
AVL平衡树(非指针实现）
06-03
AVL平衡树是一种自平衡二叉查找树，主要解决二叉查找树在插入和删除操作时可能会失去平衡的问题。在AVL平衡树中，每个节点都有一个平衡因子，即左子树的高度减去右子树的高度，平衡因子的值只能为-1、0、1三种。当插入或删除一个节点后，如果导致某个节点的平衡因子的绝对值大于1，就需要通过旋转操作来重新平衡这个节点及其子树。 下面是一个非指针实现的AVL平衡树的示例代码： ```c++ #include <iostream> using namespace std; const int MAXN = 100; class AVLTree { public: AVLTree() : size(0) {} bool insert(int val) { if (size == MAXN) return false; root = insert(root, val); size++; return true; } bool remove(int val) { if (size == 0) return false; root = remove(root, val); size--; return true; } void print() { inorder(root); } private: struct Node { int val, h; Node *l, *r; Node(int v, Node *L = NULL, Node *R = NULL) : val(v), h(0), l(L), r(R) {} int height() { return this ? h : -1; } int balance() { return r->height() - l->height(); } void update() { h = max(l->height(), r->height()) + 1; } Node *rotate_left() { Node *p = r; r = p->l; p->l = this; update(); p->update(); return p; } Node *rotate_right() { Node *p = l; l = p->r; p->r = this; update(); p->update(); return p; } Node *rotate_left_right() { r = r->rotate_right(); return rotate_left(); } Node *rotate_right_left() { l = l->rotate_left(); return rotate_right(); } }; Node *root; int size; Node *insert(Node *p, int val) { if (!p) return new Node(val); if (val < p->val) { p->l = insert(p->l, val); if (p->balance() == 2) { if (val < p->r->val) p = p->rotate_right_left(); else p = p->rotate_left(); } } else if (val > p->val) { p->r = insert(p->r, val); if (p->balance() == -2) { if (val > p->l->val) p = p->rotate_left_right(); else p = p->rotate_right(); } } p->update(); return p; } Node *remove(Node *p, int val) { if (!p) return NULL; if (val < p->val) { p->l = remove(p->l, val); if (p->balance() == -2) { if (p->l->balance() <= 0) p = p->rotate_right(); else p = p->rotate_left_right(); } } else if (val > p->val) { p->r = remove(p->r, val); if (p->balance() == 2) { if (p->r->balance() >= 0) p = p->rotate_left(); else p = p->rotate_right_left(); } } else { if (!p->l && !p->r) { delete p; return NULL; } else if (p->l) { Node *q = p->l; while (q->r) q = q->r; p->val = q->val; p->l = remove(p->l, q->val); if (p->balance() == -2) { if (p->l->balance() <= 0) p = p->rotate_right(); else p = p->rotate_left_right(); } } else { Node *q = p->r; while (q->l) q = q->l; p->val = q->val; p->r = remove(p->r, q->val); if (p->balance() == 2) { if (p->r->balance() >= 0) p = p->rotate_left(); else p = p->rotate_right_left(); } } } p->update(); return p; } void inorder(Node *p) { if (!p) return; inorder(p->l); cout << p->val << " "; inorder(p->r); } }; ``` 这里实现了AVL平衡树的插入、删除和中序遍历操作。其中，AVL平衡树的旋转操作被封装在了节点结构体中，包括左旋、右旋、左右旋和右左旋四种情况。具体实现时，需要注意节点的高度、平衡因子的计算和更新，以及对树的递归遍历等细节问题。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值