AVL树的c++实现

最新推荐文章于 2022-04-23 22:51:34 发布
最新推荐文章于 2022-04-23 22:51:34 发布
阅读量181 收藏 1
点赞数
分类专栏： 面试算法题目解答
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sysucph/article/details/89042746
版权 
作为最古老的平衡排序二叉树，avl树算是比较经典了，闲着无聊，也自己实现一下，实现了插入和删除操作。
avl树的特点： 
     1. 排序二叉树； 
     2. 左右子树高度差小于等于1；

具体算法流程伪代码随便找一下都会有的，插入也没啥难度，就是判断树高是否发生变化，需要时进行旋转；
删除操作节点，然后转移到删除至多只有一个儿子的节点上，根据树高特点进行旋转；
删除和插入不同的一点，需要注意的是，有可能删除操作之后，左右节点高度差等于2的时候，有一种情况是插入的时候不会遇到的
       k3                         k3
      / \                        /
     k2  k1     删除k1之后，      k2
    /  \                       / \
   A   B                      A  B
这个时候只要执行k3右旋就可以了。
发现有bug烦请指正 

#ifndef __AVLTREE_H__
#define __AVLTREE_H__

#define AVLTREE_NODE avltree_node<KEY_TYPE, VALUE_TYPE>
#define AVLTREE_NODE_PTR avltree_node<KEY_TYPE, VALUE_TYPE>*
#include "util.h"

template<class KEY_TYPE, class VALUE_TYPE>
class avltree_node {
public:
    KEY_TYPE key;
    VALUE_TYPE value;
    int height;
    AVLTREE_NODE_PTR left_ptr;
    AVLTREE_NODE_PTR right_ptr;
    avltree_node(const KEY_TYPE &_key = KEY_TYPE(), const VALUE_TYPE &_value = VALUE_TYPE()): key(_key), value(_value), height(0), left_ptr(nullptr), right_ptr(nullptr) {} 
};

template<class KEY_TYPE, class VALUE_TYPE>
class avltree {
public:
    avltree() : root_ptr(nullptr), node_size(0) {}
    ~avltree();
    void insert(const KEY_TYPE &key, const VALUE_TYPE &value);
    AVLTREE_NODE_PTR get_root() { return root_ptr; }
    void clear();
    int get_height();
    int size() { return node_size; };
    void remove(const KEY_TYPE &key);

private:
    void clear(AVLTREE_NODE_PTR node_ptr);
    int get_height(AVLTREE_NODE_PTR node_ptr);
    AVLTREE_NODE_PTR new_node(const KEY_TYPE& key, const VALUE_TYPE& value);
    AVLTREE_NODE_PTR insert(AVLTREE_NODE_PTR cur_ptr, const KEY_TYPE &key, const VALUE_TYPE &value);
    AVLTREE_NODE_PTR rotateL(AVLTREE_NODE_PTR cur_ptr);
    AVLTREE_NODE_PTR rotateR(AVLTREE_NODE_PTR cur_ptr);
    AVLTREE_NODE_PTR rotateRL(AVLTREE_NODE_PTR cur_ptr);
    AVLTREE_NODE_PTR rotateLR(AVLTREE_NODE_PTR cur_ptr);
    AVLTREE_NODE_PTR remove(AVLTREE_NODE_PTR cur_ptr, const KEY_TYPE &key);
    AVLTREE_NODE_PTR find_min(AVLTREE_NODE_PTR cur_ptr);
    AVLTREE_NODE_PTR find_max(AVLTREE_NODE_PTR cur_ptr);

    AVLTREE_NODE_PTR root_ptr;
    int node_size;
};

template<class KEY_TYPE, class VALUE_TYPE>
avltree<KEY_TYPE, VALUE_TYPE>::~avltree()
{
    clear();
}

template<class KEY_TYPE, class VALUE_TYPE>
void avltree<KEY_TYPE, VALUE_TYPE>::clear()
{
    node_size = 0;
    clear(root_ptr);
}

template<class KEY_TYPE, class VALUE_TYPE>
void avltree<KEY_TYPE, VALUE_TYPE>::clear(AVLTREE_NODE_PTR node_ptr)
{
    if (node_ptr == nullptr) return;
    clear(node_ptr->left_ptr);
    clear(node_ptr->right_ptr);
    delete node_ptr;
}

template<class KEY_TYPE, class VALUE_TYPE>
AVLTREE_NODE_PTR avltree<KEY_TYPE, VALUE_TYPE>::new_node(const KEY_TYPE& key, const VALUE_TYPE &value)
{
    auto node = new AVLTREE_NODE(key, value);
    return node;
}

template<class KEY_TYPE, class VALUE_TYPE>
int avltree<KEY_TYPE, VALUE_TYPE>::get_height()
{
    return get_height(root_ptr);
}

template<class KEY_TYPE, class VALUE_TYPE>
int avltree<KEY_TYPE, VALUE_TYPE>::get_height(AVLTREE_NODE_PTR node_ptr)
{
    if (node_ptr == NULL) return -1;
    return node_ptr->height;
}

template<class KEY_TYPE, class VALUE_TYPE>
void avltree<KEY_TYPE, VALUE_TYPE>::insert(const KEY_TYPE &key, const VALUE_TYPE &value)
{
    root_ptr = insert(root_ptr, key, value);
    return;
}

template<class KEY_TYPE, class VALUE_TYPE>
AVLTREE_NODE_PTR avltree<KEY_TYPE, VALUE_TYPE>::insert(AVLTREE_NODE_PTR cur_ptr, const KEY_TYPE &key, const VALUE_TYPE &value)
{
    if (cur_ptr == nullptr) {
        cur_ptr = new_node(key, value);
        ++node_size;

    } else if (key < cur_ptr->key) {
        cur_ptr->left_ptr = insert(cur_ptr->left_ptr, key, value);
        if (get_height(cur_ptr->left_ptr) - get_height(cur_ptr->right_ptr) == 2)
        {
            if (key < cur_ptr->left_ptr->key)
                cur_ptr = rotateR(cur_ptr);
            else 
                cur_ptr = rotateLR(cur_ptr);
        }

    } else if (key > cur_ptr->key) {
        cur_ptr->right_ptr = insert(cur_ptr->right_ptr, key, value);
        if (get_height(cur_ptr->left_ptr) - get_height(cur_ptr->right_ptr) == -2)
        {
            if (key < cur_ptr->right_ptr->key)
                cur_ptr = rotateRL(cur_ptr);
            else
                cur_ptr = rotateL(cur_ptr);
        }
    } else {
        cur_ptr->value = value;
    }
    cur_ptr->height = max(height(cur_ptr->left_ptr), height(cur_ptr->right_ptr)) + 1;
    return cur_ptr;
}

template<class KEY_TYPE, class VALUE_TYPE>
AVLTREE_NODE_PTR avltree<KEY_TYPE, VALUE_TYPE>::rotateL(AVLTREE_NODE_PTR cur_ptr)
{
    auto subR_ptr = cur_ptr->right_ptr;
    auto subRL_ptr = subR_ptr->left_ptr;

    cur_ptr->right_ptr = subRL_ptr;
    subR_ptr->left_ptr = cur_ptr;

    cur_ptr->height = max(get_height(cur_ptr->left_ptr), get_height(cur_ptr->right_ptr)) + 1;
    subR_ptr->height = max(get_height(subR_ptr->left_ptr), get_height(subR_ptr->right_ptr)) + 1;
    return subR_ptr;
}


/* RL(D rotates to the right, then C rotates to the left):
         k3                         k3                          k2
        /  \                       /  \                        /  \
       A    k1                    A    k2                     k3   k1 
           /  \       ==>             /  \         ==>       /  \  / \
          k2   B                     C    k1                A   C D   B
         /  \                            /  \
        C    D                          D    B 
*/

template<class KEY_TYPE, class VALUE_TYPE>
AVLTREE_NODE_PTR avltree<KEY_TYPE, VALUE_TYPE>::rotateRL(AVLTREE_NODE_PTR cur_ptr)
{
    cur_ptr->right_ptr = rotateR(cur_ptr->right_ptr);
    return rotateL(cur_ptr);

}

template<class KEY_TYPE, class VALUE_TYPE>
AVLTREE_NODE_PTR avltree<KEY_TYPE, VALUE_TYPE>::rotateR(AVLTREE_NODE_PTR cur_ptr)
{
    auto subL_ptr = cur_ptr->left_ptr;
    auto subLR_ptr = subL_ptr->right_ptr;
    
    cur_ptr->left_ptr = subLR_ptr;
    subL_ptr->right_ptr = cur_ptr;

    cur_ptr->height = max(get_height(cur_ptr->left_ptr), get_height(cur_ptr->right_ptr)) + 1;
    subL_ptr->height = max(get_height(subL_ptr->left_ptr), get_height(subL_ptr->right_ptr)) + 1;
    return subL_ptr;
}

/* LR(B rotates to the left, then C rotates to the right):
         k3                         k3                       k2
        /  \                       /  \                     /  \
       k1   D                     k2   D                   k1   k3
      /  \         ==>           /  \        ==>          / \   / \
     A    k2                    k1   C                   A  B  C   D
         /  \                  /  \
        B    C                A    B
*/

template<class KEY_TYPE, class VALUE_TYPE>
AVLTREE_NODE_PTR avltree<KEY_TYPE, VALUE_TYPE>::rotateLR(AVLTREE_NODE_PTR cur_ptr)
{
    cur_ptr->left_ptr = rotateL(cur_ptr->left_ptr);
    return rotateR(cur_ptr);
}

template<class KEY_TYPE, class VALUE_TYPE>
void avltree<KEY_TYPE, VALUE_TYPE>::remove(const KEY_TYPE& key)
{
    root_ptr = remove(root_ptr, key);
}

template<class KEY_TYPE, class VALUE_TYPE>
AVLTREE_NODE_PTR avltree<KEY_TYPE, VALUE_TYPE>::find_min(AVLTREE_NODE_PTR cur_ptr)
{
    if (cur_ptr == nullptr || cur_ptr->left_ptr == nullptr) return cur_ptr;
    return find_min(cur_ptr->left_ptr);
}

template<class KEY_TYPE, class VALUE_TYPE>
AVLTREE_NODE_PTR avltree<KEY_TYPE, VALUE_TYPE>::find_max(AVLTREE_NODE_PTR cur_ptr)
{
    if (cur_ptr == nullptr || cur_ptr->right_ptr == nullptr) return cur_ptr;
    return find_max(cur_ptr->right_ptr);
}

template<class KEY_TYPE, class VALUE_TYPE>
AVLTREE_NODE_PTR avltree<KEY_TYPE, VALUE_TYPE>::remove(AVLTREE_NODE_PTR cur_ptr, const KEY_TYPE &key)
{
    AVLTREE_NODE_PTR temp = nullptr;
    if (cur_ptr == nullptr)
        return nullptr;
    else if (key < cur_ptr->key)
        cur_ptr->left_ptr = remove(cur_ptr->left_ptr, key);
    else if (key > cur_ptr->key)
        cur_ptr->right_ptr = remove(cur_ptr->right_ptr, key);
    else if (cur_ptr->left_ptr && cur_ptr->right_ptr)
    {
        temp = find_min(cur_ptr->right_ptr);
        cur_ptr->key = temp->key;
        cur_ptr->value = temp->value;
        cur_ptr->right_ptr = remove(cur_ptr->right_ptr, cur_ptr->key);
    } else {
        temp = cur_ptr;
        if (cur_ptr->left_ptr == nullptr)
            cur_ptr = cur_ptr->right_ptr; 
        else if (cur_ptr->right_ptr == nullptr) 
            cur_ptr = cur_ptr->left_ptr; 
        delete temp; 
        node_size--; 
    }

    if (cur_ptr == nullptr) return cur_ptr;

    auto left_height = height(cur_ptr->left_ptr), right_height = height(cur_ptr->right_ptr);
    cur_ptr->height = max(left_height, right_height) + 1;

    if (left_height - right_height == 2) {
        if (height(cur_ptr->left_ptr->right_ptr) > height(cur_ptr->left_ptr->left_ptr))
            return rotateLR(cur_ptr);
        else
            return rotateR(cur_ptr);

    } else if (right_height - left_height == 2) {
        if (height(cur_ptr->right_ptr->left_ptr) > height(cur_ptr->right_ptr->right_ptr))
            return rotateRL(cur_ptr);
        else
            return rotateL(cur_ptr);
    }
    return cur_ptr;
}

template<class KEY_TYPE, class VALUE_TYPE>
bool check_avltree_balance(avltree<KEY_TYPE, VALUE_TYPE> &tree)
{
    return check_avltree_balance(tree.get_root());
}

template<class KEY_TYPE, class VALUE_TYPE>
int height(AVLTREE_NODE_PTR root_ptr)
{
    if (root_ptr == nullptr) return -1;
    return root_ptr->height;
}

template<class KEY_TYPE, class VALUE_TYPE>
bool check_avltree_balance(AVLTREE_NODE_PTR root_ptr)
{
    if (root_ptr == nullptr) return true;
    return check_avltree_balance(root_ptr->left_ptr) && check_avltree_balance(root_ptr->right_ptr) && myabs(height(root_ptr->left_ptr) - height(root_ptr->right_ptr)) <= 1;
}

#endif
贱走偏锋
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
AVL树（C++）
11-05
基于 C++实现avl树的学生管理系统基于 可直接运行，代码全自己实现
AVL树的实现（C++)
King_DJF的博客
10-22 670
Implement of AVL_Tree using CppImplement of AVL_Tree using Cpp
C++中AVL树构建详解
Artorias的博客
05-13 1162
AVL树的定义 平衡二叉树由前苏联两位数学家GM.Adelse-Velskil、E.M.Landis提出，因此一般也称作AVL树。 AVL树从本质上说仍是一颗二叉搜索树，只是在其的基础上添加了平衡要求，使得树的高度在每次插入元素后仍可以保持O（logn）的级别。 所谓的平衡操作指的是对于AVL树的任意结点来说，其左子树和右子树的高度差的绝对值不超过1，其中左子树的高度减去右子树的高度称为该结点的平衡因子。 例如，对于下面的三棵树，根结点的平衡因子分别是 -1、2、-2 基本操作函数 1.结构体 因为需要对
AVL树( C++)
泡温泉
10-04 367
#include #include using namespace std; struct Node { int val; Node *left = nullptr; Node *right = nullptr; int factor = 0; Node(int i) : val(i) {}; }; class AVLTree { public:
AVL树(c++)
weixin_41009689的博客
05-04 255
最近学习了AVL树，书上讲解的第一遍没怎么看懂，在网上搜到一篇不错的贴子，然后结合自己的理解将知识记录下来以便以后的温习回顾 AVL树简介 AVL树的名字来源于它的发明作者G.M. Adelson-Velsky 和 E.M. Landis。AVL树是最先发明的自平衡二叉查找树（Self-Balancing Binary Search Tree,简称平衡二叉树）。 一棵AVL树有如下必要条件： 条...
AVL树 C++ 实现
03-05
平衡二叉树(AVL)的C++实现。 用泛型写的。 IDE为VS2008 好像没别的了~ 就怎么个东西
AVL树C++实现
10-20
学习AVL树的算法实现，使用c++在vc6.0中进行相应的算法实现，对正在学习算法的孩子有帮助
C++实现AVL树
11-15
C++实现AVL树,有兴趣的可以看看，可能不是很好，仅作为参考
C++ AVL树
weixin_53946312的博客
01-27 981
AVL树底层结构AVL树(高度平衡搜索二叉树)AVL树的插入四种旋转右单旋左单旋右左双旋左右双旋AVL实现代码AVL树的性能 底层结构 map/set/multimap/multiset等这些容器其底层都是按照二叉搜索树来实现的但是二叉搜索树有其自身的缺陷,eg:往树中插入的元素有序或接近有序，二叉搜索树就会退化成单支树，时间复杂度会退化成O(N),因此map,set等关联式容器的底层结构是对二叉树进行了平衡处理，即采用平衡树来来实现。 AVL树(高度平衡搜索二叉树) 二叉搜索树虽然可以缩短查找的效率，但如
AVL c++实现
12-18
AVL树是最先发明的自平衡二叉查找树。在AVL树中任何节点的两个儿子子树的高度最大差别为一，所以它也被称为高度平衡树。查找、插入和删除在平均和最坏情况下都是O（log n）。
AVL树C++实现（插入，删除，查找，清空，遍历操作）
weixin_34405557的博客
12-13 360
AVL.h文件代码 #pragma once #include<iostream> #include<stack> #include <assert.h> using namespace std; using namespace std; template<class T> struct AVLNode{ T data; AVLNo...
AVL实现 C++
苍茫大地的专栏
07-12 491
一. AVL概念：      对于一颗BST，其中每个节点的左右子树高度差均不超过1的平衡二叉搜索树，就叫做AVL树。  二. 如何维护一颗AVL树。      旋转操作：      1. rotateWithLeft:(右旋转)  *       (N)                (L)  *      /   \              /   \  *    (L)
AVL树(C++版本）
qq_50271250的博客
04-23 1457
前言 AVL是一个高度平衡的二叉搜索树，主要是为了减少查找的次数而降低树的高度。 关于二叉搜索树主要是关于二叉树的左旋和右旋以及无法平衡的四种状态 左旋：主要是右子树的高度过高了，所以要左旋，就是根节点与其右孩子交换一下，此时右孩子当作了根节点了，而之间的根节点就作为右孩子的左孩子，但是之前的右孩子是可能存在它的左子树的，这时就可以把这左子树连接之前根节点的右边作为根节点的右子树 右旋与左旋是对称的，就不再赘述 不平衡的四种状态 LL:即在根节点的左孩子的左子树上添加导致不平衡了，此时需要根节点右旋即可。
AVL数的实现（C++）
TANGY的博客
04-23 1759
二叉搜索树虽然可以加快查找效率，但当数据有序或接近有序时，二叉搜索树将退化为单支树，查找元素相当于在顺序表中搜索元素，效率低下。因此，当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之差的绝对值不超过1（需要对树中的结点进行调整），即可降低树的高度，从而减少平均搜索长度。 一颗AVL树或是空树，或是具有以下性质的二叉搜索树： 它的左右子树都是AVL数 它的左右子树高度之差（简称...
AVL的代码实现C++‘
qq_51711403的博客
06-01 162
AVL树的代码实现 这里先粘贴代码 给大家的忠告，一定要及时去实现，不然之后再实现要花跟多的时间 /* *平衡二叉树应该有些功能 *插入 删除 查找 *前序遍历 中序遍历 后序遍历 层次遍历 *统计结点数目 */ //代码已经调，写了很久才写出来 // #ifndef _AVLTREE_ #define _AVLTREE_ #include<iostream> #include<vector> #include<queue> #include<ma
AVL树—— C++实现
Mind_V的博客
05-22 632
AVL树的介绍 AVL树的C实现 AVL树节点 AVL树接口 旋转操作核心 1 LL的旋转 2 RR的旋转 3 LR的旋转 4 RL的旋转 完整的实现代码AVL树的介绍二叉查找树的深度越小，那么查找所需要的运算时间越小。一个深度为log(n)的二叉查找树，查找算法的时间复杂度也是log(n)。然而，我们在二叉查找树中已经实现的插入和删除操作并不能让保持log(n)的深度。如果我们按照8，7，6，5，
AVL树的实现——c++
weixin_30376163的博客
10-08 68
一、概念 AVL树是根据它的发明者G.M.Adelson-Velsky和E.M.Landis命名的。它是最先发明的自平衡二叉查找树，也被称为高度平衡树。相比于"二叉查找树"，它的特点是：AVL树中任何节点的两个子树的高度最大差别为1。 AVL树的查找、插入和删除在平均和最坏情况下都是O(logn)。如果在AVL树中插入或删除节点后，使得高度之差大于1。此时，AVL树的平衡状...
avl树c++
最新发布
05-24
下面是一个简单的AVL树的C++实现： ```c++ #include using namespace std; // AVL树节点 struct Node { int key; int height; Node *left; Node *right; Node(int k) : key(k), height(1), left(NULL), ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值