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

最新推荐文章于 2022-10-16 01:56:09 发布
最新推荐文章于 2022-10-16 01:56:09 发布
阅读量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++实现树 - 07 平衡二叉树
Newin2020的博客
05-29 1526
写在前面： 这一讲我们来讲讲目前为止难度最大的一种树，当然后面要有 B 树、B+ 树和红黑树等着我们。同样，我会将详细的代码附到详解的最后。 平衡二叉树的定义 我们之前学了二叉排序树，但是二叉排序树存在一个致命的问题，如果我每次插入的值都比上一次插入的大，那它就会形成一个斜树，这对我们的查找删除等功能影响很大。 我们经过平衡操作就可以得到这样一颗树（具体如何操作下面会讲到）： 所以平衡二叉树就由此诞生了，平衡二叉树定义其可以为空树，但是每个结点的左右子树的高度只差不能超过 1 ，所以就引入了一个新概.
C++ 实现平衡二叉树(AVL树)(完整代码)
m0_51955470的博客
05-10 1164
#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++实现
专栏
09-14 635
下面是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; // 关键字(
经典算法：以中序遍历为例，线索化二叉树
elliptical的专栏
10-16 894
线索二叉树是另一种分步遍历二叉树的方法。它既可以从前向后分步遍历二叉树，又可以从后向前分步遍历二叉树。
无栈非递归中序遍历非线索化二叉树
?.?的专栏
10-30 4410
试设计一个非递归算法，按中根顺序遍历非线索二叉树，但不得用任何辅助。在执行算法期间，允许改变LLINK和RLINK的值。   如何不用辅助栈非递归遍历二叉树呢？这里给出了一个比较方便的算法，其基本思路是依次将每个结点p左子树的最右结点指向p，不停回溯，用类似右线索化的方式中序遍历二叉树。   具体算法如下所示：   1. 若p有左儿子：                         ...
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）：当一个节点的右子节点过高时，需要...
线索二叉树的递归与非递归实现 数据结构作业
01-07
（1）递归实现二叉树的中序线索化 （2）非递归实现二叉树的中序线索化 （3）实现中序线索二叉树上遍历二叉树
线索二叉树（中序线索化，非递归遍历）
Basic_ants的博客
02-20 1467
#include<stdio.h> #include<stdlib.h> typedef char Type; typedef struct Node{ Type val; struct Node *lchild, *rchild; int ltag, rtag;//0-thread, 1-link }Node, *Bptr; Bptr pre; void I...
C++实现平衡搜索树
qingdou_aixuexi的博客
09-21 1857
AVL树 左子树和右子树的高度之差不超过1左子树和右子树都是AVL树 平衡因子=右子树个数-左子树 #define _CRT_SECURE_NO_WARNINGS 1 #include #include using namespace std; template struct AVLTreeNode { K _key; V _value; AVLT
线索二叉树和非递归遍历（中序）
Lau's Blog
05-09 1305
基于中序遍历的线索二叉树和非递归遍历 #include <stdio.h> #include <malloc.h> #define MaxSize 100 typedef char ElemType; typedef struct node { ElemType data; int ltag,rtag; //增加的线索标记 struct node *lchild; struct node *rchild; } TBTNode; void CreateTBTNo
二叉树遍历的非递归算法
热门推荐
m0_63223213的博客
08-05 1万+
非递归的算法主要采用的是循环出栈入栈来实现对二叉树的遍历，下面是过程分析
线索化二叉树，前序中序后序遍历（递归和非递归实现）
guoxu00的博客
08-26 2933
#include&lt;iostream&gt; #include&lt;string.h&gt; using namespace std; enum PionerInfo { LINK,THREAD }; template&lt;class T&gt; struct BinTreeNode { BinTreeNode(const T&amp; data) : _pLeft(NULL)...
线索二叉树后序线索化，非递归后序遍历输出
yogur_father的博客
05-27 1466
线索二叉树后序线索化，后序遍历输出 一.写码思路 我们要进行后序遍历的化，需要记录每个结点的 Parent 结点，我之前觉得可能不需要这个，直接用前驱就行了，但是后序遍历结点的前驱不一定是他的 Parent 结点。 例如下面这个例子 B的Parent结点时A，但他的前驱是E 因此我们这个结点设定为如下 template<class T> struct TreeNode { T Data; TreeNode* Lkid; TreeNode* Rkid; TreeNode* Paren
线索二叉树的建立（C/C++语言，非递归）
bucterman的博客
04-23 1705
主要还是参考王道的C语言督学营，给自己做个笔记，方便以后复习吧，虽然以后这种简单的代码也许我可以随手写出来。递归更简单，但是我真的理解不了。 题目：读取10个元素 87 7 60 80 59 34 86 99 21 3，然后建立二叉查找树，中序遍历输出3 7 21 34 59 60 80 86 87 99 #define _CRT_SECURE_NO_WARNINGS//vs2019中要用scanf要有这个接口 #include<stdio.h> #include<stdlib...
不用栈，来实现二叉树的非递归中序遍历
五月花
12-02 3383
如果要求只能用非递归方法，同时还不让用栈，来遍历完全二叉树，则每个结点必须有一个指向父结点的指针。 题目： 完全二叉树，采用三叉链表结构。 要求 不用递归，中序遍历这棵树。要求空间复杂度是O(1). 分析：题目不让用递归，那就用迭代，同时，空间复杂度是常量级，摆明了不让用栈。 那就必须是三叉链表了。三叉链表是二叉树的另一种主要的链式存储结构。三叉链表与二叉链表的主要区别在
C++实现基础算法：链表操作与平衡二叉树
通常，平衡二叉树的实现包括AVL树或红黑树等，它们都涉及到复杂的旋转操作以保持树的平衡。 这两个文档提供了关于C++基础数据结构操作和高级数据结构——平衡二叉树的初步了解。学习和理解这些概念对于深入理解和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值