动态查找树 || 平衡二叉树的c++实现

最新推荐文章于 2023-06-02 00:00:42 发布
最新推荐文章于 2023-06-02 00:00:42 发布
阅读量353 收藏 2
点赞数
分类专栏： 数据结构 算法 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/perry0528/article/details/88710288
版权
c++ 同时被 3 个专栏收录
39 篇文章 1 订阅
订阅专栏
数据结构
29 篇文章 5 订阅
订阅专栏
算法
27 篇文章 1 订阅
订阅专栏

AVL树特性：
在满足二叉查找树的特性上，还要满足左右子树深度之差绝对值不大于1。

我们定义平衡因子（BF）：
该结点的左子树深度减去它的右子树的深度，则平衡二叉树上所有结点的深度只可能是-1，0或1。

构造方法：
插入过程中，采用平衡旋转技术获得。

一般来说，插入新结点后导致某一个结点的平衡因子绝对值大于1，失去平衡后进行调整的规律有以下四种情况：

  1. 单向右旋平衡处理：(a)
  2. 单向左旋平衡处理：©
  3. 双向旋转(先左后右)平衡处理：(b)（旋转两次）
  4. 双向旋转(先右后左)平衡处理：(d)

在这里插入图片描述
删除的算法类似，建议图图画好，分别讨论好每种对应的情况，不要遗漏。

  • hpp
//
//  AVLtree.hpp
//  AVLTree
//
//  Created by peiyu wang on 2019/3/21.
//  Copyright © 2019 peiyu wang. All rights reserved.
//

#ifndef AVLtree_hpp
#define AVLtree_hpp

#include <stdio.h>
#include <iostream>
#include <stdlib.h>
using namespace std;

/*宏定义*/
#define LH 1
#define EH 0
#define RH -1

typedef int KeyType;

struct AVLNode
{
    KeyType data;
    int bf;// 平衡因子
    AVLNode *lchild;
    AVLNode *rchild;
};

typedef AVLNode* AVLTree;

// 创建AVL树
int CreateAVL(AVLTree &T);
// 查找并返回指向key的指针，不存在则返回NULL
AVLTree SearchAVL(AVLTree T, KeyType key);
//插入
int InsertAVL(AVLTree &T, KeyType key, bool &taller);
// 删除
int DeleteFuc(AVLTree &T, KeyType key, AVLTree f, AVLTree p, bool &taller, int mark);
int DeleteAVL(AVLTree &T, KeyType key);
// 右平衡处理
void RightBalance(AVLTree &T);
// 左平衡处理
void LeftBalance(AVLTree &T);
// 右旋
void R_Rotate(AVLTree &p);
// 左旋
void L_Rotate(AVLTree &p);
// 中序遍历
void InOrderTraverse(AVLTree T);
// 求树的结点数
int NodeNum(AVLTree T);
// 求树的深度
int AVLDepth(AVLTree T);
// 打印树
void PrintAVLTree(AVLTree T);

#endif /* AVLtree_hpp */
  • cpp
//
//  AVLtree.cpp
//  AVLTree
//
//  Created by peiyu wang on 2019/3/21.
//  Copyright © 2019 peiyu wang. All rights reserved.
//

#include "AVLtree.hpp"
#include <vector>
#include <cmath>
int CreateAVL(AVLTree &T)
{
    int N = 0;
    bool t = false;
    vector<KeyType> keys;
    cout << "输入你想要组成查找表中元素的个数(上限为100)：" << endl;
    cin.clear();//重置错误输入
    cin.sync();//清空缓冲区
    cin >> N;
    cout << "----------------" << endl;
    cout << "输入你想要组成查找表中的元素：" << endl;
    cout << "----------------" << endl;
    for (int i = 0; i < N; i++)
    {
        KeyType key;
        cin.clear();//重置错误输入
        cin.sync();//清空缓冲区
        cin >> key;
        keys.push_back(key);
    }
    for (int i = 0; i < keys.size(); i++)
    {
        //cout << "123" << endl;
        InsertAVL(T, keys[i], t);
    }
    return true;
}

// 查找并返回指向key的指针，不存在则返回NULL
AVLTree SearchAVL(AVLTree T, KeyType key)
{
    if (!T || T->data == key)
        return T;
    else if (T->data > key)
        return SearchAVL(T->lchild, key);
    else
        return SearchAVL(T->rchild, key);
}
//插入
int InsertAVL(AVLTree &T, KeyType key, bool &taller)
{
    if (!T)
    {
        T = new AVLNode;
        T->data = key;
        T->lchild = T->rchild = NULL;
        T->bf = EH;
        taller = true;
    }
    else
    {
        if (T->data == key)
        {
            taller = false;
            return false;
        }
        else if (T->data > key)
        {
            if (!InsertAVL(T->lchild, key, taller))
            {
                return false;
            }
            if (taller)
            {
                switch (T->bf) {
                    case LH:
                        LeftBalance(T);
                        taller = false;
                        break;
                    case EH:
                        T->bf = LH;
                        taller = true;
                        break;
                    case RH:
                        T->bf = EH;
                        taller = false;
                        break;
                    default:
                        break;
                }
            }
        }
        else
        {
            if (!InsertAVL(T->rchild, key, taller))
            {
                return false;
            }
            if (taller)
            {
                switch (T->bf) {
                    case LH:
                        T->bf = EH;
                        taller = false;
                        break;
                    case EH:
                        T->bf = RH;
                        taller = true;
                        break;
                    case RH:
                        RightBalance(T);
                        taller = false;
                        break;
                    default:
                        break;
                }
            }
        }
    }
    return true;
}
// 删除
int DeleteFuc(AVLTree &T, KeyType key, AVLTree f, AVLTree p, bool &taller, int mark)
// p指向当前结点，f指向p的父结点，mark代表f与p的关系，用来代表p是f的左子树还是右子树，如果为0则为左，初始化为0
{
    AVLTree r;
    KeyType tmp;
    if (!p)
        return false;
    else
    {
        if (key < p->data)
        {
            if (!DeleteFuc(T, key, p, p->lchild, taller, 0))
                return false;
            if (taller)
            {
                switch (p->bf) {
                    case LH:
                        p->bf = EH;
                        taller = true;
                        break;
                    case RH:
                        // 分开讨论不能都用p的原因是T是引用&传参，可以通过形参引用改变实参的值。
                        if (!f)
                        {
                            RightBalance(T);
                        }
                        
                        else
                        {
                            RightBalance(p); // 删除p效果一样
                        }
                        taller = true;
                        break;
                    case EH:
                        p->bf = RH;
                        taller = false;
                        break;
                    default:
                        break;
                }
            }
        }
        else if (key > p->data)
        {
            if (!DeleteFuc(T, key, p, p->rchild, taller, 1))
                return false;
            if (taller)
            {
                switch (p->bf) {
                    case RH:
                        p->bf = EH;
                        taller = true;
                        break;
                    case LH:
                        if (!f)
                        {
                            LeftBalance(T);
                        }
                        else
                        {
                            LeftBalance(p);
                        }
                        taller = true;
                        break;
                    case EH:
                        p->bf = LH;
                        taller = true;
                        break;
                    default:
                        break;
                }
            }
        }
        else
        {
            if (p->rchild == NULL)
            {
                if (!f)
                {
                    T = p->lchild;
                }
                else
                {
                    if (mark == 0)
                    {
                        f->lchild = p->lchild;
                    }
                    else
                    {
                        f->rchild = p->lchild;
                    }
                }
                delete p;
                p = NULL;
                taller = true;
            }
            else if (p->lchild == NULL)
            {
                if (!f)
                {
                    T = p->rchild;
                }
                else
                {
                    if (mark == 0)
                    {
                        f->lchild = p->rchild;
                    }
                    else
                    {
                        f->rchild = p->rchild;
                    }
                }
                delete p;
                p = NULL;
                taller = true;
            }
            else
            {
                r = p->lchild;
                while (r->rchild)
                {
                    r = r->rchild;
                }
                tmp = r->data;
                taller = false;
                DeleteFuc(p, tmp, NULL, p, taller, 0);
                p->data = tmp;
            }
        }
        return true;
    }
}
// 右平衡处理
void RightBalance(AVLTree &T)
{
    AVLTree rc, ld;
    rc = T->rchild;
    switch (rc->bf) {
        case RH:
            rc->bf =EH;
            T->bf = EH;
            L_Rotate(T);
            break;
        case LH:
            ld = rc->lchild;
            switch (ld->bf) {
                case LH:
                    ld->bf = T->bf = EH;
                    rc->bf = RH;
                    break;
                case RH:
                    T->bf = LH;
                    ld->bf = rc->bf = EH;
                    break;
                case EH:
                    T->bf = ld->bf = rc->bf = EH;
                    break;
                default:
                    break;
            }
            R_Rotate(T->rchild);
            L_Rotate(T);
            break;
        default:
            break;
    }
}
// 左平衡处理
void LeftBalance(AVLTree &T)
{
    AVLTree lc, rd;
    lc = T->lchild;
    switch (lc->bf) {
        case LH:
            T->bf = lc->bf = EH;
            R_Rotate(T);
            break;
        case RH:
            rd = lc->rchild;
            switch (rd->bf) {
                case LH:
                    T->bf = RH;
                    rd->bf = lc->bf = EH;
                    break;
                case RH:
                    rd->bf = T->bf = EH;
                    lc->bf = LH;
                    break;
                // 感觉不会出现这种情况
                case EH:
                    rd->bf = T->bf = lc->bf = EH;
                    break;
                default:
                    break;
            }
            L_Rotate(T->lchild);
            R_Rotate(T);
            break;
        default:
            break;
    }
}
int DeleteAVL(AVLTree &T, KeyType key)
{
    bool taller = false;
    return DeleteFuc(T, key, NULL, T, taller, 0);
}
// 右旋
void R_Rotate(AVLTree &p)
{
    AVLTree q;
    q = p->lchild;
    p->lchild = q->rchild;
    q->rchild = p;
    p = q;
}
// 左旋
void L_Rotate(AVLTree &p)
{
    AVLTree q;
    q = p->rchild;
    p->rchild = q->lchild;
    q->lchild=p;
    p = q;
}
// 中序遍历
void InOrderTraverse(AVLTree T)
{
    if (!T)
        return;
    InOrderTraverse(T->lchild);
    cout << T->data << endl;
    InOrderTraverse(T->rchild);
}
// 求树的深度
int AVLDepth(AVLTree T)
{
    if (!T)
        return 0;
    int ld = AVLDepth(T->lchild);
    int rd = AVLDepth(T->rchild);
    return ld > rd ? ld + 1 : rd + 1;
}
//求树的结点数
int NodeNum(AVLTree T)
{
    if (!T)
        return 0;
    return 1 + NodeNum(T->lchild) + NodeNum(T->rchild);
}

// 打印树
void PrintAVLTree(AVLTree T)
{
    int row, col;
    int i, j, m, l, r;
    AVLNode a[100][100] = {};
    if (T)
    {
        row = AVLDepth(T);
        col = pow(2, row) - 1;
        for (i = 1; i <= row; i++)
        {
            for (j = 1; j <= pow(2, i-1); j++)
            {
                m = (2*j-1)*pow(2, row-i);
                l = (4*j-3)*pow(2, row-i-1);
                r = (4*j-1)*pow(2, row-i-1);
                
                if (i == 1)
                    a[i][m] = *T;
                if (a[i][m].lchild)
                    a[i+1][l] = *(a[i][m].lchild);
                if (a[i][m].rchild)
                    a[i+1][r] = *(a[i][m].rchild);
            }
        }
        for (i = 1; i <= row; i++)
        {
            for (j = 1; j <= col; j++)
            {
                if (a[i][j].data)
                {
                    printf("%2d", a[i][j].data);
                }
                else
                {
                    printf("  ");
                }
            }
            printf("\n");
        }
    }
}
  • main
//
//  main.cpp
//  AVLTree
//
//  Created by peiyu wang on 2019/3/21.
//  Copyright © 2019 peiyu wang. All rights reserved.
//

#include "AVLtree.hpp"

int main(int argc, const char * argv[]) {
    AVLTree T = NULL; //很重要，不然可能存在野指针。
    CreateAVL(T);
    InOrderTraverse(T);
    cout << "------------" << endl;
    PrintAVLTree(T);
    cout << "------------" << endl;
    cout << "Search key = 1" << endl;
    SearchAVL(T, 1) == NULL ? cout << "No" << endl : cout << "Yes" << endl;
    cout << "Delete key = 7" << endl;
    DeleteAVL(T, 7);
    //InOrderTraverse(T);
    PrintAVLTree(T);
    return 0;
}
  • 实现效果：
    在这里插入图片描述
perry0528
关注
专栏目录
平衡二叉树（c++）实现
知其所以然
03-21 1556
平衡二叉树（c++）实现 ------ 欢迎指正------- 1、参考资料： 　　书籍：《算法导论》 　　博文：http://www.cnblogs.com/fivestudy/fivestudy/p/10340647.html 原理讲的很棒。有动画，方便理解。 　　这个网站可以清晰看清楚平衡二叉树的插入删除等详细过程：https:...
平衡二叉树(AVL树)C++代码实现
RealCoder的博客
07-25 3878
目录平衡二叉树定义AVLAVLAVL树类的封装AVLAVLAVL树的插入操作与平衡化LLLLLL型调整RRRRRR型调整LRLRLR型调整RLRLRL型调整AVLAVLAVL树查找操作AVLAVLAVL树删除结点操作总源代码 平衡二叉树定义 为了使二叉排序树的平均查找长度更小，需要适当控制树高，显然，控制树高的一个有效措施就是尽量保持树的左右子树高度大致平衡，由此产生了平衡二叉树的概念。 G.M.Adelson−VelskiiG.M.Adelson-VelskiiG.M.Adelson−Velskii和E.
平衡二叉树（纯C++实现）
03-04
包含AVL树的创建，删除，查找等等功能，我使用的是VS2010的编译器，可能用版本低的编译器无法打开
C++实现平衡二叉树
Jinyao的博客
12-28 904
1.概念 平衡二叉树(AVL Tree)首先要满足二叉树的定义,如下 二叉排序树或者是一棵空树，或者是具有下列性质的二叉树： 若左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若右子树不空，则右子树上所有结点的值均大于它的根结点的值； 左、右子树也分别为二叉排序树； 没有键值相等的节点。 平衡度是左子树高度减去右子树高度，平衡度只能是-1,+1,0 ...
平衡二叉树 c/c++实现
左眼皮跳跳
03-27 2178
一直觉得平衡二叉树是非常麻烦的数据结构，关于树的旋转非常麻烦，最近特殊情况学了一下，参考了网上的代码，写这个让我对指针有了更加深入的了解，感觉收益匪浅，恶心的地方就是，当我程序无法运行出我的期望结果时，我debug就苦逼了，真的比较苦逼，一点小的注释在代码中，目前就自己出了几组样例测试了一下，感觉没什么大问题，比较低级，勿喷，如果发现代码中的bug,欢迎留言告知 #include #in
平衡二叉树c++实现
09-26
本文将详细介绍C++实现平衡二叉树——AVL树的过程。AVL树是最早被提出的自平衡二叉搜索树，由G. M. Adelson-Velsky和E. M. Landis于1962年提出，因此得名AVL。 1. AVL树的基本概念： - **节点平衡因子**：每个节点...
二叉树-基于C++实现的平衡二叉树.zip
最新发布
04-26
C++实现平衡二叉树时，我们需要定义一个二叉树节点结构体，包括节点值、颜色（对于红黑树）以及指向左子节点和右子节点的指针。接着，我们需要实现基本操作如插入、删除和查找，以及在这些操作后进行的平衡调整（如...
AVLTree 平衡二叉树c++实现
06-26
在C++中实现AVL树，通常会包含两个核心文件：头文件（.h）和源文件（.cpp）。头文件定义了AVL树的结构和相关的成员函数声明，而源文件则包含了这些函数的具体实现。 **CAVLTree.h头文件**中可能会包含以下内容： 1...
二叉树-基于C++实现的平衡二叉树的旋转.zip
04-26
本压缩包文件“二叉树_基于C++实现的平衡二叉树的旋转.zip”关注的是平衡二叉树的实现，特别是旋转操作，这在高效查找和维护平衡方面起着关键作用。 平衡二叉树（如AVL树和红黑树）是二叉搜索树的一个变种，它通过...
c++实现平衡二叉树
qq_52232093的博客
11-26 989
类的声明: #pragma once #include <iostream> using namespace std; template <class T> class AvlTree { template <class T> class Node { public: T data; int height; Node<T>* lChild; Node<T>* rChild; Node(T d = 0, int h.
二叉平衡树（C++）
wo_ai_luo_的博客
02-25 1083
平衡二叉树也叫做AVL树,AVL树的名字来源于它的发明作者G.M. Adelson-Velsky 和 E.M. Landis。AVL树是最先发明的自平衡二叉查找树(Self-Balancing Binary Search Tree,简称平衡二叉树。我们怎么知道这棵二叉搜索树平不平衡呢？我们知道，二叉搜索树的搜索时间和高度是有直接关系的，但是我们按递增、递减序输入之后，高度就和n一样了，所以时间复杂度为O(log n).想要优化，就是改变这棵二叉搜索树的高度。
数据结构（树，二叉搜索树，平衡二叉树 C++实现）
konglongdanfo的博客
07-22 1526
树 树（Tree）是n（n&gt;=0）个结点的有限集合。n = 0时称为空树。在任意一颗非空树中：(1)有且仅有一个特定的称为根（Root）的结点；（2）当n &gt; 1时，其余结点可分为m （m &gt; 0）个互不相交的有限集 T1T1T_1 、 T2T2T_2 、 …… 、 TmTmT_m ，其中每一个集合本身又是一个树，并且称为根的子树（SubTree），如下图所示： 树的结点...
查找->动态查找表->平衡二叉树
weixin_30845171的博客
08-26 519
文字描述 平衡二叉树(Balanced Binary Tree或Height-Balanced Tree) 　　因为是俄罗斯数学家G.M.Adel’son-Vel’skii和E.M.Landis在1962年提出来的，所以又称AVL树。它或者是一颗空树，或者是具有下列性质的二叉树：它的左子树和右子树都是平衡二叉树，且左子树和右子树的深度之差的绝对值不超过1。若将二叉树上结点的平衡因子BF(Bal...
数据结构与算法：C++实现 平衡二叉树
暮色年华的博客
06-02 458
保持平衡：调整树的形态，使BST性质不变又保证树的高度在任何情况下都是O(log2n)，确保树上的查找操作在最坏情况下是O(log2n)。RL：A结点的右孩子的左子树插入结点，使得A结点的平衡因子由-1变为-2引起的不平衡。RR：A结点的右孩子的右子树插入结点，使得A结点的平衡因子由-1变为-2引起的。LR：A结点的左孩子的右子树插入结点，使得A结点的平衡因子由1变为2引起的。LL：A结点的左孩子的左子树插入节点，使得A结点的平衡因子由1变为2引起的。(1)查找：在平衡二叉树中查找关键字为k的结点p。
平衡二叉树的c++实现
qq_41646522的博客
03-14 1087
插入节点： (为什么可以将其移动到另一方作为子树，考虑其左小于父节点以及右大于父节点的性质，即可理解可移动) 二叉树删除节点： 1.若删除节点为叶子节点==》直接删除 2.欲删除节点只有一个子树，删除该head,把子树移到head位置 3.欲删除节点有双子树，（右子树的最左节点为大于且最接近欲删除节点的值）找到该最接近节点node将其与欲删除节点交换，问题转换为{ 删除右子树中，值为node->key的节点（该节点为叶子节点或只有右子树的节点）<即转换为1，2情况> } AVLTree.
平衡二叉树-C++实现
m0_55464171的博客
05-23 1104
目录前言：为什么需要平衡二叉树？二叉搜索树的局限性什么是平衡二叉树？平衡二叉树的递归定义平衡二叉树的功能平衡性调整：向上调整，4种方式右单旋左单旋LR双旋RL双旋插入：1种情况删除：3种情况求树的高度：后序遍历实现判断是否为平衡二叉树输出平衡二叉树的信息：中序遍历实现判断两棵AVL树是否相等平衡二叉树的赋值：防止内存泄漏清空：后序遍历，释放所有结点完整代码 前言：为什么需要平衡二叉树？ 二叉搜索树的局限性 相对于链表，二叉搜索树的静态查找具有高效性。但是，如果我们希望一棵二叉树既能实现查找操作，又能实现插入
平衡二叉树实现动态查找表：C++代码与分析
"平衡二叉树C++/C是一个关于数据结构的实习报告，通过C++语言实现平衡二叉树来构建动态查找表，并且包含了查找、插入和删除这三个基本操作。报告中提供了详细的代码实现，包括旋转函数(R_Rotate 和 L_Rotate)以及...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值