树（四）：平衡二叉树(AVL) C++实现

最新推荐文章于 2023-06-08 19:38:14 发布
最新推荐文章于 2023-06-08 19:38:14 发布
阅读量411 收藏
点赞数 1
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Worthy_Wang/article/details/103498698
版权

树系列文章：
树（一）：二叉树(BiTree) 创建+销毁+前中后层遍历（递归+非递归）C++

树（二）：线索二叉树(ThreadBiTree) 线索化及其非递归遍历C++

树（三）：二叉排序树（BST） C++实现

树（四）：平衡二叉树(AVL) C++实现

树（五）：哈夫曼树(HuffmanTree) C++实现

文章目录

前言

AVL树相当于是在BST（二叉搜索树）的基础上进行了改进，因为简单的BST并不能保证一个较高的查找成功率，最坏情况下可能会编程链表形式，也就是O(n)的时间复杂度；如果能让左子树与右子树的高度绝对值小于等于1，那么可以将查找成功率变为最大，并且复杂度变为O(logn)。

由于AVL树的编写较为复杂，我们这里只展示AVL树的核心代码，完整的代码可以参考这一篇文章：
AVL之C++实现


树节点的旋转

可以说只要搞懂了AVL节点的旋转规律，也就搞懂了AVL树，整个AVL树在代码中本质上只涉及左旋(RR)和右旋(LL)。LR旋转和RL旋转也只是在前两种旋转的基础上做了一些改变。

  • RR旋转
//RR 左旋
TreeNode *AVLTree::RR(TreeNode *root)
{
    TreeNode* rchild = root->right;
    root->right = rchild->left;
    rchild->left = root;
    root->height = std::max(getHeight(root->left), getHeight(root->right)) + 1;
    rchild->height = std::max(getHeight(rchild->left), getHeight(rchild->right)) + 1;
    return rchild;
}
  • LL旋转

//LL 右旋
TreeNode *AVLTree::LL(TreeNode *root)
{
    TreeNode* lchild = root->left;
    root->left = lchild->right;
    lchild->right = root;
    root->height = std::max(getHeight(root->left), getHeight(root->right)) + 1;
    lchild->height = std::max(getHeight(lchild->left), getHeight(lchild->right)) + 1;
    return lchild;
}

RL与LR实质上也就是上面两种旋转的结合。

  • LR旋转
//LR 先左旋再右旋，左旋后整个树实际上也就变成了LL的模样
TreeNode* AVLTree::LR(TreeNode* root)
{
    root->left = RR(root->left);
    return LL(root);
}
  • RL旋转
//RL旋 先右旋再左旋，右旋后整个树实质上也就变成了RR的模样
TreeNode* AVLTree::RL(TreeNode* root)
{
    root->right = LL(root->right);
    return RR(root);
}
  • AVL树的插入
TreeNode* AVLTree::insertNode(TreeNode *root, int val)
{
    if (!root)
    {
        TreeNode* node = new TreeNode(val);
        return node;    
    }

    if (root->val == val)
    {
        return root; //AVL树中已经有该节点，不能够再插入
    }
    else if (val > root->val)
    {
        //向右插入
        root->right = insertNode(root->right, val);
        //插入新节点后如果失去平衡则调整
        if (getHeight(root->right) - getHeight(root->left) == 2)
        {
            TreeNode* t = root->right;
            if (getHeight(t->left) > getHeight(t->right))
                root = RL(root);
            else
                root = RR(root);
        }
    }else if (val < root->val)
    {
        //向左插入
        root->left = insertNode(root->left, val);
        //插入新节点后如果失去平衡则调整
        if (getHeight(root->left) - getHeight(root->right) == 2)
        {
            TreeNode* t = root->left;
            if (getHeight(t->left) > getHeight(t->right))
                root = LL(root);
            else
                root = LR(root);
        }
    }
    root->height = std::max(getHeight(root->left), getHeight(root->right)) + 1;
    return root;
}
  • AVL树的 删除
TreeNode *AVLTree::deleteNode(TreeNode *root, int key)
{
    if (!root)//该节点并不存在
        return nullptr;

    if (key < root->val)
    {
        //key在root左侧
        root->left = deleteNode(root->left, key);
        if (getHeight(root->right) - getHeight(root->left) == 2)
        {
            TreeNode* t = root->right;
            if (getHeight(t->right) > getHeight(t->left))
                root = RR(root);
            else
                root = RL(root);
        }
    }else if (key > root->val)
    {
        //key在root右侧
        root->right = deleteNode(root->right, key);
        if (getHeight(root->left) - getHeight(root->right) == 2)
        {
            TreeNode* t = root->left;
            if (getHeight(t->left) > getHeight(t->right))
                root = LL(root);
            else
                root = LR(root);
        }
    }else
    {
        //找到要删除的节点key
        if (root->left && root->right)
        {
            if (getHeight(root->left) > getHeight(root->right))//从更高的子树开始删除，可以保证删除之后AVL仍然平衡
            {
                TreeNode* t = root->left;
                while(t->right)
                    t = t->right;
                root->val = t->val;
                root->left = deleteNode(root->left, t->val);
            }else
            {
                TreeNode* t = root->right;
                while(t->left)
                    t = t->left;
                root->val = t->val;
                root->right = deleteNode(root->right, t->val);
            }
        }else
        {
            TreeNode* t = root;
            root = root->left ? root->left : root->right;
            delete t;
            return root;
        }
    }

    root->height = std::max(getHeight(root->left), getHeight(root->right)) + 1;
    return root;
}

1.LL旋转

插入之前树结构如下：
在这里插入图片描述
插入0之后：
在这里插入图片描述
LL旋转后：
在这里插入图片描述

2.LR旋转

基础树结构如下：
在这里插入图片描述
插入3之后：
在这里插入图片描述
LR旋转：先左旋，再右旋
先让根节点的左孩子左旋：
在这里插入图片描述
再让根节点右旋：
在这里插入图片描述

3.RR旋转

基本树结构如下：
在这里插入图片描述
插入7, 9 之后：
在这里插入图片描述
RR旋转后：
在这里插入图片描述

4.RL旋转

基本树结构如下：
在这里插入图片描述
插入4之后：
在这里插入图片描述
RL旋转：先右旋再左旋

先对根节点右孩子进行右旋：
在这里插入图片描述
然后对根节点进行左旋：
在这里插入图片描述

AVL程序代码

#include <iostream>
#include <vector>
#include <algorithm>
#include <sstream>
using namespace std;

/*********************************AVL(平衡二叉树)**************************************/
/*********************************类申明**************************************/
struct TreeNode
{
    int val;
    int height;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int val) : val(val), height(1), left(NULL), right(NULL) {}
};

class AVLTree
{
    TreeNode *_root;
public:
    AVLTree();
    AVLTree(string s);
    ~AVLTree();

    void preTraverse(TreeNode *);              //前序遍历
    void inTraverse(TreeNode *);               //中序遍历AVL树，结果应由大到小
    TreeNode *search(TreeNode *, int val);     //查询操作，找到则返回节点，否则返回NULL
    TreeNode *getRoot() const { return _root; }
    TreeNode* insertNode(TreeNode *, int val);         //插入节点操作
    TreeNode *deleteNode(TreeNode *, int val); //删除操作
    void insertNode(int val);         //插入节点操作
    void deleteNode(int val); //删除操作

    //AVL树特有的成员变量
    TreeNode *RR(TreeNode *);    //左旋
    TreeNode *LL(TreeNode *);   //右旋
    TreeNode *LR(TreeNode *);   //先左旋再右旋
    TreeNode *RL(TreeNode *);   //先右旋再左旋
    int getHeight(TreeNode *);           //求树的高度
private:
    void destroyAVLTree(TreeNode *);
};

/*********************************类成员定义**************************************/

AVLTree::AVLTree()
:_root(nullptr)
{
    cout << "AVLTree()" << endl;
}

AVLTree::AVLTree(string s)
    : _root(NULL)
{
    cout << "AVLTree()" << endl;
    stringstream ss(s);
    int val;
    while (ss >> val)
        _root = insertNode(_root, val);
}

AVLTree::~AVLTree()
{
    if (_root)
    {
        destroyAVLTree(_root);
        cout << "~AVLTree()" << endl;
    }
}

void AVLTree::destroyAVLTree(TreeNode *root)
{
    if (!root)
        return;
    else
    {
        destroyAVLTree(root->left);
        destroyAVLTree(root->right);
        delete root;
        root = NULL;
    }
}

void AVLTree::preTraverse(TreeNode *TreeNode)
{
    if (TreeNode)
    {
        cout << TreeNode->val << " ";
        preTraverse(TreeNode->left);
        preTraverse(TreeNode->right);
    }
}

void AVLTree::inTraverse(TreeNode *TreeNode)
{
    if (TreeNode)
    {
        inTraverse(TreeNode->left);
        cout << TreeNode->val << " ";
        inTraverse(TreeNode->right);
    }
}

TreeNode *AVLTree::search(TreeNode *p, int val)
{
    if (!p)
        return NULL;
    else if (val < p->val)
        return search(p->left, val);
    else if (val > p->val)
        return search(p->right, val);
    else
        return p;
}


int AVLTree::getHeight(TreeNode *root)
{
    if (!root)
        return 0;
    else
        return root->height;
}

TreeNode *AVLTree::RR(TreeNode *root)
{
    TreeNode* rchild = root->right;
    root->right = rchild->left;
    rchild->left = root;
    root->height = std::max(getHeight(root->left), getHeight(root->right)) + 1;
    rchild->height = std::max(getHeight(rchild->left), getHeight(rchild->right)) + 1;
    return rchild;
}

TreeNode *AVLTree::LL(TreeNode *root)
{
    TreeNode* lchild = root->left;
    root->left = lchild->right;
    lchild->right = root;
    root->height = std::max(getHeight(root->left), getHeight(root->right)) + 1;
    lchild->height = std::max(getHeight(lchild->left), getHeight(lchild->right)) + 1;
    return lchild;
}

TreeNode* AVLTree::LR(TreeNode* root)
{
    root->left = RR(root->left);
    return LL(root);
}

TreeNode* AVLTree::RL(TreeNode* root)
{
    root->right = LL(root->right);
    return RR(root);
}


TreeNode* AVLTree::insertNode(TreeNode *root, int val)
{
    if (!root)
    {
        TreeNode* node = new TreeNode(val);
        return node;    
    }

    if (root->val == val)
    {
        return root; //AVL树中已经有该节点，不能够再插入
    }
    else if (val > root->val)
    {
        //向右插入
        root->right = insertNode(root->right, val);
        //插入新节点后如果失去平衡则调整
        if (getHeight(root->right) - getHeight(root->left) == 2)
        {
            TreeNode* t = root->right;
            if (getHeight(t->left) > getHeight(t->right))
                root = RL(root);
            else
                root = RR(root);
        }
    }else if (val < root->val)
    {
        //向左插入
        root->left = insertNode(root->left, val);
        //插入新节点后如果失去平衡则调整
        if (getHeight(root->left) - getHeight(root->right) == 2)
        {
            TreeNode* t = root->left;
            if (getHeight(t->left) > getHeight(t->right))
                root = LL(root);
            else
                root = LR(root);
        }
    }
    root->height = std::max(getHeight(root->left), getHeight(root->right)) + 1;
    return root;
}

void AVLTree::insertNode(int val)
{
    _root  = insertNode(_root, val);
}

void AVLTree::deleteNode(int val)
{
    _root = deleteNode(_root, val);
}

TreeNode *AVLTree::deleteNode(TreeNode *root, int key)
{
    if (!root)//该节点并不存在
        return nullptr;

    if (key < root->val)
    {
        //key在root左侧
        root->left = deleteNode(root->left, key);
        if (getHeight(root->right) - getHeight(root->left) == 2)
        {
            TreeNode* t = root->right;
            if (getHeight(t->right) > getHeight(t->left))
                root = RR(root);
            else
                root = RL(root);
        }
    }else if (key > root->val)
    {
        //key在root右侧
        root->right = deleteNode(root->right, key);
        if (getHeight(root->left) - getHeight(root->right) == 2)
        {
            TreeNode* t = root->left;
            if (getHeight(t->left) > getHeight(t->right))
                root = LL(root);
            else
                root = LR(root);
        }
    }else
    {
        //找到要删除的节点key
        if (root->left && root->right)
        {
            if (getHeight(root->left) > getHeight(root->right))//从更高的子树开始删除，可以保证删除之后AVL仍然平衡
            {
                TreeNode* t = root->left;
                while(t->right)
                    t = t->right;
                root->val = t->val;
                root->left = deleteNode(root->left, t->val);
            }else
            {
                TreeNode* t = root->right;
                while(t->left)
                    t = t->left;
                root->val = t->val;
                root->right = deleteNode(root->right, t->val);
            }
        }else
        {
            TreeNode* t = root;
            root = root->left ? root->left : root->right;
            delete t;
            return root;
        }
    }

    root->height = std::max(getHeight(root->left), getHeight(root->right)) + 1;
    return root;
}




/**************************************测试函数****************************************/
//该测试函数和 参考文章中的测试函数相同，可对应着看
void test1()
{
    AVLTree tree;
    tree.insertNode(3);
    // tree.deleteNode(3);
}

void test2()
{
    AVLTree tree("3 2 1 4 5 6 7 16 15 14 13 12 11 10 8 9");
    tree.preTraverse(tree.getRoot());
    cout << endl;
    tree.inTraverse(tree.getRoot());
    cout << endl;
    cout << "Height:" << tree.getHeight(tree.getRoot()) << endl;

}

void test3()
{
    AVLTree tree("3 2 1 4 5 6 7 16 15 14 13 12 11 10 8 9");
    tree.deleteNode(8);
    tree.preTraverse(tree.getRoot());
    cout << endl;
    tree.inTraverse(tree.getRoot());
    cout << endl;
    cout << "Height:" << tree.getHeight(tree.getRoot()) << endl;

}

int main()
{
    test3();
    return 0;
}
Worthy_Wang
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉平衡树（C++）
wo_ai_luo_的博客
02-25 1023
平衡二叉树也叫做AVL树,AVL树的名字来源于它的发明作者G.M. Adelson-Velsky 和 E.M. Landis。AVL树是最先发明的自平衡二叉查找树(Self-Balancing Binary Search Tree,简称平衡二叉树。我们怎么知道这棵二叉搜索树平不平衡呢？我们知道，二叉搜索树的搜索时间和高度是有直接关系的，但是我们按递增、递减序输入之后，高度就和n一样了，所以时间复杂度为O(log n).想要优化，就是改变这棵二叉搜索树的高度。
C++ AVL树（高度平衡的二叉搜索树）
ChanJose的博客
03-25 627
一、思路 1.创建AVL树： 每次输入一个数num，然后用Insert()函数，将num插入到AVL树中。 // 创建AVL平衡树 template <class T> void AVLTree<T>::CreateAVLTree() { T num; cout << "请输入数（以-1结束输入）建立平衡二叉树...
二叉线索树（Threaded binary tree）
西湖有大葱的专栏
11-18 4007
二叉树是一种非线性结构，对二叉树进行遍历时，实际上那个是将二叉树这种非线性结构按某种需要转化成线性序列，但每次遍历二叉树时，都要用递归对其进行遍历，当二叉树的节点较多时，这样的效率是很低的。所以我们有没有办法把我们遍历的二叉树保存，方便以后遍历呢? 在一棵只有n个结点的二叉树中，假设有n个结点，那么就有2n个指针域，因为二叉树只用到了其中的n-1个结点，所以只要利用剩下的n+1个节点，我们就能把
Thread Tree(线索二叉树)
NextCodemonster的博客
12-25 716
Thread Tree(线索二叉树) 定义：在二叉树的结点上加上线索的二叉树称为线索二叉树，对二叉树以某种遍历方式（如先序、中序、后序或层次等）进行遍历，使其变为线索二叉树的过程称为对二叉树进行线索化。 二叉树的遍历本质上是将一个复杂的非线性结构转换为线性结构，使每个结点都有了唯一前驱和后继（第一个结点无前驱，最后一个结点无后继）。对于二叉树的一个结点，查找其左右子女是方便的，其前驱后继只有在遍...
平衡二叉树（C++实现）
qq_39559641的博客
11-04 8366
二叉树实现插入、查询、删除功能
C/C++数据结构（十一）—— 平衡二叉树（AVL树）
热门推荐
Edison's 小宇宙
01-19 2万+
平衡二叉树又称为 AVL 树，其实就是一颗 平衡的二叉搜索树，解决了二叉搜索树的不平衡问题。
C++实现AVL树（四种旋转详解）
Amber的博客
01-23 1178
一、概念AVL树又称为高度平衡的二叉搜索树，它能保持二叉树的高度平衡，尽量降低二叉树的高度，减少树的平均搜索长度。二、性质 树中每个左子树和右子树都是AVL树 左子树和右子树高度之差的绝对值（简称平衡因子）不超过1（0，1，-1） 平衡因子就是用右子树的高度减去左子树的高度 红色的就是每个节点的平衡因子 三、AVL树的插入如果在一棵原本是平衡的二叉搜索树中插入一个新节点，可能造成不平衡，此时
AVLTree 平衡二叉树c++实现
06-26
在C++中实现AVL树，通常会包含两个核心文件：头文件（.h）和源文件（.cpp）。头文件定义了AVL树的结构和相关的成员函数声明，而源文件则包含了这些函数的具体实现。 **CAVLTree.h头文件**中可能会包含以下内容： 1...
二叉树-基于C++实现的平衡二叉树.zip
最新发布
04-26
C++实现平衡二叉树时，我们需要定义一个二叉树节点结构体，包括节点值、颜色（对于红黑树）以及指向左子节点和右子节点的指针。接着，我们需要实现基本操作如插入、删除和查找，以及在这些操作后进行的平衡调整（如...
AVLTree自平衡二叉树C++模板类实现
01-19
使用C++实现的AVLTree自平衡二叉树，支持动态插入与删除操作，供C++数据结构课程学习与交流使用。
AVL树 C++ 实现
03-05
在C++中实现AVL树，我们可以利用模板类来创建一个泛型的数据结构，这样就可以处理不同类型的元素。 首先，我们需要定义AVL树的节点结构。每个节点包含三个部分：键（key）存储元素值，高度（height）用于计算树的...
平衡二叉树(AVL树)C++实现
08-10
3. **旋转操作**：AVL树的平衡是通过四种旋转操作来实现的，分别是左旋、右旋、左-右旋和右-左旋。这些操作用于在插入或删除节点后调整树的平衡。 - **左旋**（Left Rotation）：当一个节点的右子节点过高时，需要...
C++实现树 - 07 平衡二叉树
Newin2020的博客
05-29 1508
写在前面： 这一讲我们来讲讲目前为止难度最大的一种树，当然后面要有 B 树、B+ 树和红黑树等着我们。同样，我会将详细的代码附到详解的最后。 平衡二叉树的定义 我们之前学了二叉排序树，但是二叉排序树存在一个致命的问题，如果我每次插入的值都比上一次插入的大，那它就会形成一个斜树，这对我们的查找删除等功能影响很大。 我们经过平衡操作就可以得到这样一颗树（具体如何操作下面会讲到）： 所以平衡二叉树就由此诞生了，平衡二叉树定义其可以为空树，但是每个结点的左右子树的高度只差不能超过 1 ，所以就引入了一个新概.
平衡二叉树详解及C++实现
c661280411470yb的博客
06-08 734
平衡二叉搜索树
C++ 实现平衡二叉树(AVL树)(完整代码)
m0_51955470的博客
05-10 1158
#include <iostream> using namespace std; typedef int KeyType; class AVLNode { friend class AVLTree; public: AVLNode() :lchild(nullptr), rchild(nullptr) {}; private: KeyType key; int bf; AVLNode *lchild; AVLNode *rchild; }; class AVLTree { pub
平衡二叉树（AVL）的实现(详细) c++ 二叉排序树
Tree_sea的博客
07-31 3131
平衡二叉树概念 平衡二叉排序树（Balanced Binary Tree），因由前苏联数学家Adelson-Velskii 和 Landis于1962年首先提出的，所以又称为AVL树。 平衡二叉树是一种特殊的二叉排序树，理解平衡二叉树首先要理解什么是二叉排序树。 如果已经了解二叉排序树可以直接看下面平衡二叉树内容。 二叉排序树（Binary Sort Tree） 所谓二叉排序树(BST)即： （1）若该树的左子树不为空，那么左子树所以结点的值均小于其根结点的值。 （2）若该树的右子树不为空，那么右子树所
AVL平衡树的c++实现
专栏
09-14 633
下面是avl.h文件#ifndef _AVL_TREE_HPP_ #define _AVL_TREE_HPP_#include <iomanip> #include <iostream> using namespace std;template <class T> class AVLTreeNode{ public: T key; // 关键字(
AVL树（平衡二叉搜索树）详解及C++代码实现
m0_59074850的博客
12-13 296
AVL树的介绍和代码实现
哈希表（散列表） C++实现
Worthy_Wang的博客
02-24 1532
文章目录哈希函数哈希函数的构造方法处理散列冲突的方法散列表性能分析散列表C++代码实现 哈希函数 哈希函数就是 关键字Key 到 值Value 的映射： Value = f(Key) Value反映的是关键字Key的存储地址。 哈希函数的构造方法 直接定址法 f(Key) = a * Key + b 例如存放不同出生年份的人口数量，出生年份是关键字，那么可以用直接定址法。 直接定址法的优点是简单均匀，也不会产生冲突；缺点是该方法适合表比较小且连续的情况，所以 该方法虽然简单但是并不常用。 数
C++一些基本算法代码.docx
05-08
通常，平衡二叉树的实现包括AVL树或红黑树等，它们都涉及到复杂的旋转操作以保持树的平衡。 这两个文档提供了关于C++基础数据结构操作和高级数据结构——平衡二叉树的初步了解。学习和理解这些概念对于深入理解和...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值