算法笔记-第九章-平衡二叉树

最新推荐文章于 2024-06-16 22:47:03 发布
最新推荐文章于 2024-06-16 22:47:03 发布
阅读量200 收藏
点赞数
分类专栏： # 算法笔记刷题 文章标签： 算法 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yihoujian_2003/article/details/134506206
版权

算法笔记-第九章-平衡二叉树）

平衡二叉树

定义

  • 树还是一个二叉查找树
  • 其左右树的高度之差的绝对值不超过1
    左右高度之差称为该结点的平衡因子

大佬讲解

平衡二叉树的查找操作

本质上是和查找二叉树中的查找操作是一样的

void search(node* root, int x)
{
    if (root == NULL)
    {
        printf("search failed\n");
        return;  
    }
    if (x == root->data) {                
        printf("%d\n", root->data);                   
    }
    else if (x < root->data)//如果x笔根节点的数据域小，说明x在左子树                    
    {
        search(root->lchild, x);                    
    }
    else                    
    {
        search(root->data, x);                    
    }
}

插入操作

左旋操作

算法笔记-322页

在这里插入图片描述
在这里插入图片描述

void L(node* root)     
{
    node* temp = root->rchild;     
    root->rchild = temp->lchild;     
    temp->rchild = root;     

    //更新结点A的高度     
    updateHeight(root);     
    updateHeight(temp);     
    root = temp;     
}

插入情况

在这里插入图片描述

AVL数的插入代码是在二叉查找树的插入代码上增加平衡操作的

插入操作代码

不考虑平衡操作


void insert(node*& root, itn v)
{
    if (root == NULL)
    {
        root = newnode(v);  
        return;  
    }
    if (v < root->v)  
    {
        insert(root->lchild, v);//向左子树插入    
    }
    else     
    {
        insert(root->rchild, v);//向右子树插入     
    }
}

平衡插入操作

在这个基础上，由于需要从插入的节点开始从下往上判断结点是否失衡，因此需要在每一个insert函数之后更新当前子树的高度，并且在这之后判断树型是LL,LR,RR,RL型之一
插入权值为v的结点

void insert(node* root, int v)
{
    if (root == NULL)
    {
        root = newnode(v);
        return;
    }
    if (v < root->v)//v笔根节点的权值小
    {
        i = insert(root->lchild, v);//向左子树插入
        updateHeight(root);
        //更新树的高度

        if (getBalancefactor(root) == 2)
        {
            if (getBalancefactor(root->lchild) == 1) {//LL型
                R(root);
            }
            else if (fteBalancefactor(root->lchild == -1))
            {
                //LR型
                L(root->lchild);
                R(root);
            }
        }

    }
    else {
        insert(root->rchild, v);//向右子树插入
        updateHeight(root);//更新树高度
        if (getBalancefactor(root) == 2)
        {
            if (gteBalancefactor(root->rchild) == -2) {
                if (getBalancefactor(root->rchild) == -1) {
                    //RR型  
                    L(root);  
                }
                else if (getBalancefactor(root->rchild) == -1)//RL型  
                {
                    R(root->rchild);  
                    L(root);  
                }
            }
        }
    }
   
}

二叉查找树的平衡因子

在这里插入图片描述

在这里插入图片描述

#include <cstdio>
#include <vector>
#include <algorithm>
using namespace std;

const int MAXN = 50;

struct Node {
    int data;
    int height;
    int l, r;
} nodes[MAXN];

int nodeCount = 0;

int newNode(int data) {
    nodes[nodeCount].data = data;
    nodes[nodeCount].height = 1;
    nodes[nodeCount].l = nodes[nodeCount].r = -1;
    return nodeCount++;
}

int getHeight(int root) {
    if (root == -1) {
        return 0;
    } else {
        return nodes[root].height;
    }
}

void updateHeight(int root) {
    nodes[root].height = max(getHeight(nodes[root].l), getHeight(nodes[root].r)) + 1;
}

int getBalanceFactor(int root) {
    return getHeight(nodes[root].l) - getHeight(nodes[root].r);
}

int insert(int root, int data) {
    if (root == -1) {
        return newNode(data);
    }
    if (data < nodes[root].data) {
        nodes[root].l = insert(nodes[root].l, data);
    } else {
        nodes[root].r = insert(nodes[root].r, data);
    }
    updateHeight(root);
    return root;
}

vector<int> balanceFactor;

void inOrder(int root) {
    if (root == -1) {
        return;
    }
    inOrder(nodes[root].l);
    balanceFactor.push_back(getBalanceFactor(root));
    inOrder(nodes[root].r);
}

int main() { 
    int n, data, root = -1;  
    scanf("%d", &n);  
    for (int i = 0; i < n; i++) {  
        scanf("%d", &data);  
        root = insert(root, data);  
    }
    inOrder(root);  
    for (int i = 0; i < (int)balanceFactor.size(); i++) {  
        printf("%d", balanceFactor[i]);  
        if (i < (int)balanceFactor.size() - 1) {  
            printf(" ");  
        }
    }
    return 0;  
}

平衡二叉树的判定

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

#include <cstdio>
#include <vector>
#include <algorithm>
using namespace std;

const int MAXN = 50;

struct Node {
    int data;
    int height;
    int l, r;
} nodes[MAXN];

int nodeCount = 0;

int newNode(int data) {
    nodes[nodeCount].data = data;
    nodes[nodeCount].height = 1;
    nodes[nodeCount].l = nodes[nodeCount].r = -1;
    return nodeCount++;
}

int getHeight(int root) {
    if (root == -1) {
        return 0;
    } else {
        return nodes[root].height;
    }
}

void updateHeight(int root) {
    nodes[root].height = max(getHeight(nodes[root].l), getHeight(nodes[root].r)) + 1;
}

int getBalanceFactor(int root) {
    return getHeight(nodes[root].l) - getHeight(nodes[root].r);
}

int insert(int root, int data) {
    if (root == -1) {
        return newNode(data);
    }
    if (data < nodes[root].data) {
        nodes[root].l = insert(nodes[root].l, data);
    } else {
        nodes[root].r = insert(nodes[root].r, data);
    }
    updateHeight(root);
    return root;
}

bool isAVL(int root) {
    if (root == -1) {
        return true;
    }
    return isAVL(nodes[root].l) && isAVL(nodes[root].r) && abs(getBalanceFactor(root)) <= 1;

}

int main() {  
    int n, data, root = -1;  
    scanf("%d", &n);  
    for (int i = 0; i < n; i++) {  
        scanf("%d", &data);  
        root = insert(root, data);  
    }
    printf(isAVL(root) ? "Yes" : "No");  
    return 0;  
}

平衡二叉树的建立

在这里插入图片描述

在这里插入图片描述

#include <cstdio>
#include <vector>
#include <algorithm>
using namespace std;

const int MAXN = 50;

struct Node {
    int data;
    int height;
    int l, r;
} nodes[MAXN];

int nodeCount = 0;

int newNode(int data) {
    nodes[nodeCount].data = data;
    nodes[nodeCount].height = 1;
    nodes[nodeCount].l = nodes[nodeCount].r = -1;
    return nodeCount++;
}

int getHeight(int root) {
    if (root == -1) {
        return 0;
    } else {
        return nodes[root].height;
    }
}

void updateHeight(int root) {
    nodes[root].height = max(getHeight(nodes[root].l), getHeight(nodes[root].r)) + 1;
}

int getBalanceFactor(int root) {
    return getHeight(nodes[root].l) - getHeight(nodes[root].r);
}

int L(int root) {
    int temp = nodes[root].r;
    nodes[root].r = nodes[temp].l;
    nodes[temp].l = root;
    updateHeight(root);
    updateHeight(temp);
    return temp;
}

int R(int root) {
    int temp = nodes[root].l;
    nodes[root].l = nodes[temp].r;
    nodes[temp].r = root;
    updateHeight(root);
    updateHeight(temp);
    return temp;
}

int insert(int root, int data) {
    if (root == -1) {
        return newNode(data);
    }
    if (data < nodes[root].data) {
        nodes[root].l = insert(nodes[root].l, data);
        updateHeight(root);
        if (getBalanceFactor(root) == 2) {
            if (getBalanceFactor(nodes[root].l) == 1) {
                root = R(root);
            } else if (getBalanceFactor(nodes[root].l) == -1) {
                nodes[root].l = L(nodes[root].l);
                root = R(root);
            }
        }
    } else {
        nodes[root].r = insert(nodes[root].r, data);
        updateHeight(root);
        if (getBalanceFactor(root) == -2) {
            if (getBalanceFactor(nodes[root].r) == -1) {
                root = L(root);
            } else if (getBalanceFactor(nodes[root].r) == 1) {
                nodes[root].r = R(nodes[root].r);
                root = L(root);
            }
        }
    }
    return root;
}

vector<int> pre;

void preOrder(int root) {
    if (root == -1) {
        return;
    }
    pre.push_back(nodes[root].data);
    preOrder(nodes[root].l);
    preOrder(nodes[root].r);
}

int main() {
    int n, data, root = -1;
    scanf("%d", &n);
    for (int i = 0; i < n; i++) {
        scanf("%d", &data);
        root = insert(root, data);
    }
    preOrder(root);
    for (int i = 0; i < (int)pre.size(); i++) {
        printf("%d", pre[i]);
        if (i < (int)pre.size() - 1) {
            printf(" ");
        }
    }
    return 0;
}
一直爱莲子
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
【算法笔记第9.5节-平衡二叉树 】问题 A: 算法9-9~9-12：平衡二叉树的基本操作
xunalove的博客
03-16 414
题目描述 平衡二叉树又称AVL树，它是一种具有平衡因子的特殊二叉排序树。平衡二叉树或者是一棵空树，或者是具有以下几条性质的二叉树： 1. 若它的左子树不空，则左子树上所有结点的值均小于它的根节点的值； 2. 若它的右子树不空，则右子树上所有结点的值均大于它的根节点的值； 3. 它的左右子树也分别为平衡二叉树，且左子树和右子树的深度之差的绝对值不超过1。 ...
二维矩形装箱算法--二叉树--java实现
03-22
多个车子，N个箱子，用二维矩形方式进行装车。采用二叉树实现。java
866数据结构笔记 - 第五章 树和二叉树
qq_45331246的博客
10-20 2165
866数据结构、湖南大学考研、树和二叉树
算法笔记-问题 A: 算法9-9~9-12：平衡二叉树的基本操作
qq_41966660的博客
01-23 152
问题 A: 算法9-9~9-12：平衡二叉树的基本操作 题目描述 平衡二叉树又称AVL树，它是一种具有平衡因子的特殊二叉排序树。平衡二叉树或者是一棵空树，或者是具有以下几条性质的二叉树： 1.若它的左子树不空，则左子树上所有结点的值均小于它的根节点的值； 2.若它的右子树不空，则右子树上所有结点的值均大于它的根节点的值； 3.它的左右子树也分别为平衡二叉树，且左子树和右子树的深度之差的绝对值不超过1。 若将二叉树上结点的平衡因子定义为该结点的左子...
算法笔记-6：平衡二叉树（理论篇）
weixin_47806733的博客
02-19 733
        上期我们说到，如果按从小到大的顺序向二叉搜索树插入节点，那么搜索树会退化成链表，这样就背离我们利用二叉搜索树的特性方便查询元素的初衷了。     &nbs...
算法笔记-第七章-数据结构至第九章-树
Qi_Li的博客
08-09 523
7.1 栈的应用 使用c++的stl容器中的stack, 注意：c++中的栈没有实现栈的清空操作，因此可以使用while循环反复pop()出元素直至栈空 #include <stack> using namespace std; while(!st.empty()) { st.pop(); } stack容器中各种常用函数： 1.top(): st.top() 2.push()...
算法笔记.胡凡 第九章 二叉树
weixin_45406155的博客
08-13 291
9.1 树与二叉树 二叉树的存储 struct node { typename data; node* lchild; node* rchild; }; 新建节点 node* newNode(int v) { node* Node = new node; Node->data = v; Node->lchild = Node->rchild = NULL; return Node; } 二叉树的查找 void sea
每日算法-平衡二叉树
偏偏爱吃梨的博客
02-26 194
题目 给定一个二叉树，判断它是否是高度平衡的二叉树。 本题中，一棵高度平衡二叉树定义为：一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1 。 示例 1： 输入：root = [3,9,20,null,null,15,7] 输出：true 示例 2： 输入：root = [1,2,2,3,3,null,null,4,4] 输出：false 示例 3： 输入：root = [] 输出：true 提示： 树中的节点数在范围 [0, 5000] 内 -104 <= Node.val
王道数据结构笔记02-平衡二叉树/平衡树/AVL树
testleaf.cn
08-31 2134
平衡二叉树（BalancedBinaryTree），简称平衡树（AVL树），树上任一结点的左子树和右子树的高度之差不超过1。简称AVL命名来源于其发明者G.M.Adelson-Velsky和E.M.Landis，不要和平均查找长度ASL混淆了。结点的平衡因子=左子树高-右子树高。平衡二叉树结点的平衡因子的值只可能是-1、0或1。只要有任一结点的平衡因子绝对值大于1，就不是平衡二叉树。intkey;//数据域intbalance;.......................................
平衡二叉树（AVL树）学习笔记-C语言，附手绘过程
NanamiKento的博客
09-15 453
真的很详细，很通俗易懂…… 至少作者这么觉得。
二维矩形装箱算法--二叉树--java实现.rar
06-07
二维矩形装箱算法--二叉树--java实现.rar
Java数据结构与算法-笔记-代码-课件-资料
05-17
稀疏数组、单向队列、环形队列、单向链表、双向链表、环形链表、约瑟夫问题、栈、前缀、中缀、后缀表达式、中缀表达式转换为后缀表达式、递归与回溯、迷宫问题、八皇后问题、算法的时间复杂度、冒泡排序、选择排序、...
Objective-C实现二叉树遍历算法（源代码）
04-30
本文展示了如何在Objective-C中实现一个简单的二叉树算法。首先，定义了一个二叉树节点的类BinaryTreeNode，用于存储数据和指向左右子节点的指针。接着，定义了一个二叉树类BinaryTree，该类包含一个根节点指针，并...
二叉树-基于C++实现的平衡二叉树.zip
04-26
二叉树 二叉树_基于C++实现的平衡二叉树
力扣LCP 08.剧情触发时间
Pisasama的博客
06-12 455
【代码】力扣LCP 08.剧情触发时间。
算法训练营day60
最新发布
stmfresher的博客
06-16 224
【代码】算法训练营day60。
算法体系-20 第二十节暴力递归到动态规划
m0_61164038的博客
06-12 345
四种模型和体系班两种模型一共六种模型0.1 从左往右模型0.2 范围讨论模型范围尝试模型 （这种模型特别在乎讨论开头如何如何 结尾如何如何）玩家博弈问题，玩家玩纸牌只能那左或者右0.3 样本对应样本对应模型（特别在乎两个样本结尾如何如何 最长公共子序列）0.4 业务限制模型动态规划只是暴力尝试的一个缓存。
算法体系-19 第十九节 暴力递归到动态规划
m0_61164038的博客
06-11 308
一旦写出递归来，改动态规划就很快尝试策略和状态转移方程是一码事学会尝试是攻克动态规划最本质的能力如果你发现你有重复调用的过程，动态规划在算过一次之后把答案记下来，下回在越到重复调用过程就直接调做题思路 一定要从尝试入手动态规划的套路从尝试出发,从尝试递归出发，然后在改动态规划的时候第一步找到base的情况填上相应位置的数，然后根据下一步的条件推出其他位置的数；
算法9-9~9-12：平衡二叉树的基本操作
06-28
回答1：</h3><br/>算法9-9~9-12是关于平衡二叉树的基本操作，包括插入、删除、旋转等操作。平衡二叉树是一种特殊的二叉搜索树，它的左右子树高度差不超过1，可以保证树的高度始终在log(n)级别，从而保证了树的查找、...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

一直爱莲子

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值