Size Balanced Tree(SBT) 类模板C++实现(持续更新)

最新推荐文章于 2023-02-15 21:00:59 发布
置顶 最新推荐文章于 2023-02-15 21:00:59 发布
阅读量3.4k 收藏
点赞数
分类专栏： ACM-数据结构 文章标签： tree c++ null insert compiler delete
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/codeforces_sphinx/article/details/7246783
版权

       Size Balanced Tree是OI神犇陈启峰发明的，据说是目前最高效的二叉查找树，搞了好长时间终于弄出来了～这个版本的SBT本来是打算用来实现STL的set的，所以树中不存在两个键值一样的元素，当然改成multiset那样的也不是很麻烦～原本按自己的理解想设计自底向上调整的SBT，结果最后发现这样的SBT有很大的问题最简单的例子就是如果插入的数据是单调有序的，那么显然这棵SBT就会严重倾向一侧，所以必须是自顶向下调整～这次写SBT模板收获很大^_^~大家要是发现bug请留言哈～

被虐。。。重写+debug。。。

// =============================================================================
// 
//       Filename:  size_balanced_tree.h
// 
//    Description:  Size Balanced Tree
// 
//        Version:  1.1
//        Created:  03/29/2012 01:00:29 PM
//       Revision:  none
//       Compiler:  g++
// 
//         Author:  SphinX (Whisper), topcodersphinx@gmail.com
//        Company:  HFUT
// 
// =============================================================================

#ifndef SIZE_BALANCED_TREE
#define SIZE_BALANCED_TREE

#include <iostream>
#include <cstring>
#include "dsexceptions.h"
using std::cout;
using std::endl;

template <typename T>
class SizeBalancedTree
{
    private:

        struct SizeBalancedNode
        {
            T element;
            SizeBalancedNode * left;
            SizeBalancedNode * right;
            int node_size;

            SizeBalancedNode(const T & _element, 
                    SizeBalancedNode * lt, SizeBalancedNode * rt, int sz = 1)
                : element(_element), left(lt), right(rt), node_size(sz) {}
        };


    public:

        SizeBalancedTree()
        {
            root = NULL;
            tree_size = 0;
        }
        SizeBalancedTree(SizeBalancedTree & rhs)
        {
            this->root = clone(rhs.root);
            this->tree_size = rhs.size();
        }
        ~SizeBalancedTree()
        {
            clear();
        }

        const SizeBalancedTree & operator = (const SizeBalancedTree & rhs)
        {
            if (this != &rhs)
            {
                this->clear();
                this->root = clone(rhs.root);
                this->tree_size = rhs.tree_size;
            }
            return (*this);
        }

        int size() const
        {
            return tree_size;
        }
        bool empty() const
        {
            return size() == 0;
        }
        bool contains(const T & x) const
        {
            return contains(x, root);
        }
        const T & findMin() const
        {
            if (empty())
            {
                throw UnderflowException();
            }
            return findMin(root)->element;
        }
        const T & findMax() const
        {
            if (empty())
            {
                throw UnderflowException();
            }
            return findMax(root)->element;
        }
        int rank(const T & x) const
        {
            if (!contains(x))
            {
                return -1;
            }
            return rank(x, root);
        }
        const T & select(int _rank) const
        {
            if (_rank < 0)
            {
                throw UnderflowException();
            }
            if (_rank >= size())
            {
                throw OverflowException();
            }
            return select(_rank, root)->element;
        }
        void showTree() const
        {
            showTree(root);
            return ;
        }

        void clear()
        {
            clear(root);
            tree_size = 0;
            return ;
        }
        void insert(const T & x)
        {
            if (contains(x))
            {
                return ;
            }
            ++tree_size;
            insert(x, root);
            return ;
        }
        void remove(const T & x)
        {
            if (!contains(x))
            {
                return ;
            }
            --tree_size;
            remove(x, root);
            return ;
        }


    private:

        SizeBalancedNode * root;
        int tree_size;

        int getNodeSize(SizeBalancedNode * t) const
        {
            if (NULL == t)
            {
                return 0;
            }
            return t->node_size;
        }
        bool contains(const T & x, SizeBalancedNode * t) const
        {
            while (t != NULL)
            {
                if (x < t->element)
                {
                    t = t->left;
                }
                else if (t->element < x)
                {
                    t = t->right;
                }
                else
                {
                    return true;
                }
            }
            return false;
        }
        SizeBalancedNode * clone(SizeBalancedNode * t) const
        {
            if (NULL == t)
            {
                return NULL;
            }
            return new SizeBalancedNode(t->element, 
                clone(t->left), clone(t->right));
        }
        SizeBalancedNode * findMin(SizeBalancedNode * t) const
        {
            if (t != NULL)
            {
                while (t->left != NULL)
                {
                    t = t->left;
                }
            }
            return t;
        }
        SizeBalancedNode * findMax(SizeBalancedNode * t) const
        {
            if (t != NULL)
            {
                while (t->right != NULL)
                {
                    t = t->right;
                }
            }
            return t;
        }
        int rank(const T & x, SizeBalancedNode * t) const
        {
            int _rank = 0;
            while (t != NULL)
            {
                if (x < t->element)
                {
                    t = t->left;
                }
                else if (t->element < x)
                {
                    _rank += getNodeSize(t->left) + 1;
                    t = t->right;
                }
                else
                {
                    _rank += getNodeSize(t->left);
                    break ;
                }
            }
            return _rank;
        }
        SizeBalancedNode * select(int _rank, SizeBalancedNode * t) const
        {
            while (t != NULL)
            {
                if (_rank < getNodeSize(t->left))
                {
                    t = t->left;
                }
                else if (getNodeSize(t->left) < _rank)
                {
                    _rank -= getNodeSize(t->left) + 1;
                    t = t->right;
                }
                else
                {
                    break ;
                }
            }
            return t;
        }
        void showTree(SizeBalancedNode * t) const
        {
            if (t != NULL)
            {
                cout << "The element of this Node is " << t->element << endl;
                if (t->left != NULL)
                {
                    cout << "Walk into left child!" << endl;
                    showTree(t->left);
                    cout << "Walk back!" << endl;
                }
                cout << "The element of this Node is " << t->element << endl;
                if (t->right != NULL)
                {
                    cout << "Walk into right child!" << endl;
                    showTree(t->right);
                    cout << "Walk back!" << endl;
                }
            }
            return ;
        }

        void clear(SizeBalancedNode * & t)
        {
            if (t != NULL)
            {
                clear(t->left);
                clear(t->right);
                delete t;
                t = NULL;
            }
            return ;
        }
        void rotateWithLeft(SizeBalancedNode * & k2)
        {
            SizeBalancedNode * k1 = k2->left;
            k2->left = k1->right;
            k1->right = k2;
            k1->node_size = getNodeSize(k2);
            k2->node_size = getNodeSize(k2->left) + getNodeSize(k2->right) + 1;
            k2 = k1;
            return ;
        }
        void rotateWithRight(SizeBalancedNode * & k2)
        {
            SizeBalancedNode * k1 = k2->right;
            k2->right = k1->left;
            k1->left = k2;
            k1->node_size = getNodeSize(k2);
            k2->node_size = getNodeSize(k2->left) + getNodeSize(k2->right) + 1;
            k2 = k1;
            return ;
        }
        void doubleWithLeft(SizeBalancedNode * & t)
        {
            rotateWithRight(t->left);
            rotateWithLeft(t);
            return ;
        }
        void doubleWithRight(SizeBalancedNode * & t)
        {
            rotateWithLeft(t->right);
            rotateWithRight(t);
            return ;
        }
        void maintain(SizeBalancedNode * & t)   //Need to optimize...
        {
            if (t->left != NULL)
            {
                if (getNodeSize(t->right) < getNodeSize(t->left->left))
                {
                    rotateWithLeft(t);
                }
                else if (getNodeSize(t->right) < getNodeSize(t->left->right))
                {
                    doubleWithLeft(t);
                }
            }
            if (t->right != NULL)
            {
                if (getNodeSize(t->left) < getNodeSize(t->right->right))
                {
                    rotateWithRight(t);
                }
                else if (getNodeSize(t->left) < getNodeSize(t->right->left))
                {
                    doubleWithRight(t);
                }
            }
            if (t->left != NULL)
            {
                maintain(t->left);
            }
            if (t->right != NULL)
            {
                maintain(t->right);
            }
            return ;
        }
        void simpleInsert(const T & x, SizeBalancedNode * & t)
        {
            if (NULL == t)
            {
                t = new SizeBalancedNode(x, NULL, NULL);
                return ;
            }
            ++t->node_size;
            if (x < t->element)
            {
                simpleInsert(x, t->left);
            }
            else if (t->element < x)
            {
                simpleInsert(x, t->right);
            }
            return ;
        }
        void insert(const T & x, SizeBalancedNode * & t)
        {
            if (NULL == t)
            {
                t = new SizeBalancedNode(x, NULL, NULL);
                return ;
            }
            ++t->node_size;
            if (x < t->element)
            {
                simpleInsert(x, t->left);
            }
            else if (t->element < x)
            {
                simpleInsert(x, t->right);
            }
            else
            {
                return ;
            }
            maintain(t);
            return ;
        }
        void remove(const T & x, SizeBalancedNode * & t)
        {
            if (NULL == t)
            {
                return ;
            }
            --t->node_size;
            if (x < t->element)
            {
                remove(x, t->left);
            }
            else if (t->element < x)
            {
                remove(x, t->right);
            }
            else
            {
                if (t->left != NULL && t->right != NULL)
                {
                    if (getNodeSize(t->left) < getNodeSize(t->right))
                    {
                        t->element = findMin(t->right)->element;
                        remove(t->element, t->right);
                    }
                    else
                    {
                        t->element = findMax(t->left)->element;
                        remove(t->element, t->left);
                    }
                }
                else
                {
                    SizeBalancedNode * oldNode = t;
                    t = ((t->left != NULL) ? t->left : t->right);
                    delete oldNode;
                    oldNode = NULL;
                }
            }
            return ;
        }

};
/*
 *template <typename T>
 *const typename SizeBalancedTree<T>::SizeBalancedNode *  SizeBalancedTree<T>::nil
 *     = new SizeBalancedTree<T>::SizeBalancedNode(T(), NULL, NULL, 0);
 */

#endif


codeforces_sphinx
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
sbt.rar_SBT_Size Balanced Tree
09-22
SBT算法的C实现，用于动态排序、查找、删除。亲测非常高效实用
竞赛最好用的平衡树-Size Balanced Tree（SBT）【建议收藏】
x0919的博客
10-24 2734
大家好。 前段时间我更新过AVL、红黑树以及搜索二叉树的简单讲解。今天我们还是围绕着平衡树的话题，来讲解一个很牛逼的平衡树结构。这种结构是我国的一位大牛：陈启峰。在2006年，他还在读高中阶段，所发明的一种平衡树结构，叫Size Balanced Tree（SBT），根据节点的个数，来调整平衡性。一直到今天，这种平衡树结构，在算法竞赛领域是非常常用的，虽然SBT的时间复杂度跟AVL、红黑树这些平衡树一样，但是SBT是比较好写，比较好改的。所以在算法竞赛时，是最常用的一种算法。陈启峰SBT论文（译） 本期文章
SizeBalancedTree C++实现
juggte的博客
04-01 1179
SBT SizeBalancedTree，SBT也是一种自平衡二叉搜索树，它的均摊时间复杂度不差于红黑树，实现起来比红黑树简单很多，它的旋转方式与AVL树一样，它的平衡条件靠的是每个节点的侄子节点不大于叔叔节点， 旋转的方式与AVL相同。 n1上的节点数量 和 n2上的节点数量 都不大于u2上的节点数量 n3上的节点数量 和 n4上的节点数量 都不大于u1上的节点数量 每个节点都符合以上条件就认为这棵树平衡。 SBT的特点 SBT在删除的时候，可以不用进行旋转调整树的高度，即使退化成链状也无所谓
有序表之SB树（Size Balanced Tree）
明朗晨光的专栏
02-15 946
1、SB树的失衡类型及失衡的调整方式 2、SB树的代码实现
SizeBalancedTrees
Darkside的博客
10-14 199
前言 BST一直都是卡常的领域，为了不被卡常，我们需要一个更平衡的BST，SizeBalanceTree就是不错的选择。 旋转 众所周知，平衡树分为两类，非旋平衡树和旋转平衡树， SizeBalanceTree是依靠旋转来保持平衡的。 左旋 左旋的意思就是把当前节点移到左边去，同时保持树的中序遍历不变，右旋也是同理(代码与左旋对称)，注意保持树的中序遍历不变是非常重要的，它决定了树的搜索性质是否变化； 右旋 代码 inline void Rotate(int &now,bool flag) {
SizeBalanceTree详解（含代码实现）
qq_56999918的博客
02-03 1591
+1.SBT树的概念及其相关性质 Size Balanced Tree(SBT)是一种平衡二叉查找树。它的论文由中国广东中山记念中学的陈启峰于2006年末完成，php 并在Winter Camp 2007中发表。因为SBT的拼写很容易找到中文谐音， 它常被中国的Oler们戏称为 “傻X树”、html “Super BT”等。但它的性能并不SB，编写起来也并不BT。偏偏相反，SBT易于实现，且据陈启峰论文中所言 ，node “这是目前为止速度最快的高级二叉搜索树”。它能在O(logn)的时间..
【学习笔记】SBT学习笔记
weixin_30892037的博客
05-05 871
[## 一、什么是SBT SBT , 即 Size Balanced Tree，是一种平衡二叉排序树，根据其节点中 Size 域大小进行平衡，由陈启峰于2006年在冬令营提出 二、为什么写SBT： 书写简单：在常用的平衡树（ Spaly , Treap , AVL , Red-Black Tree ……）中，SBT的码量较小，只是在原有 BST 的基础上加入 Maintain 函数以及对Si...
【平衡树总结 Ⅱ】【SBT】Size Balanced Tree | E
Keyu Tian's blog
03-29 729
今天来种一种个人最喜欢的SBTree Size Balanced Tree，顾名思义是尽量维护子树大小（结点个数）平衡的树。 也就是当左右子树失衡（某个结点的size比它兄弟的孩子的size都要小）时就得进行旋转操作，来使子树的size始终保持在一个较为平衡的状态。 自平衡操作 SBT的自平衡维护比较简单，只有两种旋转操作而且是最基本的选择操作：简单左旋和简单右旋： 例题&...
10.陈启峰《Size Balanced Tree》.ppt
09-17
10.陈启峰《Size Balanced Tree》.ppt
SBT和AVL的C++模板实现 最新版
04-11
SBT和AVL的C++模板实现，提供了与stl中的set类似接口，支持迭代器，并提供了set所不支持的动态顺序统计功能，内含参考手册。
SBT模板(平衡树)
04-02
本模板为 BZOJ3224：文艺平衡树 的源程序 含各种操作，旋转，插入，删除，求前驱，后继，查询值为x的数的排名，查询排名为k的数，求最大值，最小值……
节点大小平衡树(（Size Balanced Tree, c++和python源码）
02-26
我自己写的SBTree的实现 参考了http://www.nocow.cn/index.php/Size_Balanced_Tree的算法 声明：此源码可以用于商业用途，但请注明来源于random
SBT和AVL的C++模板实现
03-13
SBT和AVL的C++模板实现，提供了与stl中的set类似接口，支持迭代器，并提供了set所不支持的动态顺序统计功能，内含参考手册。
陈启峰《Size Balanced Tree》 pdf英文版
02-07
“Size Balanced Tree (abbr. SBT) 是一种通过大小来保持平衡的BST。” SBT资料——陈启峰本人 pdf英文版 若需参考更多资料，请下载“陈启峰《Size Balanced Tree》 ppt中文版”
balancedTree.zip_数据结构_Visual_C++_
08-11
平衡二叉树的搭建与维护，构造与基本计算等方面的功能
Balanced-binary-tree.rar_Balanced Binary Tree
09-23
手动输入数据，加入到二叉树中，并生成平衡二叉树，对学习C++及数据结构有较大帮助
pinghen.rar_avl_avl tree_balanced tree_二叉树_平衡二叉树
09-24
平衡二叉树，又称为AVL树，是1962年由Adelsonr Velskii 和Landis 提出并以他们的名字命名的，它是具有如下性质的二叉树：
Size Balanced Tree(SBT树)整理
weixin_30414245的博客
11-29 536
不想用treap和Splay，那就用SB树把，哈哈，其实它一点也SB，厉害着呢。 先膜拜一下作者陈启峰。Orz 以下内容由我搜集整理得来。 一、BST及其局限性 二叉查找树（Binary Search Tree），也称有序二叉树（ordered binary tree）,排序二叉树（sorted binary tree），是指一棵空树或者具有下列性质的二叉树： 1.若任意...
java实现SizeBalancedTree大小平衡树（附完整源码）
最新发布
05-26
以下是Java实现SizeBalancedTree的完整源码： ```java import java.util.Random; public class SizeBalancedTree { private static final int MAXN = 100005; private static final Random random = new Random...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值