Size Blanced Tree

最新推荐文章于 2024-07-25 17:45:03 发布
最新推荐文章于 2024-07-25 17:45:03 发布
阅读量150 收藏
点赞数
分类专栏： 算法和数据结构 学习笔记 文章标签： 二叉树 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46654029/article/details/109550470
版权

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

Size Blanced Tree

介绍

Size Blanced Tree 是平衡二叉树的一种。每个结点所在子树的结点个数不小于其兄弟的两个孩子所在子树的结点个数，并且在插入时才会触发平衡调整。它还可以用来求第k小元素

一、自平衡条件

对于每个结点 tt，同时满足

size[right[t]]≥ max(size[left[left[t]]],size[right[left[t]]])
size[right[t]]≥max(size[left[left[t]]],size[right[left[t]]])

size[left[t]] ≥max(size[left[right[t]]],size[right[right[t]]])
size[left[t]]≥max(size[left[right[t]]],size[right[right[t]]])

其中 size[t]size[t] 表示 tt 结点所在子树的结点个数。

形象一点来说，就是每个结点所在子树的结点个数不小于其兄弟的两个孩子所在子树的结点个数。

比如对于这棵排序二叉树

在这里插入图片描述
对于结点 39 来说，就不满足 SBTree 的自平衡条件。

二、旋转操作

左旋和右旋，通过一系列左旋和右旋操作，将不平衡的树调整为平衡树。

左旋操作的演示如下：
在这里插入图片描述
通过进行左旋操作，使得原先的根 4变成了其左孩子2的右孩子，而 2 原先的左孩子 3变成了 4 的左孩子。

对应的，右旋操作的演示如下：
在这里插入图片描述
通过右旋操作，使得原先的根 5变成了其左孩子 3 的右孩子，而 3 原先的右孩子变成了 5 的左孩子。

多旋

AVL 树中还有两种复合旋转操作（即“多旋”），由两次单旋操作组合而成

第一种是左旋加右旋：
在这里插入图片描述
第二种是右旋加左旋：
在这里插入图片描述

三、旋转的触发

在调整过程中，一共有 4 种会触发旋转的情况：

LL 型：size[left[left[t]]] > size[right[t]]size[left[left[t]]]>size[right[t]]：首先对子树 tt 执行右旋操作，旋转以后对 tt 的右子树进行调整，之后再对子树 tt 进行调整。

LR 型：size[right[left[t]]] > size[right[t]]
size[right[left[t]]]>size[right[t]]：首先对 tt 的左子树执行左旋操作，再对 tt 进行右旋操作。之后分别调整结点 tt 的左右子树，最终对结点 tt进行调整。

RR 型：size[right[right[t]]] > size[left[t]]
size[right[right[t]]]>size[left[t]]：首先对 tt 执行左旋操作，旋转以后对 tt 的左子树进行调整，之后再对 tt 进行调整。

RL 型：size[left[right[t]]] > size[left[t]]
size[left[right[t]]]>size[left[t]]：首先对结点 tt 的右子树执行右旋操作，再对 tt 进行左旋操作。之后分别调整 tt 的左右子树，最终对 tt 进行调整。

通过递归的进行调整，我们可以最终让不平衡的 SBTree 恢复平衡状态。可以证明，调整操作的均摊时间复杂度为 O(1)O(1)。

和 AVL 不太一样的是，SBTree 只有在插入时才可能触发调整，而 不需要在删除结点以后进行调整。

四、代码

#include <iostream>

using std::cin;
using std::cout;
using std::endl;

template<typename Type>
class SBTNode {
public:
    Type data;
    int size;
    SBTNode<Type> *lchild, *rchild, *father;
    SBTNode(Type init_data, int init_size = 0, SBTNode<Type> *init_father = NULL);
    ~SBTNode();

    void insert(Type value);
    SBTNode<Type>* search(Type value);
    SBTNode<Type>* predecessor();
    SBTNode<Type>* successor();
    void remove_node(SBTNode<Type> *delete_node);
    bool remove(Type value);
    void print();
};

template<typename Type>
class BinaryTree {
private:
    SBTNode<Type>* root;
public:
    BinaryTree();
    ~BinaryTree();
    void insert(Type value);
    bool find(Type value);
    bool remove(Type value);
    void print_();
};

SBTNode<int> ZERO(0);
SBTNode<int>* NIL = &ZERO;

template <typename Type>
SBTNode<Type>::SBTNode(Type init_data, int init_size, SBTNode<Type>* init_father) {
    data = init_data;
    size = init_size;
    lchild = NIL;
    rchild = NIL;
    father = init_father;
}

template <typename Type>
SBTNode<Type>::~SBTNode() {
    if (lchild != NIL) {
        delete lchild;
    }
    if (rchild != NIL) {
        delete rchild;
    }
}

//左旋
template <typename Type>
SBTNode<Type>* left_rotate(SBTNode<Type>* node) {
    SBTNode<Type>* temp = node->rchild;
    node->rchild = temp->lchild;
    temp->lchild->father = node;
    temp->lchild = node;
    temp->father = node->father;
    node->father = temp;
    temp->size = node->size;
    node->size = node->lchild->size + node->rchild->size + 1;
    return temp;
}

//右旋
template <typename Type>
SBTNode<Type>* right_rotate(SBTNode<Type>* node) {
    SBTNode<Type>* temp = node->lchild;
    node->lchild = temp->rchild;
    temp->rchild->father = node;
    temp->rchild = node;
    temp->father = node->father;
    node->father = temp;
    temp->size = node->size;
    node->size = node->lchild->size + node->rchild->size + 1;
    return temp;
}

//调整
template <typename Type>
SBTNode<Type>* maintain(SBTNode<Type>* node, bool flag) {
    //左子树更高的情况
    if (flag == false) {
        if (node->lchild->lchild->size > node->rchild->size) { //LL
        	node = right_rotate(node);
        } else if (node->lchild->rchild->size > node->rchild->size){ //LR
        	node->lchild = left_rotate(node->lchild);
            node = right_rotate(node);
        } else {
        	return node;
        }
    } 
    //右子树更高的情况
    else {
    	if (node->rchild->rchild->size > node->lchild->size) { //RR
        	node = left_rotate(node);
        }  else if (node->rchild->lchild->size > node->lchild->size) { //RL
        	node->rchild = right_rotate(node->rchild);
            node = left_rotate(node);
        } else {
        	return node;
        }
    }
    node->lchild = maintain(node->lchild,false);
    node->rchild = maintain(node->rchild,true);
    node = maintain(node,false);
    node = maintain(node,true);
    return node;
}

template <typename Type>
SBTNode<Type>* insert(SBTNode<Type>* node, Type value) {
    node->size++;
    if (value > node->data) {
        if (node->rchild == NIL) {
            node->rchild = new SBTNode<Type>(value, 1, node);
        } else {
            node->rchild = insert(node->rchild, value);
        }
    } else {
        if (node->lchild == NIL) {
            node->lchild = new SBTNode<Type>(value, 1, node);
        } else {
            node->lchild = insert(node->lchild, value);
        }
    }
    return maintain(node, value > node->data);
}

template <typename Type>
SBTNode<Type>* SBTNode<Type>::search(Type value) {
    if (data == value) {
        return this;
    } else if (value > data) {
        if (rchild == NIL) {
            return NIL;
        } else {
            return rchild->search(value);
        }
    } else {
        if (lchild == NIL) {
            return NIL;
        } else {
            return lchild->search(value);
        }
    }
}

//寻找节点的前驱（前驱：比此节点小的最大的节点）
template <typename Type>
SBTNode<Type>* SBTNode<Type>::predecessor() {
    SBTNode<Type>* temp = lchild;
    while (temp != NIL && temp->rchild != NIL) {
        temp = temp->rchild;
    }
    return temp;
}

//寻找节点的后继（后继：比此节点大的最小的节点）
template <typename Type>
SBTNode<Type>* SBTNode<Type>::successor() {
    SBTNode<Type>* temp = rchild;
    while (temp != NIL && temp->lchild != NIL) {
        temp = temp->lchild;
    }
    return temp;
}

template <typename Type>
void SBTNode<Type>::remove_node(SBTNode<Type>* delete_node) {
    SBTNode<Type>* temp = NIL;
    if (delete_node->lchild != NIL) {
        temp = delete_node->lchild;
        temp->father = delete_node->father;
        delete_node->lchild = NIL;
    }
    if (delete_node->rchild != NIL) {
        temp = delete_node->rchild;
        temp->father = delete_node->father;
        delete_node->rchild = NIL;
    }
    if (delete_node->father->lchild == delete_node) {
        delete_node->father->lchild = temp;
    } else {
        delete_node->father->rchild = temp;
    }
    temp = delete_node;
    while (temp != NULL) {
        temp->size--;
        temp = temp->father;
    }
    delete delete_node;
}

template <typename Type>
bool SBTNode<Type>::remove(Type value) {
    SBTNode<Type> * delete_node, * current_node;
    current_node = search(value);
    if (current_node == NIL) {
        return false;
    }
    if (current_node->lchild != NIL) {
        delete_node = current_node->predecessor();
    } else if (current_node->rchild != NIL) {
        delete_node = current_node->successor();
    } else {
        delete_node = current_node;
    }
    current_node->data = delete_node->data;
    remove_node(delete_node);
    return true;
}
// 可在以下添加 SBTNode 的遍历方法
template <typename Type>
void SBTNode<Type>::print(){
    if (lchild != NIL) {
        lchild->print();
    }
     cout << data << " ";
    if (rchild != NIL) {
        rchild->print();
    }
}

template <typename Type>
BinaryTree<Type>::BinaryTree() {
    root = NULL;
}

template <typename Type>
BinaryTree<Type>::~BinaryTree() {
    delete root;
}

template <typename Type>
void BinaryTree<Type>::insert(Type value) {
    if (root == NULL) {
        root = new SBTNode<Type>(value, 1);
    } else if (root->search(value) == NIL) {
        root = ::insert(root, value);
    }
}

template <typename Type>
bool BinaryTree<Type>::find(Type value) {
    if (root->search(value) == NIL) {
        return false;
    } else {
       return true;
    }
}

template <typename Type>
bool BinaryTree<Type>::remove(Type value) {
    return root->remove(value);
}
// 可在以下添加 BinaryTree 遍历方法
template <typename Type>
void BinaryTree<Type>::print_() {
    if (root == NULL) {
        return;
    } else {
        root->print();
    }
}

int main() {
    BinaryTree<int> binarytree;
    int n;
    cin >> n;
    while (n--) {
        int val;
        cin >> val;
        binarytree.insert(val);
    }
    cin >> n;
    while (n--) {
        int val;
        cin >> val;
       if (binarytree.remove(val)) {
           cout << "delete success!" << endl;
       } else {
           cout << "delete failed!" << endl;
       }
    }
    binarytree.print_();
    return 0;
}
烛火寻途
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Size Blanced Tree(SB树)
xiaolu567的博客
06-19 397
任何一个叔叔节点拥有的节点数,不少于他自己的任何一个侄子节点 叔叔节点:对于左树的左右孩子节点,叔叔节点为右树节点,同理对于右树的左右孩子节点,叔叔节点为左树节点,即叔叔节点为父亲节点的兄弟节点在调整过程中,哪个节点更改了孩子就要对该节点进行调整与AVL树第一步相同,先对顶部节点右旋 在右旋过程中,a和b节点的孩子会发生改变,因此递归调用maintain(a)和maintain(b) 如图,在左旋过程中,a和c的孩子节点发生改变,因此递归调用maintain(a)和maintain© 在调整过程中,e,b
SB Tree（Size Blanced Tree）优化——有序分数
m0_60738889的博客
03-16 342
题目来源：https://www.acwing.com/problem/content/1362/
重学数据结构系列之——平衡树之SB Tree（Size Blanced Tree）
weixin_33800593的博客
07-03 191
学习来源：计蒜客 平衡树 1.定义 对于每一个结点。左右两个子树的高度差的绝对值不超过1，或者叫深度差不超过1 为什么会出现这样一种树呢？ 假如我们依照1-n的顺序插入到二叉排序树中，那么二叉排序树就退化成了一个有序链表，效率大大减少。 2.有关概念 全部平衡树基本由下面三个特征组成： 1.自平衡条件 2.旋转操作 3.旋转的...
JAVA对SBTree（size blanced tree）的实现尝试
caocaocaocaocaonima的专栏
02-14 580
尽管不明白用java写数据结构的好处究竟有多大，但是了解了SBTree之后我就想尝试着去实现。最终做出了一个不规范的类似物。 希望大触们的意见！ 下面的是带着草稿的源码。 import java.util.ArrayList; public class SBTree>{     private double rate=0.60;     public int capacity=0;
竞赛最好用的平衡树-Size Balanced Tree（SBT）【建议收藏】
x0919的博客
10-24 2969
大家好。 前段时间我更新过AVL、红黑树以及搜索二叉树的简单讲解。今天我们还是围绕着平衡树的话题，来讲解一个很牛逼的平衡树结构。这种结构是我国的一位大牛：陈启峰。在2006年，他还在读高中阶段，所发明的一种平衡树结构，叫Size Balanced Tree（SBT），根据节点的个数，来调整平衡性。一直到今天，这种平衡树结构，在算法竞赛领域是非常常用的，虽然SBT的时间复杂度跟AVL、红黑树这些平衡树一样，但是SBT是比较好写，比较好改的。所以在算法竞赛时，是最常用的一种算法。陈启峰SBT论文（译） 本期文章
Size Balanced Tree（SBT）平衡二叉树
Eason的博客
12-05 2634
const int N = 210005; const int INF=0x7FFFFFFF; struct SBT { int key,left,right,size; } tree[N]; int root,top; void init(){ root=top=0; } /////以下函数x参数带root void left_rot(int &x) { int y
登峰造极之树——Size_Blanced_Tree萌新入门教程
Holylight_Knight
08-28 508
先前的博文：旧版SBT教程 洛谷P3369是道模板题，我在洛谷P3369中详细的写了一个题解，这里就直接copy来了。当时写的时候把zig，zag表示的旋转方向弄反了，大家将就这看吧。大家自己打的时候就把zig改成left_rotate,把zag改成right_rotate。 184ms / 3.15MB 代码：2.61KB C++11 时空以及编程复杂度都还好吧= =，大
Tree, priority queue and BST (python)
whyymlm的博客
07-22 253
一.建立树结构： 在自定义的二叉树内，我们需要保存当前节点的值，其左子树和其右子树。同时还需定义插入函数，注意插入函数定义时需要考虑是否当前节点已经有了左子树或右子树，若已经存在，则应该在插入新节点后接上原子树。 class BinaryTree: def __init__(self, root):# initialization self.key = root ...
重学数据结构系列之——总结
giantbranch的专栏
04-25 1414
重学数据结构系列之链接汇总： 重学数据结构系列之——八大排序算法 http://blog.csdn.net/u012763794/article/details/51189364 重学数据结构系列之——静态查找表查找算法  http://blog.csdn.net/u012763794/article/details/51180845 重学数据结构系列之——图论算法之Dijkstra算法
数据结构(5.3_3)——由遍历序列构造二叉树
m0_65240792的博客
07-25 103
若只给出一棵二叉树的前/中/后/层 序遍历序列中的一种，不能唯一确定一棵二叉树 例：前序遍历序列：DAEFBCHGI 中序遍历序列：DAEFBCHGI
学习记录day19——数据结构 查找算法
weixin_64918301的博客
07-25 188
在给定数据元素的某个值，在查找表中确定一个其关键字等于给定值的数据元素的操作，叫做查找。
【数据结构】单链表的增删改查
最新发布
2302_78914800的博客
07-25 651
链表是有序的列表，但是它在内存中是如下存储的：①链表以节点的方式进行存储，是链式存储的②每个节点包含 data 域、next 域：指向下一节点③链表的各个节点不一定是连续存放的④链表分为有头节点的链表和没有头节点的链表head节点1.不存放具体数据2.作用就是表示单链表头。
数据结构之初始二叉树（4）
我要学编程的博客
07-22 1220
二叉树的前序遍历、二叉树的层序遍历、根据二叉树的前序和中序遍历构造二叉树、二叉树的最近公共祖先、根据二叉树创建字符串
数据结构---二叉树
weixin_47808575的博客
07-22 271
参考：二叉树遍历方法——前、中、后序遍历（图解）_二叉树遍历前序中序后序-CSDN博客
重生之“我打数据结构，真的假的？”--3.栈和队列
2301_80374809的博客
07-21 701
栈：一种特殊的线性表，其只允许在进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守LIFO（Last In First Out）的原则。
数据结构~~顺序表
TU^的博客
07-22 886
定义：顺序表是用一组连续的存储单元依次存储数据元素的线性结构。特点：1. 逻辑顺序与物理顺序一致：元素顺序存储，相邻元素物理位置相邻。2. 可以快速访问任意元素：通过索引直接访问元素。优点：1. 实现简单。2. 随机访问方便。缺点：1. 插入、删除操作可能需要移动大量元素，效率较低。2. 需要预先确定固定的存储空间，可能造成空间浪费或不足。基本操作：包括初始化、插入、删除、查找、遍历等。
【数据结构】搜索二叉树
dab112的博客
07-24 1037
介绍了二叉搜索树的实现与模拟
数据结构：顺序表的实现
2303_81073778的博客
07-25 108
3.test.c文件。
【数据结构-前缀和】力扣2550.统计范围内的元音字符串数
sjsjs11的博客
07-22 439
计算前缀和数组的时间是 O(n)，然后计算 q 个查询的答案，计算每个查询的答案的时间是 O(1)，因此时间复杂度是 O(n+q)。输入：words = [“aba”,“bcb”,“ece”,“aa”,“e”], queries = [[0,2],[1,4],[1,1]]输入：words = [“a”,“e”,“i”], queries = [[0,2],[0,1],[2,2]]查询 [1,4] 结果为 3（字符串 “ece”、“aa”、“e”）。返回结果 [2,3,0]。输出：[3,2,1]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值