AVL树/线索二叉树

最新推荐文章于 2024-09-09 14:59:20 发布
最新推荐文章于 2024-09-09 14:59:20 发布
阅读量133 收藏
点赞数
文章标签： c/c++ 数据结构与算法
原文链接：http://www.cnblogs.com/heihuifei/p/8215293.html
版权
此文转载：

http://www.cnblogs.com/skywang12345/p/3577360.html

AVL树是一棵特殊的高度平衡的二叉树，每个节点的两棵子树高度最大差为1。所以在每次的删除或者是插入的过程之后都要判断此时是否是一颗AVL树，AVL树不平衡的调整最关键，大概分为四种不同的不平衡的状态。处理四种不平衡状态四个调整函数（LL,RR,LR,Rl）即可；

1093650-20180106194353784-1636977044.png

1093650-20180106194424737-814960599.png

(1) LL：LeftLeft，也称为"左左"。插入或删除一个节点后，根节点的左子树的左子树还有非空子节点，导致"根的左子树的高度"比"根的右子树的高度"大2，导致AVL树失去了平衡。

例如，在上面LL情况中，由于"根节点(8)的左子树(4)的左子树(2)还有非空子节点"，而"根节点(8)的右子树(12)没有子节点"；导致"根节点(8)的左子树(4)高度"比"根节点(8)的右子树(12)"高2。

(2) LR：LeftRight，也称为"左右"。插入或删除一个节点后，根节点的左子树的右子树还有非空子节点，导致"根的左子树的高度"比"根的右子树的高度"大2，导致AVL树失去了平衡。

例如，在上面LR情况中，由于"根节点(8)的左子树(4)的左子树(6)还有非空子节点"，而"根节点(8)的右子树(12)没有子节点"；导致"根节点(8)的左子树(4)高度"比"根节点(8)的右子树(12)"高2。

(3) RL：RightLeft，称为"右左"。插入或删除一个节点后，根节点的右子树的左子树还有非空子节点，导致"根的右子树的高度"比"根的左子树的高度"大2，导致AVL树失去了平衡。

例如，在上面RL情况中，由于"根节点(8)的右子树(12)的左子树(10)还有非空子节点"，而"根节点(8)的左子树(4)没有子节点"；导致"根节点(8)的右子树(12)高度"比"根节点(8)的左子树(4)"高2。

(4) RR：RightRight，称为"右右"。插入或删除一个节点后，根节点的右子树的右子树还有非空子节点，导致"根的右子树的高度"比"根的左子树的高度"大2，导致AVL树失去了平衡。

例如，在上面RR情况中，由于"根节点(8)的右子树(12)的右子树(14)还有非空子节点"，而"根节点(8)的左子树(4)没有子节点"；导致"根节点(8)的右子树(12)高度"比"根节点(8)的左子树(4)"高2。

LL旋转：
1093650-20180106195152893-1840420338.png

RR旋转：
1093650-20180106195241659-1595251201.png

LR旋转：
1093650-20180106195341440-1111363841.png

RL旋转：
1093650-20180106195417628-1288784435.png

因为博客园中我还不知道如何转载原文，所以只能以这种方式；

第八次作业：

下面是我自己根据原文代码做题写的C语言的代码（没有全A，不知为何）

2、题目链接（多次删除操作多次寻找树中的最大最小值）：

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<algorithm>
#include<malloc.h>
using namespace std;
int n;
int nodes[100005];
int dep[100005];
int depth = 0;
typedef struct AVL_Node
{
    int data;
    int height;
    AVL_Node* left;
    AVL_Node* right;
}Node, *AVLTree;

int MAX(int a, int b)
{
    return a < b ? b : a;
}

int Height(AVLTree tree)                        //返回该节点树的高度；
{
    return tree == NULL ? 0 : tree->height;
}

Node* create_node(int data, Node* left, Node* right)
{
    Node* p;
    if ((p = (Node*)malloc(sizeof(Node))) == NULL)
        return NULL;
    p->data = data;
    p->height = 0;
    p->left = left;
    p->right = right;
    return p;
}

Node* L_L(AVLTree tree)
{
    AVLTree tmp;
    tmp = tree->left;
    tree->left = tmp->right;
    tmp->right = tree;
    tree->height = MAX(Height(tree->left), Height(tree->right)) + 1;
    tmp->height = MAX(Height(tmp->left), tree->height) + 1;
    return tmp;
}

Node* R_R(AVLTree tree)
{
    AVLTree tmp;
    tmp = tree->right;
    tree->right = tmp->left;
    tmp->left = tree;
    tree->height = MAX(Height(tree->left), Height(tree->right)) + 1;
    tmp->height = MAX(Height(tmp->right), tree->height) + 1;
    return tmp;
}

Node* L_R(AVLTree tree)
{
    tree->left = R_R(tree->left);
    return L_L(tree);
}

Node* R_L(AVLTree tree)
{
    tree->right = L_L(tree->right);
    return R_R(tree);
}
Node* maximum(Node* tree)
{
    if (tree == NULL)return NULL;
    while(tree->right!=NULL)
    {
        tree = tree->right;
    }
    return tree;
}
Node* minimun(Node* tree)
{
    if (tree == NULL)return NULL;
    while(tree->left!=NULL)
    {
        tree = tree->left;
    }
    return tree;
}

Node* insert(AVLTree tree, int data)
{
    if (tree == NULL)
    {
        tree = create_node(data, NULL, NULL);
        if (tree == NULL)
            return NULL;
    }
    else if (data < tree->data)         //根据AVL树的性质应该插入到左子树中
    {
        tree->left = insert(tree->left, data);
        if (Height(tree->left) - Height(tree->right) == 2)      //插入后树如果不平衡，则应进行调节；
        {
            if (data < tree->left->data)
                tree = L_L(tree);
            else
                tree = L_R(tree);
        }
    }
    else if (data > tree->data)
    {
        tree->right = insert(tree->right, data);
        if (Height(tree->right) - Height(tree->left) == 2)
        {
            if (data < tree->right->data)
                tree = R_L(tree);
            else
                tree = R_R(tree);
        }
    }
    tree->height = MAX(Height(tree->left), Height(tree->right)) + 1;
    return tree;
}

Node* Delete(AVLTree tree,Node* dele)
{
    if (tree == NULL || dele == NULL)return NULL;       //根为空或者没有要删除的节点，直接返回NULL;
    if (dele->data < tree->data)                        //删除节点在左子树中；
    {
        tree->left = Delete(tree->left, dele);
        if (Height(tree->right) - Height(tree->left) == 2)//失去平衡之后要重新调整；
        {
            Node* tmp = tree->right;
            if (Height(tmp->left) > Height(tmp->right))
                tree = R_L(tree);
            else
                tree = R_R(tree);
        }
    }
    else if (dele->data > tree->data)                   //删除节点在右子树中；
    {
        tree->right = Delete(tree->right, dele);
        if (Height(tree->left) - Height(tree->right) == 2)//失去平衡之后要重新调整；
        {
            Node* tmp = tree->left;
            if (Height(tmp->right) > Height(tmp->left))
                tree = L_R(tree);
            else
                tree = L_L(tree);
        }
    }
    else
    {
        if ((tree->left != NULL) && (tree->right != NULL))
        {
            if (Height(tree->left) > Height(tree->right))
            {
                // 如果tree的左子树比右子树高；
                // 则(01)找出tree的左子树中的最大节点
                //   (02)将该最大节点的值赋值给tree。
                //   (03)删除该最大节点。
                // 这类似于用"tree的左子树中最大节点"做"tree"的替身；
                // 采用这种方式的好处是：删除"tree的左子树中最大节点"之后，AVL树仍然是平衡的。
                Node* max = maximum(tree->left);
                tree->data = max->data;
                tree->left = Delete(tree->left, max);
            }
            else
            {
                // 如果tree的左子树不比右子树高(即它们相等，或右子树比左子树高1)
                // 则(01)找出tree的右子树中的最小节点
                //   (02)将该最小节点的值赋值给tree。
                //   (03)删除该最小节点。
                // 这类似于用"tree的右子树中最小节点"做"tree"的替身；
                // 采用这种方式的好处是：删除"tree的右子树中最小节点"之后，AVL树仍然是平衡的。
                Node* min = minimun(tree->right);
                tree->data = min->data;
                tree->right = Delete(tree->right, min);
            }
        }
        else
        {
            Node* tmp = tree;
            tree = (tree->left != NULL) ? tree->left : tree->right;
            free(tmp);
        }
    }
    return tree;
}

Node* mininode(AVLTree tree,AVLTree tmproot)            //寻找最小键值的节点；
{
    int depth = 1;
    if (tree == NULL)return NULL;
    while (tree->left != NULL)
    {
        tree = tree->left; depth++;
    }
    cout << tree->data << " " << depth << endl;
    return Delete(tmproot, tree);
}

Node* maxnode(AVLTree tree,AVLTree tmproot)             //寻找最大键值的节点；
{
    int depth = 1;
    if (tree == NULL)return NULL;
    while (tree->right != NULL)
    {
        tree = tree->right; depth++;
    }
    cout << tree->data << " " << depth << endl;
    return Delete(tmproot, tree);
}

int main()
{
    int i, tmp1, tmp2;
    AVLTree root = NULL;
    cin >> n;
    for (i = 1; i <= n; i++)
    {
        cin >> nodes[i];
        root = insert(root, nodes[i]);
    }
    int m, j = 0;
    cin >> m;
    for (i = 1; i <= m; i++)
    {
        cin >> tmp1;
        if (tmp1 == 1)
        {
            if (j >= n) { cout << "-1\n"; continue; }
            root = maxnode(root, root); j++;
        }
        else if (tmp1 == 2)
        {
            if (j >= n) { cout << "-1\n"; continue; }
            root = mininode(root, root); j++;
        }
        else if (tmp1 == 3)
        {
            cin >> tmp2;
            insert(root, tmp2);
            j--;
        }
    }
    return 0;
}

1、题目链接(找出每个节点的深度即层次)
代码：

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<algorithm>
#include<malloc.h>
using namespace std;
int n;
int nodes[100005];
int dep[100005];
int depth = 0;
typedef struct AVL_Node
{
    int data;
    int height;
    AVL_Node* left;
    AVL_Node* right;
}Node, *AVLTree;

int MAX(int a, int b)
{
    return a < b ? b : a;
}

int Height(AVLTree tree)
{
    return tree == NULL ? 0 : tree->height;
}

Node* create_node(int data, Node* left, Node* right)
{
    Node* p;
    if ((p = (Node*)malloc(sizeof(Node))) == NULL)
        return NULL;
    p->data = data;
    p->height = 0;
    p->left = left;
    p->right = right;
    return p;
}

Node* L_L(AVLTree tree)
{
    AVLTree tmp;
    tmp = tree->left;
    tree->left = tmp->right;
    tmp->right = tree;
    tree->height = MAX(Height(tree->left), Height(tree->right)) + 1;
    tmp->height = MAX(Height(tmp->left), tree->height) + 1;
    return tmp;
}

Node* R_R(AVLTree tree)
{
    AVLTree tmp;
    tmp = tree->right;
    tree->right = tmp->left;
    tmp->left = tree;
    tree->height = MAX(Height(tree->left), Height(tree->right)) + 1;
    tmp->height = MAX(Height(tmp->right), tree->height) + 1;
    return tmp;
}

Node* L_R(AVLTree tree)
{
    /*AVLTree tmp1, tmp2;
    tmp2 = tree->left;
    tmp1 = tmp2->right;
    tmp2->right = tmp1->left;
    tmp1->left = tmp2;
    tree->left = tmp1;*/
    tree->left = R_R(tree->left);
    return L_L(tree);
}

Node* R_L(AVLTree tree)
{
    tree->right = L_L(tree->right);
    return R_R(tree);
}

Node* insert(AVLTree tree, int data)
{
    if (tree == NULL)
    {
        tree = create_node(data, NULL, NULL);
        if (tree == NULL)
            return NULL;
    }
    else if (data < tree->data)         //根据AVL树的性质应该插入到左子树中
    {
        tree->left = insert(tree->left, data);
        if (Height(tree->left) - Height(tree->right) == 2)
        {
            if (data < tree->left->data)
                tree = L_L(tree);
            else
                tree = L_R(tree);
        }
    }
    else if (data > tree->data)
    {
        tree->right = insert(tree->right, data);
        if (Height(tree->right) - Height(tree->left) == 2)
        {
            if (data < tree->right->data)
                tree = R_L(tree);
            else
                tree = R_R(tree);
        }
    }
    tree->height = MAX(Height(tree->left), Height(tree->right)) + 1;
    return tree;
}

void mid_Tree(AVLTree tree)     //中序遍历树，即从小到大遍历
{
    if (tree != NULL)
    {
        depth++;                //每向下走一步就加一
        mid_Tree(tree->left);
        dep[tree->data] = depth;
        mid_Tree(tree->right);
        depth--;                //往上回走一步减一（回溯过程）
    }
}
int main()
{
    int i, tmp;
    AVLTree root = NULL;
    cin >> n;
    for (i = 1; i <= n; i++)
    {
        cin >> nodes[i];
        root = insert(root, nodes[i]);
    }
    mid_Tree(root);
    for (i = 1; i <= n; i++)
        printf("%d%c", dep[nodes[i]], i != n ? ' ' : '\n');
    return 0;
}

其次我认为最主要是给定一个数列之后，会将其AVL树画出来；
具体可以参见博客：http://www.cnblogs.com/skywang12345/p/3577360.html

转载于:https://www.cnblogs.com/heihuifei/p/8215293.html

weixin_30820151
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
线索二叉树，搜索二叉树，AVL二叉树，满二叉树，完全二叉树，平衡二叉树，最优二叉树
ZJQ的博客
10-15 678
二叉树的遍历本质上是将一个复杂的非线性结构转换为线性结构，使每个结点都有了唯一前驱和后继（第一个结点无前驱，最后一个结点无后继）。对于二叉树的一个结点，查找其左右子女是方便的，其前驱后继只有在遍历中得到。为了容易找到前驱和后继，有两种方法。一是在结点结构中增加向前和向后的指针fwd和bkd，这种方法增加了存储开销，不可取；二是利用二叉树的空链指针。 二叉查找树（又：二叉搜索树，二叉排...
树——（1）综述：二叉树，线索二叉树，二叉搜索树，B-/B+树，AVL树，红黑树
矩阵实验室
06-27 3680
tree 1. 定义 树是n(n>=0)个结点的有限集。在任意一棵非空树中：     (1)有且仅有一个特定的称为根的结点；    (2)当n>1时,其余结点可分为m(m>0)个互不相交的有限集T1,T2,...Tm,其中每一个集合本身又是一棵树,并且称为根的子树. 2. 树的基本概念： 度：结点拥有的子树数称为结点的度。 叶子（终端结点）：度为0的结点称为叶子或终端结点。 分
数据结构—线索二叉树
qq_34784354的博客
03-07 138
建议将思维导图保存下来观看，或点击这里在幕布上在线观看
平衡二叉树（AVL树）
ALin_Think的博客
03-27 216
平衡二叉树（AVL树） 基本介绍 1、平衡二叉树也叫平衡二叉搜索树（Self-balancing binary search tree）又被称为AVL树， 可以保证查询效率较高。 2、它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。 为什么需要AVL树 问题 给定一个数列{1,2,3,4,5,6}，要求创建一颗二叉排序树(BST) 分析： 1、左子树全...
【数据结构】：二叉树，线索二叉树，排序二叉树，AVL树
呋喃吖的博客
06-15 1236
文章目录前言一 二叉树0）二叉树较为重要的种类1. 满二叉树2.完全二叉树1） 二叉树的存储结构2） 初始化二叉树3）创建二叉树1.创建二叉树的方式 12.创建二叉树 23.创建二叉树 34）遍历二叉树1.前序递归遍历2.中序递归遍历3.后序递归遍历4.层次遍历5）前序非递归遍历 前言 二叉树分好多种: 我在这里分享四种二叉树的基本操作集合。 普通的二叉树(二叉树) 线索二叉树 搜索二叉树 平衡（AVL）二叉树 一 二叉树 0）二叉树较为重要的种类 满二叉树和完全二叉树。 1. 满二叉树 一棵二叉树，除
AVL树(三)之 Java的实现
WO的专栏
03-30 982
概要 前面分别介绍了AVL树"C语言版本"和"C++版本"，本章介绍AVL树的Java实现版本，它的算法与C语言和C++版本一样。内容包括： 1. AVL树的介绍 2. AVL树的Java实现 3. AVL树的Java测试程序 转载请注明出处：http://www.cnblogs.com/skywang12345/p/3577479.html   更多内容: 数据结构与算法系列 目录
AVL.rar_二叉树 线索化_线索二叉树
09-24
中序线索化的二叉树 能够对二叉树先线索化然后再中序排列 并且输出
二叉排序树/平衡二叉树/哈夫曼树
chengxuyuanlee的博客
12-10 2195
本人将树相关知识总结为初、中、高三篇，本文属于树结构的中篇，主要阐述几种经典的树形结构，是继承树的基础知识之后，进行相关拓展那么本文将以三种典型的树形结构进行总结，从查找的角度来进行分析各个树型结构的区别与优势。 基础篇在：数据结构——树基础 （主要总结树、二叉树、线索二叉树、森林等基础相关知识） 二叉排序树 树表相关概念 二叉排序树定义 查找操作 插入操作 删除操作 查找效率分析 平衡二叉树 相关概念 平衡二叉树定义 平衡二叉树调整方法 创建、插入、删除 查找效率分析 ...
数据结构之——排序二叉树、平衡二叉树和线索二叉树
xiaoyong5854的博客
05-29 2014
1.排序二叉树 排序二叉树(BST)也称二叉查找树,排序二叉树或者是一棵空树,或者是一棵具有下列特性的非空二叉树: (1)若左子树非空,则左子树上所有结点关键字值小于根节点的关键字值. (2)若右子树非空,则右子树上所有结点关键字值大于根节点的关键字值. (3)左、右子树本身分别是一棵排序二叉树。 根据排序二叉树的定义，左子树结点值<根节点值<右子树结点值，对排序二叉树进行中序遍历，可以得到一个递增的序列。 （1）查找操作代码如下： //search函数查找二叉查找树中数据域为x的结点 void
数据结构之AVL树
菜鸟清风http://www.hphblog.cn/
05-22 171
AVL树相关学习与实现： 简介AVL树是最早被发明的自平衡二叉查找树。在AVL树中，任一节点对应的两棵子树的最大高度差为1，因此它也被称为高度平衡树。查找、插入和删除在平均和最坏情况下的时间复杂度(都是$O(\log n)$。增加和删除元素的操作则可能需要借由一次或多次树旋转，以实现树的重新平衡。AVL树得名于它的发明者G. M. Ad...
51nod-1412 AVL树的种类
L.
08-04 1023
原题链接 1412 AVL树的种类 基准时间限制：1 秒 空间限制：131072 KB 分值: 40 难度：4级算法题  收藏  关注 平衡二叉树(AVL树），是指左右子树高度差至多为1的二叉树，并且该树的左右两个子树也均为AVL树。 现在问题来了，给定AVL树的节点个数n，求有多少种形态的AVL树恰好有n个节点。
AVL树
weixin_33935505的博客
05-17 70
AVL树的介绍 　　AVL树是最先发明的自平衡二叉查找树。在AVL树中任何节点的两个子树的高度最大差别为一，所以它也被称为高度平衡树。查找、插入和删除在平均和最坏情况下都是O（log n）。增加和删除可能需要通过一次或多次树旋转来重新平衡这个树。节点的平衡因子是它的左子树的高度减去它的右子树的高度（有时相反）。带有平衡因子1、0或 -1的节点被认为是平衡的。带有平衡因子 -2或2的节点被认为是不...
【C++】STL—vector的使用
2301_77112794的博客
09-04 717
本文介绍了vector重点函数接口的使用
QWidget(c++)嵌入window环境的exe
sunflower_2020的博客
09-05 296
QWidget(c++)嵌入window环境的exe
C语言初阶 --- ⾃定义类型：结构体
2301_79842589的博客
09-08 937
💫往期文章👇：
[ C++ ] 一文复习（基础语法，语言特性，STL回顾）
2301_79175236的博客
09-04 1083
C++复习参考文，待完善
C语言学习笔记 Day16（C10文件管理--下）
给bug两拳的博客
09-04 1288
1、查询文件状态；2、文件的随机读写：fseek()、rewind()；3、文件的删除和重命名：remove()、rename()；4、文件缓冲区：基础概念、更新缓冲区
C/C++ 趣味代码目录
最新发布
m0_53061304的博客
09-09 178
0-100行练手 C++实现线性拟合 C++控制台井字棋 C++实现在控制台输出红色爱心 C语言实现三角定位 C++彩色星空 C++实现二叉树 C++ 纳秒级计时器 C++代码：简单的神经元实现 C 语言实现一个循环队列 C++代码：弹力小球 C++代码：矩阵的加减乘运算 C++中的数制转换工具 使用C++实现表达式求值器 C++实现雪花飘落效果 可视化冒泡排序 C++实现简单的内存池 100-300行 C++贪吃蛇 C++ 小球打砖块 C++ 实现K-means算法
线索二叉树解析：树与二叉树的概念与遍历
"二叉树相关的PPT课件，涵盖了二叉树的结构、线索二叉树的概念以及树的相关术语和概念" 二叉树是一种特殊类型的树，其中每个节点最多有两个子节点，分别称为左子节点和右子节点。在二叉树中，节点通常包含数据元素...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值