重学数据结构系列之——平衡树之SB Tree（Size Blanced Tree）

最新推荐文章于 2023-02-15 21:00:59 发布
最新推荐文章于 2023-02-15 21:00:59 发布
阅读量216 收藏
点赞数
文章标签： 数据结构与算法

学习来源：计蒜客

平衡树

1.定义


对于每一个结点。左右两个子树的高度差的绝对值不超过1，或者叫深度差不超过1
为什么会出现这样一种树呢？

假如我们依照1-n的顺序插入到二叉排序树中，那么二叉排序树就退化成了一个有序链表，效率大大减少。



2.有关概念


全部平衡树基本由下面三个特征组成：

1.自平衡条件
2.旋转操作
3.旋转的触发

平衡树通过设置合理的自平衡条件，使得二叉排序树的查找、插入等操作的性能不至于退化到 O(n)O(n)，而且在进行二叉排序树的查找、插入等操作时进行推断。假设满足当中某个旋转的触发条件，则进行相应的旋转操作。


左旋和右旋：（我的理解）

左旋：右边的深度大于左边深度2以上，把它变成平衡树，叫左旋（由于要把右边的某些元素挪到左边）

右旋：左边的深度大于右边深度2以上，把它变成平衡树。叫右旋（由于要把左边的某些元素挪到右边）

多旋：1.先左旋后右旋 2.先右旋在左旋


SB Tree


这个事实上不是很熟悉，程序是计蒜客的。大概理解吧。做点笔记，只是凝视都是自己的理解

1.定义


他也是平衡树的一种。每一个结点所在子树的结点个数不小于其兄弟的两个孩子所在子树的结点个数。
还有SBTree 仅仅有在插入时才可能触发调整。

据说他有个能够查找第k小的元素这个特殊的特点,为什么会有这个特点呢。
首先说个概念： 树的大小：所含结点的个数， 还有的话SB Tree也是属于排序树
SB Tree的结点的数据结构中用size储存了以当前结点为根构成的树的大小，那么它的父亲就排在size+1位了。详细看代码更好理解

2.实现


以下没凝视的函数请看这个（二叉排序树）： http://blog.csdn.net/u012763794/article/details/50967631 
#include <iostream>

using namespace std;

class SBTNode {
public:
	//size:子树大小(就是以当前结点为根构成的树有多少结点)
	//data:权值。就是树上的结点储存的值
	//value:应该是暂时储存权值的
    int data, size, value;
    SBTNode * lchild, * rchild, * father;
	//构造函数，參数分别为 权值，以当前结点为根的树的大小，父亲结点
    SBTNode(int init_data, int init_size = 0, SBTNode * init_father = NULL);
    ~SBTNode();
	//以下依次是
	//二叉排序树的插入，搜索，找前驱，找后继，移除某个度为0或1的结点，移除某个权值的点。找出第k大的元素
    void insert(int value);
    SBTNode * search(int value);
    SBTNode * predecessor();
    SBTNode * successor();
    void remove_node(SBTNode * delete_node);
    bool remove(int value);
    int select(int k);
};

class BinaryTree {
private:
    SBTNode * root;
public:
    BinaryTree();
    ~BinaryTree();
	//以下依次是
	//二叉树的插入 查找 删除结点 找出第k大的树。都是以上面的结点类的函数为基础的
    void insert(int value);
    bool find(int value);
    bool remove(int value);
    int select(int k);
};

//这里搞了个权值为0的结点，避免在边界情况时对空指针（NULL）进行特判，所以将全部原本指向空指针的情况都改为指向一个 ZPTR，并将其 size 设置为 0，从而减少代码复杂度。
SBTNode ZERO(0);
SBTNode * ZPTR = &ZERO;

SBTNode::SBTNode(int init_data, int init_size, SBTNode * init_father) {
    data = init_data;
    size = init_size;
    lchild = ZPTR;
    rchild = ZPTR;
    father = init_father;
}

SBTNode::~SBTNode() {
    if (lchild != ZPTR) {
        delete lchild;
    }
    if (rchild != ZPTR) {
        delete rchild;
    }
}

//左旋：将右孩子变为“根结点”（当前子树的根结点）。右孩子的左孩子就变成原来的根结点的右孩子
//以下凝视中：node（原来的根结点）的右孩子用“根结点”来说
SBTNode * left_rotate(SBTNode * node) {
	//用temp保存“根结点”
    SBTNode * temp = node->rchild;
	//“根结点”的左孩子  变成node（原来的根结点）的右孩子
    node->rchild = temp->lchild;
	//更新“根结点”原来的左孩子的父亲为node（原来的根结点） 
    temp->lchild->father = node;
	//node（原来的根结点） 就变成“根结点”的左孩子
    temp->lchild = node;
	//“根结点”的父亲更新为node（原来的根结点）的父亲
    temp->father = node->father;
	//node（原来的根结点）的父亲更新为“根结点”
    node->father = temp;
	//“根结点”的大小更新为node（原来的根结点）的大小（这里的大小是以该结点为根构成的树的结点的个数）
    temp->size = node->size;
	//node（原来的根结点）的大小更新为 它左孩子和右孩子的大小再在上本身1
    node->size = node->lchild->size + node->rchild->size + 1;
	//返回左旋后的根结点
    return temp;
}

//右旋：将左孩子变为“根结点”（当前子树的根结点）。左孩子的右孩子就变成原来的根结点的左孩子
//以下凝视中：node（原来的根结点）的左孩子用“根结点”来说
//反正这里跟上差点儿相反
SBTNode * right_rotate(SBTNode * node) {
	//用temp保存“根结点”
    SBTNode * temp = node->lchild;
	//“根结点”的右孩子  变成node（原来的根结点）的左孩子
    node->lchild = temp->rchild;
	//更新“根结点”原来的右孩子的父亲为node（原来的根结点） 
    temp->rchild->father = node;
	//node（原来的根结点） 就变成“根结点”的右孩子
    temp->rchild = node;
	//“根结点”的父亲更新为node（原来的根结点）的父亲
    temp->father = node->father;
	//node（原来的根结点）的父亲更新为“根结点”
    node->father = temp;
	//“根结点”的大小更新为node（原来的根结点）的大小（这里的大小是以该结点为根构成的树的结点的个数）
    temp->size = node->size;
	//node（原来的根结点）的大小更新为 它左孩子和右孩子的大小再在上本身1
    node->size = node->lchild->size + node->rchild->size + 1;
	//返回右旋后的根结点
    return temp;
}

//利用上面的左右旋进行调整的函数
//flag为false：处理左子树更高的情况，否则处理右子树更高的情况
//node:要调整的子树的根结点
SBTNode * maintain(SBTNode * node, bool flag) {
	//左子树比右子树高（或者叫深度要深）
    if (flag == false) {
		//LL型：左子树的左子树的元素个数大于右子树的元素个数。应进行右旋
        if (node->lchild->lchild->size > node->rchild->size) {
			//右旋并更新子树的根结点
            node = right_rotate(node);
        }
		//LR型：左子树的右子树的元素个数大于右子树的元素个数
		//那么先对左子树进行左旋，就变成LL型。再右旋就可以
		else if (node->lchild->rchild->size > node->rchild->size) {
			//左旋并更新左子树的根结点
            node->lchild = left_rotate(node->lchild);
			//右旋并更新根节点
            node = right_rotate(node);
        } else {
			//说明平衡了，返回根节点
            return node;
        }
	//右子树比左子树高（或者叫深度要深）
    } else {
		//RR型：右子树的右子树的元素个数大于左子树的元素个数,应进行左旋
        if (node->rchild->rchild->size > node->lchild->size) {
			//左旋并更新根节点
            node = left_rotate(node);
        }
		//RL型: 右子树的左子树的元素个数大于左子树的元素个数
		//那么先对右子树进行右旋，变成RR型，在左旋就可以
		else if (node->rchild->lchild->size > node->lchild->size) {
			//右旋并更新左子树的根结点
            node->rchild = right_rotate(node->rchild);
			//左旋并更新根节点
            node = left_rotate(node);
        } else {
			//说明平衡了。返回根节点
            return node;
        }
    }
	//以下为递归调用。由于有时上面的调整过后。左子树和右子树的某个结点还是不平衡

	//递归调用，处理可能左子树的左子树高度更高的情况
	//false表示左子树较高
    node->lchild = maintain(node->lchild, false);
	//其右子树的右子树高度更高的情况
    node->rchild = maintain(node->rchild, true);
	//最后再对子树根结点的左右子树递归进行调整
    node = maintain(node, false);
    node = maintain(node, true);
	//返回调整后的子树的根结点
    return node;
}

SBTNode * insert(SBTNode * node, int value) {
    if (value == node->data) {
        return node;
    } else {
        node->size++;
        if (value > node->data) {
            if (node->rchild == ZPTR) {
                node->rchild = new SBTNode(value, 1, node);
            } else {
                node->rchild = insert(node->rchild, value);
            }
        } else {
            if (node->lchild == ZPTR) {
                node->lchild = new SBTNode(value, 1, node);
            } else {
                node->lchild = insert(node->lchild, value);
            }
        }
    }
    return maintain(node, value > node->data);
}

SBTNode * SBTNode::search(int value) {
    if (data == value) {
        return this;
    } else if (value > data) {
        if (rchild == ZPTR) {
            return ZPTR;
        } else {
            return rchild->search(value);
        }
    } else {
        if (lchild == ZPTR) {
            return ZPTR;
        } else {
            return lchild->search(value);
        }
    }
}

SBTNode * SBTNode::predecessor() {
    SBTNode * temp = lchild;
    while (temp != ZPTR && temp->rchild != ZPTR) {
        temp = temp->rchild;
    }
    return temp;
}

SBTNode * SBTNode::successor() {
    SBTNode * temp = rchild;
    while (temp != ZPTR && temp->lchild != ZPTR) {
        temp = temp->lchild;
    }
    return temp;
}

void SBTNode::remove_node(SBTNode * delete_node) {
    SBTNode * temp = ZPTR;
    if (delete_node->lchild != ZPTR) {
        temp = delete_node->lchild;
        temp->father = delete_node->father;
        delete_node->lchild = ZPTR;
    }

    if (delete_node->rchild != ZPTR) {
        temp = delete_node->rchild;
        temp->father = delete_node->father;
        delete_node->rchild = ZPTR;
    }
    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;
}

bool SBTNode::remove(int value) {
    SBTNode * delete_node, * current_node;
    current_node = search(value);
    if (current_node == ZPTR) {
        return false;
    }
    size--;
    if (current_node->lchild != ZPTR) {
        delete_node = current_node->predecessor();
    } else if (current_node->rchild != ZPTR) {
        delete_node = current_node->successor();
    } else {
        delete_node = current_node;
    }
    current_node->data = delete_node->data;
    remove_node(delete_node);
    return true;
}

int SBTNode::select(int k) {
    //rank表示当前结点在子树的排位
	int rank = lchild->size + 1;
	//若rank等于第k小的k。说明就是要找的值。直接返回权值就可以
	if (rank == k) {
		return data;
	}else if (k < rank) {
	//小于rank。就表明要找比当前结点更小的。就在左边查找
		return lchild->select(k);
	}else{
	//大于就在右边咯
		//这里为什么看k - rank呢。由于我们已经把前rank排除了。
		//相当于我们要在右子树（把他当做一颗新的树去查找），所以排位当然要减去rank了
		return rchild->select(k - rank);
	}
}

BinaryTree::BinaryTree() {
    root = NULL;
}

BinaryTree::~BinaryTree() {
    if (root != NULL) {
        delete root;
    }
}

void BinaryTree::insert(int value) {
    if (root == NULL) {
		//初始化时仅仅有根结点，所以子树大小为1
        root = new SBTNode(value, 1);
    } else {
        root = ::insert(root, value);
    }
}

bool BinaryTree::find(int value) {
    if (root->search(value) == NULL) {
        return false;
    } else {
       return true;
    }
}

bool BinaryTree::remove(int value) {
    return root->remove(value);
}

int BinaryTree::select(int k) {
    return root->select(k);
}

int main() {
    BinaryTree binarytree;
    int arr[10] = { 16, 9, 20, 3, 18, 15, 6, 30, 7, 25 };
    for (int i = 0; i < 10; i++) {
        binarytree.insert(arr[i]);
    }
	cout<<"请输入第k小的元素："<<endl;
    int k;
    cin >> k;
	cout<<endl<<"第"<<k<<"小的元素为："<<endl;
    cout << binarytree.select(k) << endl;
    return 0;
}


3.执行结果





weixin_33800593
关注
【数据结构】SBTree——平衡二叉排序树（C语言）
moX980的博客
07-29 484
1.平衡条件 uncle节点的节点个数大于等于自身节点个数 如39节点，左子树size = 0， 右子树的右子树size = 1， 所以39需要调整 2.旋转操作 左旋和右旋 见AVL树 3.旋转的触发 LL型(size[left[left[t]]] > size[right[t]]):首先对子树t执行右旋操作，旋转以后对t的右子树进行调整，之后再对子树t进行调整 LR型(size[right[left[t]]] > size[right[t]]):首先对t左子树执行左旋操作，再
SB tree （Size Balanced Tree）
SprintfWater的专栏
12-18 4428
转载：http://www.clarkok.com/blog/?p=347#more-347 采取网友建议，写一下SB Tree。 ============================================================================ 所谓SB，并不是傻X，而是Size Balanced的意思的。本人也比较建议使用，因为写起来比较简单。这
有序表之SB树（Size Balanced Tree）
最新发布
明朗晨光的专栏
02-15 1154
1、SB树的失衡类型及失衡的调整方式 2、SB树的代码实现
关于 SBTree
davied9的专栏
11-07 529
C# 实现的版本，但是添加了我自己需求的重复添加和准确删除的特性，所以跟标准的 Sized Balanced Tree 有区别，
[poj2142] 天平The Balance
Bill_Yang_2016的博客
01-03 651
题目描述现有一天平，质量为a和b的砝码，已知砝码数量不限且天平左右均可放砝码，现要求在天平上称出质量为c的物品。 编程求一种可行方案。要求：放置的砝码数量尽可能少；当砝码数量相同时，总质量尽可能少。输入格式输入数据有多组，每组占一行，从左到右分别为a,b,c。其中a!=b，a<=10000,b<=10000,c<=50000。输入数据以0 0 0终止。输出格式对应每组输入输出满足题目要求的两个数据
Sklearn库中Logistic Regression函数各个参数总结
热门推荐
Leo
09-08 2万+
  Logistics Regression参数名称 含义   函数调用形式 LogisticRegression(penalty='l2',dual=False,tol=1e-4,C=1.0,fit_intercept=True,intercept_scaling=1,class_weight=None,rando...
3，包头社保F5负载均衡器实施配置文档.doc
08-02
该文档描述了一个特定的网络拓扑结构，旨在实现F5 BIG-IP负载均衡器的透明部署。F5 BIG-IP设备以Active/Standby模式工作，即一台设备处于活动状态（Active），另一台设备作为备份（Standby）。这种配置的好处在于...
pion最简单webrtc例子
lqq_419的博客
06-09 8589
前言 pion是一个纯用golang写的开源webrtc项目，目前github上大部分webrtc开源都是使用c++写的。本人认为pion对于一个webrtc入门者来说golang的语法相对简单，你这样可以更好的关注webrtc协议。如果业务场景不是特别高，业务上只做sfu转发服务器的话，可以尝试用golang来做。 读这篇文章你需要稍微了解webrtc的协议。 例子 pion也有提供不少的例子，我这边写了一个我自认为最简单，只能接受一个流的例子。这个例子平铺直叙，走了一个完整的webrtc流程，需要配合前
SBTree树实现
sessos的博客
11-12 424
SBTree树实现 SBTree与AVL树具有相同的概念，也具有相同的操作，类似自平衡，旋转操作和旋转触发。SBTree严格遵守下列公式，如有违反，则需要通过相应的转置操作来达到平衡. 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[t]表示t结点所在的子树个数，...
SBTree:使用B +树优化字段的文档存储。 适配器支持内存和文件系统
05-12
SB树 使用B +树进行字段的快速文档存储。 适配器支持内存和文件系统 状态：优化，功能和稳定性正在进行中。 文档： : 该库的目标是提供一种在内存中或文件系统上快速存储基于文档的数据的方法。 它使用基于B + Tree结构的特定于字段的索引系统。 这样可以处理大量数据，并为它们建立索引，而无需将整个数据集保留在内存中。 大多数数据库使用B树（MongoDB，CouchDB）或B + Tree（InnoDB，MariaDB，MySQL）。 注意：默认情况下。 除明确排除的字段以外的所有内容都被索引。 嵌套对象也被索引。 提供了对唯一键的可选支持。 目录 常问问题 安装 npm install sbtree 发行说明 请参阅发行说明 用法 mkdir myproject cd myproject npm init npm install sbtree touch inde
节点大小平衡树(（Size Balanced Tree, c++和python源码）
02-26
我自己写的SBTree的实现 参考了http://www.nocow.cn/index.php/Size_Balanced_Tree的算法 声明：此源码可以用于商业用途，但请注明来源于random
Size Balance Tree（SBT模板整理）
weixin_30505225的博客
11-02 125
/* * tree[x].left 表示以 x 为节点的左儿子 * tree[x].right 表示以 x 为节点的右儿子 * tree[x].size 表示以 x 为根的节点的个数（大小） */ struct SBT { int key,left,right,size; } tree[10010]; int root = 0,top = 0;...
SB树
bllsll
09-21 1656
1.farey 序列（法里序列） POJ - 2478 题意： F2 = {1/2} F3 = {1/3, 1/2, 2/3} F4 = {1/4, 1/3, 1/2, 2/3, 3/4} F5 = {1/5, 1/4, 1/3, 2/5, 1/2, 3/5, 2/3, 3/4, 4/5} 问Fn有多少项 解法，可以看出来，Fn的解就是从2到n的欧拉函数的和 打个表求欧拉函数就行了，然后可
数据结构总结---树
steven_miao的专栏
07-04 1097
仅以此文纪念过往岁月 数据结构中，树是一种非常重要的数据结构，常见的树分为 1.二叉树    最常见的数据结构 2.红黑树 3.B树 4.vEB树 5.KD树
Size Blanced Tree(SB树)
xiaolu567的博客
06-19 421
任何一个叔叔节点拥有的节点数,不少于他自己的任何一个侄子节点 叔叔节点:对于左树的左右孩子节点,叔叔节点为右树节点,同理对于右树的左右孩子节点,叔叔节点为左树节点,即叔叔节点为父亲节点的兄弟节点在调整过程中,哪个节点更改了孩子就要对该节点进行调整与AVL树第一步相同,先对顶部节点右旋 在右旋过程中,a和b节点的孩子会发生改变,因此递归调用maintain(a)和maintain(b) 如图,在左旋过程中,a和c的孩子节点发生改变,因此递归调用maintain(a)和maintain© 在调整过程中,e,b
我的第一棵平衡树-SB树
ureaster的博客
11-07 2246
数组实现的SB树(而且竟然没有结构体) 功能就和普通的二茬查找树一样: insert: 插入元素 erase: 删除元素 pre: 查询一个元素的前驱 suc: 查询一个元素的后继 select: 返回第几小的元素的值 rank: 返回一个值的位置 除了maintain全部非递归实现,并且有assert(似乎并没有什么用) maintain写得不是很高效, 并且缺储存平衡树中元
【数据结构与算法】Size Balanced Tree（SBT）平衡二叉树
小哲的博客
11-02 1517
尺寸平衡树（SBT）平衡二叉树 原文链接大小平衡树（SBT）平衡二叉树 定义数据结构 struct SBT { int key,left,right,size; } tree[N]; 关键：存储值，左，右：左右子树，大小：保持平衡最终要的数据，表示子树的大小 SBT树的性质 定义一个节点X，同时满足下面两个条件 (a)、x.left.size &gt;= max(x.r...
SB tree——A temporal aggregation data structure
hcy19941229的专栏
05-17 479
refer to Incremental computation and maintenance of temporal aggregates    ,Jun Yang1, JenniferWidom2 ,VLDBJ 2003
SBTree的代码实现
qq_35975827的博客
07-31 477
计蒜课上面说SBTree说SBTree删除的时候不需要调整，所以删除我没有作调整。 具体为什么不需要作调整，我询问了一些大佬，大概是因为插入删除查找需要的平均时间复杂度是一样的。所以调不调都行。如果有哪位大佬有更详细的资料还望告诉一声，在此谢谢。 这里是AVLTree的实现和SBTree差不多，就是调整策略条件改改 #include &lt;stdlib.h&gt; #include &lt...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值