二叉平衡树——插入操作（C++)

最新推荐文章于 2024-11-09 20:38:27 发布
最新推荐文章于 2024-11-09 20:38:27 发布
阅读量290 收藏 6
点赞数 5
文章标签： c++ 开发语言 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ll2633ll/article/details/139666747
版权

二叉平衡树

二叉平衡树的前置理论知识，这篇博客已经总结得比较完善了数据结构之——平衡二叉树（内容详解）。在此不做赘述，本文基于C++实现，提供二叉平衡树的构造（插入）代码，基于C++实现。

二叉平衡树的结构定义

struct TreeNode {
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode *fa = nullptr; // 存储父节点
    int depth = 1; // 存储深度
    TreeNode() : val(0), left(nullptr), right(nullptr) {}
    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
    TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
};

这里设计的结构对比二叉树增加了：

  1. f a fa fa 指针：指向当前节点的父节点，设立的原因是实现后文的 L L LL LL等旋转的时候快速获取父节点。
  2. d e p t h depth depth：指的是以当前节点为根节点的子树的高度，设立的原因是为了计算平衡因子=左子树和右子树的高度的差值。

插入代码及解释

int get_depth(TreeNode* root) { return root == nullptr ? 0 : root->depth; }

void update_depth(TreeNode*& root) { root->depth = max(get_depth(root->left), get_depth(root->right)) + 1; }

void insert(TreeNode*& root, int v){
    // 向 root 根插入元素 v
    if (root == nullptr) {
        root = new TreeNode(v);
        return ;
    }
    if (root->left == nullptr && root->right == nullptr) {
        if (root->val == v) return ;
        (root->val <  v ?  root->right : root->left) = new TreeNode(v);
        (root->val <  v ?  root->right : root->left)->fa = root;
        root->depth = 2;
        return ;
    }
    if (root->val < v) {
        insert(root->right, v);
        root->right->fa = root;
    }else if (root->val > v) {
        insert(root->left, v);
        root->left->fa = root;
    }
    // 检查平衡因子
    int left_depth = root->left ? root->left->depth : 0, right_depth = root->right ? root->right->depth : 0;
    if (abs(left_depth - right_depth) > 1) { // 调整树型
        TreeNode* tmpFa = root->fa ? root->fa : new TreeNode(-INT_MAX, root, nullptr);
        bool flag = tmpFa->left == root;
        if (root->left && root->val > v) { // 插入到左子树
            if (v < root->left->val) { // LL 平衡旋转
                TreeNode* B_Node = root->left, *B_Node_r = B_Node->right;
                B_Node->right = B_Node->fa, B_Node->right->fa = B_Node;
                B_Node->right->left = B_Node_r;
                if (B_Node_r) B_Node->right->left->fa = B_Node->right;
                (flag ? tmpFa->left : tmpFa->right) = B_Node;
                update_depth(root), update_depth(B_Node);// 更新高度
            } else { // LR平衡旋转
                TreeNode* B_Node = root->left, *C_Node = B_Node->right;
                TreeNode* C_Node_l = C_Node->left, *C_Node_r = C_Node->right;
                C_Node->left = B_Node, C_Node->left->fa = C_Node;
                C_Node->right = root, C_Node->right->fa = C_Node;
                B_Node->right = C_Node_l;
                if (C_Node_l) B_Node->right->fa = B_Node;
                root->left = C_Node_r;
                if (C_Node_r) root->left->fa = root;
                (flag ? tmpFa->left : tmpFa->right) = C_Node;
                update_depth(root), update_depth(B_Node), update_depth(C_Node);// 更新高度
            }
        } else { // 插入到右子树
            if (v > root->right->val) { // RR 平衡旋转
                TreeNode* B_Node = root->right, *B_Node_l = B_Node->left;
                B_Node->left = B_Node->fa, B_Node->left->fa = B_Node;
                B_Node->left->right = B_Node_l;
                if (B_Node_l) B_Node->left->right->fa = B_Node->left;
                (flag ? tmpFa->left : tmpFa->right) = B_Node;
                update_depth(root), update_depth(B_Node); // 更新高度
            } else { // RL 平衡旋转
                TreeNode* B_Node = root->right, *C_Node = B_Node->left;
                TreeNode* C_Node_l = C_Node->left, *C_Node_r = C_Node->right;
                C_Node->left = root, C_Node->left->fa = C_Node;
                C_Node->right = B_Node, C_Node->right->fa = C_Node;
                B_Node->left = C_Node_r;
                if (C_Node_r) B_Node->left->fa = B_Node;
                root->right = C_Node_l;
                if (C_Node_l) root->right->fa = root;
                (flag ? tmpFa->left : tmpFa->right) = C_Node;
                update_depth(root), update_depth(B_Node), update_depth(C_Node);// 更新高度
            }
        }
        (flag ? tmpFa->left : tmpFa->right)->fa = tmpFa;
        if (tmpFa->val == -INT_MAX) root = (flag ? tmpFa->left : tmpFa->right);
    }
    update_depth(root);
    return ;
}

看懂代码的前提还是需要看懂相关的旋转理论，其实本质上代码就是对旋转的过程进行了实现。
需要注意的是：

  1. 旋转的过程中，需要及时更新父节点的情况。
  2. 旋转的过程中，有的节点的高度是会发生改变的，因而需要及时进行更新。

代码测试

int main(){
    vector<int> nums{15, 3, 7, 10, 9, 8};
    TreeNode* root = nullptr;
    for (int num : nums) {
        insert(root, num);
    }
    cout << "preOrder: ";
    preOrder(root);
    cout << endl;
    cout << "inOrder: ";
    inOrder(root);
    cout << endl;
    return 0;
}

测试的结果如下：

preOrder: 9, 7, 3, 8, 10, 15
inOrder: 3, 7, 8, 9, 10, 15

完整代码：

#include<bits/stdc++.h>
using namespace std;

struct TreeNode {
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode *fa = nullptr; // 存储父节点
    int depth = 1; // 存储深度
    TreeNode() : val(0), left(nullptr), right(nullptr) {}
    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
    TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
};

int get_depth(TreeNode* root) { return root == nullptr ? 0 : root->depth; }

void update_depth(TreeNode*& root) { root->depth = max(get_depth(root->left), get_depth(root->right)) + 1; }

void insert(TreeNode*& root, int v){
    // 向 root 根插入元素 v
    if (root == nullptr) {
        root = new TreeNode(v);
        return ;
    }
    if (root->left == nullptr && root->right == nullptr) {
        if (root->val == v) return ;
        (root->val <  v ?  root->right : root->left) = new TreeNode(v);
        (root->val <  v ?  root->right : root->left)->fa = root;
        root->depth = 2;
        return ;
    }
    if (root->val < v) {
        insert(root->right, v);
        root->right->fa = root;
    }else if (root->val > v) {
        insert(root->left, v);
        root->left->fa = root;
    }
    // 检查平衡因子
    int left_depth = root->left ? root->left->depth : 0, right_depth = root->right ? root->right->depth : 0;
    if (abs(left_depth - right_depth) > 1) { // 调整树型
        TreeNode* tmpFa = root->fa ? root->fa : new TreeNode(-INT_MAX, root, nullptr);
        bool flag = tmpFa->left == root;
        if (root->left && root->val > v) { // 插入到左子树
            if (v < root->left->val) { // LL 平衡旋转
                TreeNode* B_Node = root->left, *B_Node_r = B_Node->right;
                B_Node->right = B_Node->fa, B_Node->right->fa = B_Node;
                B_Node->right->left = B_Node_r;
                if (B_Node_r) B_Node->right->left->fa = B_Node->right;
                (flag ? tmpFa->left : tmpFa->right) = B_Node;
                update_depth(root), update_depth(B_Node);// 更新高度
            } else { // LR平衡旋转
                TreeNode* B_Node = root->left, *C_Node = B_Node->right;
                TreeNode* C_Node_l = C_Node->left, *C_Node_r = C_Node->right;
                C_Node->left = B_Node, C_Node->left->fa = C_Node;
                C_Node->right = root, C_Node->right->fa = C_Node;
                B_Node->right = C_Node_l;
                if (C_Node_l) B_Node->right->fa = B_Node;
                root->left = C_Node_r;
                if (C_Node_r) root->left->fa = root;
                (flag ? tmpFa->left : tmpFa->right) = C_Node;
                update_depth(root), update_depth(B_Node), update_depth(C_Node);// 更新高度
            }
        } else { // 插入到右子树
            if (v > root->right->val) { // RR 平衡旋转
                TreeNode* B_Node = root->right, *B_Node_l = B_Node->left;
                B_Node->left = B_Node->fa, B_Node->left->fa = B_Node;
                B_Node->left->right = B_Node_l;
                if (B_Node_l) B_Node->left->right->fa = B_Node->left;
                (flag ? tmpFa->left : tmpFa->right) = B_Node;
                update_depth(root), update_depth(B_Node); // 更新高度
            } else { // RL 平衡旋转
                TreeNode* B_Node = root->right, *C_Node = B_Node->left;
                TreeNode* C_Node_l = C_Node->left, *C_Node_r = C_Node->right;
                C_Node->left = root, C_Node->left->fa = C_Node;
                C_Node->right = B_Node, C_Node->right->fa = C_Node;
                B_Node->left = C_Node_r;
                if (C_Node_r) B_Node->left->fa = B_Node;
                root->right = C_Node_l;
                if (C_Node_l) root->right->fa = root;
                (flag ? tmpFa->left : tmpFa->right) = C_Node;
                update_depth(root), update_depth(B_Node), update_depth(C_Node);// 更新高度
            }
        }
        (flag ? tmpFa->left : tmpFa->right)->fa = tmpFa;
        if (tmpFa->val == -INT_MAX) root = (flag ? tmpFa->left : tmpFa->right);
    }
    update_depth(root);
    return ;
}

void preOrder(TreeNode* root){
    if (root == nullptr) return;
    cout << root->val << ", ";
    preOrder(root->left);
    preOrder(root->right);
}

void inOrder(TreeNode* root){
    if (root == nullptr) return;
    inOrder(root->left);
    cout << root->val << ", ";
    inOrder(root->right);
}

int main(){
    vector<int> nums{15, 3, 7, 10, 9, 8};
    TreeNode* root = nullptr;
    for (int num : nums) {
        insert(root, num);
    }
    cout << "preOrder: ";
    preOrder(root);
    cout << endl;
    cout << "inOrder: ";
    inOrder(root);
    cout << endl;
    return 0;
}

从以上测试结果来看，代码应当没有很大的问题，可放心食用~
创作不易，欢迎点赞，感谢~~

kongchen1024
关注
数据结构与算法详解——二叉查找树篇（附c++实现代码）
JMasker的博客
05-23 1470
目录二叉树相关概念和术语二叉树特殊类型二叉树的存储链式存储顺序存储二叉树的遍历二叉查找树查找插入删除完整代码 二叉树相关概念和术语   二叉树的递归定义为：二叉树是一棵空树，或者是一棵由一个根节点和两棵互不相交的，分别称作根的左子树和右子树组成的非空树；左子树和右子树又同样都是二叉树。 度：一个节点拥有子树的数目称为结点的度，叶子结点的度为0。 叶子结点：也称为终端结点，没有子树的结点或者度为零的结点。 结点的层次：从根结点开始，假设根结点为第1层，根节点的子结点为第2层，依此类推，如果某一个结点位于第L
AVL树（高度平衡二叉搜索树）的模拟实现
work_hard423的博客
07-15 665
写死我了┭┮﹏┭┮
数据结构——平衡二叉树(AVL树)之插入
weixin_57023347的博客
06-17 7816
文章目录前言一.定义二.基本操作1.查找，删除2.插入(如何调整)如何调整代码实现插入 前言 首先我们来思考一下一个普通二叉树保存数据，如果想查找一个数据，由于普通二叉树保存数据是随机的，要找到数据的时间复杂度为O(n)。后面为了方便 ，我们又学习二叉搜索树，它的定义是将比根节点小的数放左边，比根节点大的数放右边，并且每一课子树都是二叉搜索树这样使得数据在树上存储有一定 的规律，在一定情况下查找起来很方便。但是，二叉搜索数当给出数据的顺序不同时，二叉搜索树也会不同。比如如果给出的序列为{1，2，3，4，5}
平衡二叉树插入操作的详细过程图解
热门推荐
jinking01的专栏
05-08 1万+
二叉搜索树/二叉排序树/二叉查找树 是二叉树、任意结点的左子树的值均小于根节点的值，右子树均大于根节点的值 没有键值相等 平衡二叉树(AVL树) 定义 左右字数的高度差的绝对值不超过1，并且两子树都是平衡二叉树 没有键值相等 高度差，又名平衡因子，范围为[-1,0,1]，在此规定==平衡因子 bf = 右子树的高度-左子树的高度== 插入操作 当有新的结点...
平衡二叉树（AVL）的插入与调整
Sep21m_wyy的博客
08-12 1665
平衡二叉树（AVL）的插入与调整 平衡二叉树： 定义：一种特殊的二叉查找树，树上任一结点的左子树和右子树的深度之差不超过1（平衡因子：左右子树深度之差，只要有仁义结点的平衡因子绝对值大于1，就不是平衡二叉树）。 平衡二叉树的插入 在一个平衡二叉树中插入一个结点时，又可能会出现失衡，即出现平衡因子绝对值大于1的结点，如：2，-2. 比如下面这个例子： 接下来就必须要重新调整树的结构，恢复平衡。每次调整的对象称为最小不平衡树。 平衡调整的四种类型 4中类型如下图： 平衡调整 之前学习的大部分方法都是左旋调整
查找算法【平衡二叉树】 - 平衡二叉树的插入
谢谢你们的关注
10-31 874
查找算法【平衡二叉树】 - 平衡二叉树的插入
C++二叉搜索树——插入
qq_43640822的博客
05-31 553
​ 通过结构体作为节点，结构体包含四个成员，分别是键值key，指向父节点的指针 *parent，指向左子节点的指针 *left，指向右子节点的指针 *right。 struct Node{ int key; Node *left,right,parent; } ​ 从根以起点寻找节点 x 的插入位置。 设当前节点为 x，如果 z 的键值小于 x 则将当前节点的左子节点作为下一个 x，反之则以...
【数据结构】AVL树——平衡二叉搜索树
2301_79796701的博客
05-25 1762
平衡树：左子树的高度等于右子树的高度不平衡树：左子树的高度不等于等于右子树的高度二叉搜索树很难是一颗平衡树。对二叉树进行插入和删除的操作，或插入大量的数据不够随机，都会是使二叉搜索树不够平衡。极端情况下，二叉树会退化成类似链表的结构，那么二叉搜索树查询数据的效率荡然无存。在二叉树的基础上加入平衡的概念就是平衡二叉搜索树，也叫AVL树。AVL树也不是一颗绝对的平衡树，AVL树的平衡是相对的，它允许左子树和右子树的高度为 1 ，但不能超过 1。
平衡二叉搜索树——红黑树
hahahahahaha5的博客
03-12 739
平衡搜索树——红黑树）一.红黑树的性质1.红黑树的基本性质2.红黑树为何可以将时间复杂度降为O(lgn) 首先，在了解红黑树之前我们应该知道平衡搜索树是一种进阶版的二叉搜索树。可是，普通的二叉搜索树在进行插入，删除等操作时，虽然在树高较低时执行的很快。然而，如果树的高度较高时，执行效率可能并没有链表高。前人们为解决此问题，便有人提出了使搜索树平衡的想法。此后，便出现了各种使搜索树平衡的算法，红黑树便是其中的一种，它可以保证在最坏情况下进行基本动态集合操作的时间复杂度为O(lgn)。 一.红黑树的性质 1.红
动图详解平衡树——平衡的二叉搜索树
tunmang5421的博客
04-10 1500
【多动图警告】本文详细介绍了平衡树，加了一些动图和自己的理解
数据结构（二叉平衡排序树）课程设计报告
10-25
然而，二叉平衡排序树通过特定的结构调整策略，确保了树的左右子树高度差不超过1，极大地优化了搜索、插入和删除操作的时间复杂度，通常达到O(log n)。 常见的二叉平衡排序树类型有AVL树和红黑树。AVL树是最早被...
史上最简单的平衡树——无旋Treap.pdf
01-14
### 最简平衡树——无旋Treap（fhq_treap）详解 #### 一、简介 无旋Treap（fhq_treap），由范浩强发明，是一种高效的平衡树数据结构。它综合了Treap与Splay树的优点，支持常见的平衡树操作如插入、删除、查找等，...
二叉搜索树——概述】定义】相关习题】具体实现】基本操作】
01解题者~博客
03-23 1369
二叉搜索树 文章目录1、概述2、二叉搜索树的定义3、相关入门习题【1】[验证二叉搜索树](https://leetcode-cn.com/problems/validate-binary-search-tree/)1）解法一：递归2) 解法二：中序遍历【2】[二叉搜索树迭代器](https://leetcode-cn.com/problems/binary-search-tree-iterator/)4、二叉搜索树的基本操作1-搜索操作代码示例2-插入操作代码示例：3-删除操作代码示例：以上代码算法思想：5
C++_用 using 语句继承基类的构造函数
学海无涯
11-09 84
**默认情况下**，派生类会继承基类的所有成员，包括数据成员和函数成员，但不会继承基类的**构造函数和析构函数**，因为构造函数和析构函数的作用是创建和销毁对象，派生类通常需要有自己的构造和析构的逻辑。C++11 引入了using语句，使得派生类可以通过 using 关键字使用基类的构造函数，更方便地复用基类的构造逻辑。
C 学习（4）
search7的博客
11-05 768
C语言学习，每个模块来自工作中的？？？
STL set
最新发布
hls0611的博客
11-09 142
练习题：P1059 [NOIP2006 普及组] 明明的随机数。
常用的c++特性--＞day02
m0_69093426的博客
11-06 546
C++11中为我们提供了一个模板类叫做std::enable_shared_from_this，这个类中有一个方法叫做shared_from_this()，通过这个方法可以返回一个共享智能指针，在函数的内部就是使用weak_ptr来监测this对象，并通过调用weak_ptr的lock()方法返回一个shared_ptr对象。通过打印的结果可以知道，虽然弱引用智能指针wp3、wp4、wp5监测的资源是同一个，但是它的引用计数并没有发生任何的变化，也进一步证明了weak_ptr只是监测资源，并不管理资源。
GitLab 提交 C++ 技巧
nbspzs的专栏
11-08 207
在 GitLab 中提交 C++ 代码时，通常应只提交 源代码文件（例如 .cpp、.h）和 CMake 配置文件（例如 CMakeLists.txt），而不要提交通过 CMake 编译后的中间文件或构建产物。这样，当其他开发者克隆你的项目后，他们可以在自己的机器上使用 cmake 构建项目，而不需要下载编译产物。2. 跨平台兼容性：不同的开发者和平台可能会生成不同的编译产物，提交这些文件会造成不必要的冲突和问题。1. 在 .gitignore 文件中忽略编译生成的文件和目录。
西南科技大学C++作业1——组合依赖关系实验代码
m0_74312676的博客
11-05 612
合理设计类与类的组合关系，即一个类要嵌套另一个类的对象作为成员变量，根据问题的需要可以是同一个类的多个对象(可以使用对象数组)，也可以是不同类的多个不同对象。让所设计的功能发挥作用。对学生和图书进行抽象，抽象出应有的成员变量，和基本的初始化，修改等成员函数，学生可以发起借书的操作，这是一种依赖关系，在学生类中将设计相应的成员函数体现这一功能操作，合理即可，可以用输出借书是否成功的结果，有一定示意就可以。其他操作：计算得到正确答案，输入自己的题目的答案，向题库内增加题目，在题库内删除题目，查询题库的题目。
二叉搜索树原理与应用——数控机床G代码M代码关联分析
同样，删除操作也需要找到待删除节点，并考虑三种情况：没有子节点、有一个子节点和有两个子节点，分别对应直接删除、替换和重新平衡树的操作。 对于相等关键码的情况，二叉搜索树的接口可以扩展来支持多个相同元素...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值