【数据结构】平衡二叉树（插入、查找、删除）解析+完整代码

于 2024-05-14 14:15:01 发布
阅读量1.2k 收藏 16
点赞数 14
分类专栏： 数据结构 文章标签： 数据结构 c语言 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_61628700/article/details/138853247
版权

3.2 平衡二叉树

3.2.1 定义

  • 平衡二叉树，简称平衡树（AVL树）

    树上任一结点的左右子树高度差不超过1。

    结点的平衡因子=左子树高-右子树高

3.2.2 插入操作

  • 插入结点后，可能造成不平衡

    要调整最小不平衡子树，使其恢复平衡。

    调整最小不平衡树A的方法：

    1.LL：在A的左孩子的左子树中插入导致不平衡；

    2.RR：在A的右孩子的右子树中插入导致不平衡；

    3.LR：在A的左孩子的右子树中插入导致不平衡；

    4.RL：在A的右孩子的左子树中插入导致不平衡。

在这里插入图片描述

A.调整最小不平衡子树 LL

  • LL插入后：

    由于在结点A的左孩子（L）的左子树（L）上插入新结点，A的平衡因子由1增至2，导致以A为根的子树失去平衡，需要一次向右的旋转操作。

  • 平衡旋转的目标：

    1.恢复平衡；

    2.保持二叉排序树特性：

    ​ 左子树结点值<根结点值<右子树结点值

    ​ BL<B<HR<A<AR

  • LL平衡旋转（右单旋转）：

    1.将A的左孩子B向右上旋转代替A成为根结点；

    2.将A结点向右下旋转成为B的右子树的根结点；

    3.而B的原右子树作为A结点的左子树。

    在这里插入图片描述

  • 右旋代码思路

    实现f向右下旋转，p向右上旋转：

    其中，gf是f他爹。

    1.f->lchild=p->rchild;

    2.p->rchild=f;

    3.gf->lchild/rchild=p;

B.调整最小不平衡子树 RR

  • RR插入后：

    由于在结点A的右孩子（R）的右子树（R）上插入新结点，A的平衡因子由-1减至-2，导致以A为根的子树失去平衡，需要一次向左的旋转操作。

  • RR平衡旋转（左单旋转）步骤：

    1.将A的右孩子B向左上旋转代替A成为根结点；

    2.将A结点向左下旋转成为B的左子树的根结点；

    3.将B的原左子树作为A结点的右子树。

    在这里插入图片描述

  • 左旋代码思路

    实现f向左下旋转，p向左上旋转：

    其中gf是f他爹。

    1.f->rchild=p->lchild;

    2.p->lchild=f;

    3.gf->lchild/rchild=p;

C.调整最小不平衡子树 LR

  • LR插入后：

    由于在A的左孩子（L）的右子树（R）上插入新结点，A的平衡因子由1增至2，导致以A为根的子树失去平衡，需要进行两次旋转操作，先左旋再右旋。

  • LR平衡旋转（先左后右双旋转）步骤：

    1.左旋：先将A结点的左孩子B的右子树的根结点C向左上旋转提升到B结点的位置；

    2.右旋：将C结点向右上旋转提升到A结点的位置。

    在这里插入图片描述

D.调整最小不平衡树 RL

  • RL插入后

    由于在A的右孩子（R）的左子树（L）上插入新结点，A的平衡因子由-1减至-2，导致以A为根的子树失去平衡，需要进行两次旋转操作，先右旋后左旋转。

  • RL平衡旋转（先右后左双旋转）步骤：

    1.右旋：将A结点的右孩子B的左子树的根结点C向右上旋转提升到B结点的位置；

    2.左旋：将C结点向左上旋转提升到A结点的位置。

    在这里插入图片描述

  • 旋转练习

    1.将新结点插入到相应位置；

    2.找到最近的不平衡结点；

    3.根据插入结点的位置旋转。

3.2.3 查找操作

  • 效率分析

    若树高为h，最坏情况下一个关键字对比h次，所以查找的时间复杂度不可能超过 O ( h ) O(h) O(h)。

  • 最少结点数

    假设以 n h n_h nh​表示深度为h的平衡树中含有的最少结点数，

    则有 n 0 = 0 , n 1 = 1 , n 2 = 2 n_0=0,n_1=1,n_2=2 n0​=0,n1​=1,n2​=2

    ​ n h = n h − 1 + n h − 2 + 1 n_h=n_{h-1}+n_{h-2}+1 nh​=nh−1​+nh−2​+1

    • 应用：对有9个结点的平衡二叉树，树高最大为4。（因为 n 4 = 7 , n 5 = 12 , 而 n 4 < 9 < n 5 n_4=7,n_5=12,而n_4<9<n_5 n4​=7,n5​=12,而n4​<9<n5​）

  • 含有n个结点的平衡二叉树

    最大深度： O ( l o g 2 n ) O(log_2n) O(log2​n)

    平均查找长度： O ( l o g 2 n ) O(log_2n) O(log2​n)

3.2.4 删除操作

  • 删除和插入操作相同，也要保持二叉排序树的特性不变。

  • 删除操作的步骤

    1.删除结点（方法同二叉排序树）；

    ​ 若删除结点是叶子结点，直接删。

    ​ 若删除结点只有一个子树，用子树顶替删除位置。

    ​ 若删除结点有两棵子树，用前驱（或后继）结点顶替，并转换为对前驱（或后继）结点的删除。

    2.一路向上找到最小不平衡子树；

    3.找到最小不平衡子树下，个头最高的儿子和孙子；

    ​ 如这里最高的儿子是80，最高的孙子是90：

    ​

    4.根据孙子的位置，调整平衡（LL/RR/LR/RL）；

    ​ 孙子在LL：儿子右单旋

    ​ 孙子在RR：儿子左单旋

    ​ 孙子在LR：孙子先左旋，再右旋

    ​ 孙子在RL：孙子先右旋，再左旋

    5.如果不平衡向上传导，继续第二步。

    ​ 对最小不平衡子树的旋转可能导致树变矮，从而导致上层祖先不平衡（不平衡向上传递）

    ​ 如：

*完整代码 平衡二叉树
#include <stdio.h>
#include <stdlib.h>

typedef struct Node {
    int key;
    struct Node* left;
    struct Node* right;
    int height;
} Node;

// 计算节点的高度
int height(Node* node) {
    if (node == NULL)
        return 0;
    return node->height;
}

// 返回两个整数中较大的一个
int max(int a, int b) {
    return (a > b) ? a : b;
}

// 创建一个新节点
Node* newNode(int key) {
    Node* node = (Node*)malloc(sizeof(Node));
    node->key = key;
    node->left = NULL;
    node->right = NULL;
    node->height = 1;
    return node;
}

// 右旋转子树
Node* rightRotate(Node* y) {
    Node* x = y->left;
    Node* T2 = x->right;

    x->right = y;
    y->left = T2;

    y->height = max(height(y->left), height(y->right)) + 1;
    x->height = max(height(x->left), height(x->right)) + 1;

    return x;
}

// 左旋转子树
Node* leftRotate(Node* x) {
    Node* y = x->right;
    Node* T2 = y->left;

    y->left = x;
    x->right = T2;

    x->height = max(height(x->left), height(x->right)) + 1;
    y->height = max(height(y->left), height(y->right)) + 1;

    return y;
}

// 获取节点的平衡因子
int getBalance(Node* node) {
    if (node == NULL)
        return 0;
    return height(node->left) - height(node->right);
}

// 插入节点
Node* insert(Node* node, int key) {
    if (node == NULL)
        return newNode(key);

    if (key < node->key)
        node->left = insert(node->left, key);
    else if (key > node->key)
        node->right = insert(node->right, key);
    else // 如果键值已经存在，则不插入
        return node;

    node->height = 1 + max(height(node->left), height(node->right));

    int balance = getBalance(node);

    // 如果节点不平衡，根据不同情况进行旋转
    if (balance > 1 && key < node->left->key)
        return rightRotate(node);
    if (balance < -1 && key > node->right->key)
        return leftRotate(node);
    if (balance > 1 && key > node->left->key) {
        node->left = leftRotate(node->left);
        return rightRotate(node);
    }
    if (balance < -1 && key < node->right->key) {
        node->right = rightRotate(node->right);
        return leftRotate(node);
    }

    return node;
}

// 查找最小值节点
Node* minValueNode(Node* node) {
    Node* current = node;

    while (current->left != NULL)
        current = current->left;

    return current;
}

// 删除节点
Node* deleteNode(Node* root, int key) {
    if (root == NULL)
        return root;

    if (key < root->key)
        root->left = deleteNode(root->left, key);
    else if (key > root->key)
        root->right = deleteNode(root->right, key);
    else {
        if ((root->left == NULL) || (root->right == NULL)) {
            Node* temp = root->left ? root->left : root->right;

            if (temp == NULL) {
                temp = root;
                root = NULL;
            } else
                *root = *temp;
            free(temp);
        } else {
            Node* temp = minValueNode(root->right);
            root->key = temp->key;
            root->right = deleteNode(root->right, temp->key);
        }
    }

    if (root == NULL)
        return root;

    root->height = 1 + max(height(root->left), height(root->right));

    int balance = getBalance(root);

    if (balance > 1 && getBalance(root->left) >= 0)
        return rightRotate(root);
    if (balance > 1 && getBalance(root->left) < 0) {
        root->left = leftRotate(root->left);
        return rightRotate(root);
    }
    if (balance < -1 && getBalance(root->right) <= 0)
        return leftRotate(root);
    if (balance < -1 && getBalance(root->right) > 0) {
        root->right = rightRotate(root->right);
        return leftRotate(root);
    }

    return root;
}

// 查找节点
Node* search(Node* root, int key) {
    if (root == NULL || root->key == key)
        return root;

    if (root->key < key)
        return search(root->right, key);

    return search(root->left, key);
}

// 中序遍历二叉树
void inorder(Node* root) {
    if (root != NULL) {
        inorder(root->left);
        printf("%d ", root->key);
        inorder(root->right);
    }
}

// 主函数
int main() {
    Node* root = NULL;

    root = insert(root, 10);
    root = insert(root, 20);
    root = insert(root, 30);
    root = insert(root, 40);
    root = insert(root, 50);
    root = insert(root, 25);

    printf("Inorder traversal of the constructed AVL tree:\n");
    inorder(root);
    printf("\n");

    Node* foundNode = search(root, 30);
    if (foundNode != NULL)
        printf("Node with key 30 found!\n");
    else
        printf("Node with key 30 not found.\n");

    root = deleteNode(root, 30);

    printf("Inorder traversal after deletion of 30:\n");
    inorder(root);
    printf("\n");

    foundNode = search(root, 30);
    if (foundNode != NULL)
        printf("Node with key 30 found!\n");
    else
        printf("Node with key 30 not found.\n");

    return 0;
}

吧啦吧啦嘭
关注
  • 14
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
二叉排序树的创建，插入和删除（C++完整代码）
qq_48071481的博客
10-18 7958
一、二叉排序树（二叉查找树）的概念 （1）若左子树非空，则左子树上所有结点的值均小于根节点的值 （2）若右子树非空，则右子树上所有结点的值均大于根节点的值 （3）左右子树分别也是一棵二叉排序树 tip：可以是一棵空树 二、二叉排序树的判别 （1）因为二叉排序树的中序遍历是一个有序递增序列，可以对已经建立的二叉树进行中序遍历，如果满足则判断是 三、二叉排序树的创建（creat、insert） 树结点的结构体： struct tree{ int data; struc...
平衡二叉树(代码)
JIE的博客
12-12 1756
#include<stdio.h> #include <stdlib.h> #include <stdbool.h> typedef struct TreeNode { int data; struct TreeNode* left; struct TreeNode* right; }TreeNode; TreeNode* create_node(int data) { TreeNode* node = malloc(sizeof(TreeNode)); n
平衡二叉树（AVL树）
qq_43906881的博客
10-20 193
平衡二叉树（AVL树） 1、问题引入 给你一个数列{1,2,3,4,5,6}，要求创建一颗二叉排序树(BST), 并分析问题所在. 左子树全部为空，从形式上看，更像一个单链表. 插入速度没有影响 查询速度明显降低(因为需要依次比较), 不能发挥 BST的优势，因为每次还需要比较左子树，其查询速度比单链表还慢 解决方案-平衡二叉树(AVL) 2、基本介绍 平衡二叉树也叫平衡 二叉搜索树（Self-balancingbinary search tree）又被称为 AVL 树，可以保证查询效率较高。 具有以
平衡二叉树完整代码（创建，插入，旋转）
07-20
该套代码是博主在学习数据结构的平衡二叉树时总结整理的一套平衡二叉树的代码，包括平衡二叉树的创建，插入，旋转，遍历等一套完善的代码，亲自测试过，代码保证是对的。
平衡二叉树-代码详解
zl_mj_hc的博客
06-17 154
平衡二叉树是一种特殊的搜索二叉树，普通的搜索二叉树没有限制左右子树的高度关系，当搜索二叉树时斜树时查找效率了低，为了解决这种极端问题就考虑左右子树的高度关系，平衡二叉树就是限制左右子树高度差不超过1。这种情况3是一个不平衡点，3的右子树函数中时L，L时平衡的看似没什么问题但是问大家，加入1是新节点，请问1是怎么插入在一个原来就不平衡的棵树上的。双旋转：当9作为新节点插入时，4，6，7，均为R，而10未L，这是需要10右旋转，9替代原来的10，此时9未R，这时对7进行左旋即可。
平衡二叉树的实现代码
吴小宝的博客
08-21 9656
前面已经讲过平衡二叉树的实现原理以及实例 原理参见 http://blog.csdn.net/wxbmelisky/article/details/47755753      实例参见 http://blog.csdn.net/wxbmelisky/article/details/47787963 平衡二叉树的实现代码如下
java 数据结构二叉树的实现代码
09-01
在Java中，数据结构中的二叉树是一种重要的抽象数据类型，它由节点组成，每个节点最多有两个子节点，通常称为左子节点和右子节点。在本文中，我们将深入探讨如何使用Java实现二叉树，并通过接口、节点类和具体实现来...
数据结构之二叉树的C++实现源码
02-15
在IT领域，数据结构是计算机科学的基础，而二叉树作为一种重要的数据结构，广泛应用于算法设计和程序开发中。本文将深入探讨如何使用C++语言实现二叉树，并结合提供的压缩包文件“PracticalTraining_Exam2_1_12_24”...
东北大学数据结构与算法课程设计实验报告+源代码
04-20
1. **数据结构**：这可能涵盖了数组、链表、栈、队列、哈希表、树（二叉树、红黑树、AVL树等）、图等基本数据结构的实现，每个数据结构都有其特定的存储和操作方式，适用于不同的问题场景。 2. **算法**：包括排序...
数据结构二叉树，c语言简单实现
01-12
数据结构中的二叉树是一种非线性数据结构，它由n（n>=1）个有限节点组成，这些节点通过边连接形成一个具有层次关系的集合。每个节点最多有两个子节点，通常称为左子节点和右子节点。二叉树的概念在计算机科学中广泛...
平衡二叉树源代码
01-31
平衡二叉树源代码
吉林大学数据结构上机实验全套完整代码
最新发布
07-09
4. **二叉树查找节点**：二叉树是一种特殊的树形数据结构，每个节点最多有两个子节点。查找节点通常涉及遍历树的递归过程，包括前序、中序和后序遍历。 5. **二叉树的创建**：创建二叉树可能涉及从数组、链表或其他...
平衡二叉树的代码实现
慎铭的博客
11-02 659
  平衡二叉树，即对于一颗二叉查找树，它的任意一个结点的左子树与右子树高度之差小于1，这样的树我们称之为平衡二叉树。当一个树为平衡二叉树时，对它进行插入运算或者删除运算，都有可能会造成树的失衡，这时，我们就要对其进行调整，使他重新成为一颗平衡二叉树。 判断一颗树是否失衡   我们要判断一棵二叉查找树是否平衡，便要对其进行遍历，若存在结点，使得它的左子树高度和右子树高度之差大于1，则树不平衡。为了比较时方便，我们这样定义树的结构。 struct AVLNode { struct AVLNode *lchil
平衡二叉树代码实现
明月如霜，照见人如画
06-11 285
平衡二叉树（AVL树）的详细介绍：https://blog.csdn.net/qq_43643944/article/details/116354568 #include <iostream> using namespace std; typedef struct BiTNode { //结点定义 int data; int height;//高度，表示以当前结点为根的子树的高度 struct BiTNode *lchild, *rchild; } BiTNode,.
平衡二叉树及代码实现
5683的博客
10-24 780
1 介绍 平衡二叉树，又称AVL树，在学习AVL树之前，最好先掌握二叉查找树，因为AVL树，就是对二叉查找树的平衡性进行优化而得到的特殊的二叉搜索树。 它有和二叉搜索树一样的特点： 树中的任一节点总是大于其左子树的任一节点，小于其右子树的任一节点 同时有着自己独特的特点 树中任一节点的左右两个子树的高度差的不会超过1 示例 2 时间复杂度 平衡二叉树的左右子树高度差不大于1，这个特点使它的时间复杂度和普通的二叉查找树相比要稳定得多，不会出现普通二叉查找树退化成链表的情况，树高和节点数的关系为 h =
数据结构之——平衡二叉树代码实现
m0_37914588的博客
12-29 4260
一、结构定义 public class BalanceTree { //根节点 private Node root; /** * 静态内部类，定义节点。 */ private static class Node { //数据域 private int data; //父节点 ...
平衡二叉树的插入(java实现)
weixin_37885641的博客
10-15 397
/** * @author hgl * @data 2018年9月24日 * @description 平衡二叉树的结点 */ public class BSTNode { public int data;//数据 public int bf;//结点的平衡因子 public BSTNode lchild;//左孩子 public BSTNode rchild;//右孩子...
平衡二叉树的插入
weixin_52530507的博客
12-04 123
int Max(int a, int b){ if(a>b) return a; else return b; } int GetHeight(AVLTree A){ if(A==NULL) return 0; return A->Height; } AVLTree LeftRotate(AVLTree A){ AVLTree B=A->Right; A->Right=B->Left

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值