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

最新推荐文章于 2018-11-07 16:57:17 发布
最新推荐文章于 2018-11-07 16:57:17 发布
阅读量626 收藏
点赞数
分类专栏： 算法 C++ 文章标签： c++ 算法
C++ 同时被 2 个专栏收录
202 篇文章 4 订阅
订阅专栏
算法
73 篇文章 7 订阅
订阅专栏

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

http://blog.csdn.net/sprintfwater/article/details/8316268

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

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

[cpp]  view plain copy print ?
  1. // =============================================================================  
  2. //   
  3. //       Filename:  size_balanced_tree.h  
  4. //   
  5. //    Description:  Size Balanced Tree  
  6. //   
  7. //        Version:  1.1  
  8. //        Created:  03/29/2012 01:00:29 PM  
  9. //       Revision:  none  
  10. //       Compiler:  g++  
  11. //   
  12. //         Author:  SphinX (Whisper), topcodersphinx@gmail.com  
  13. //        Company:  HFUT  
  14. //   
  15. // =============================================================================  
  16.   
  17. #ifndef SIZE_BALANCED_TREE  
  18. #define SIZE_BALANCED_TREE  
  19.   
  20. #include <iostream>  
  21. #include <cstring>  
  22. #include "dsexceptions.h"  
  23. using std::cout;  
  24. using std::endl;  
  25.   
  26. template <typename T>  
  27. class SizeBalancedTree  
  28. {  
  29.     private:  
  30.   
  31.         struct SizeBalancedNode  
  32.         {  
  33.             T element;  
  34.             SizeBalancedNode * left;  
  35.             SizeBalancedNode * right;  
  36.             int node_size;  
  37.   
  38.             SizeBalancedNode(const T & _element,   
  39.                     SizeBalancedNode * lt, SizeBalancedNode * rt, int sz = 1)  
  40.                 : element(_element), left(lt), right(rt), node_size(sz) {}  
  41.         };  
  42.   
  43.   
  44.     public:  
  45.   
  46.         SizeBalancedTree()  
  47.         {  
  48.             root = NULL;  
  49.             tree_size = 0;  
  50.         }  
  51.         SizeBalancedTree(SizeBalancedTree & rhs)  
  52.         {  
  53.             this->root = clone(rhs.root);  
  54.             this->tree_size = rhs.size();  
  55.         }  
  56.         ~SizeBalancedTree()  
  57.         {  
  58.             clear();  
  59.         }  
  60.   
  61.         const SizeBalancedTree & operator = (const SizeBalancedTree & rhs)  
  62.         {  
  63.             if (this != &rhs)  
  64.             {  
  65.                 this->clear();  
  66.                 this->root = clone(rhs.root);  
  67.                 this->tree_size = rhs.tree_size;  
  68.             }  
  69.             return (*this);  
  70.         }  
  71.   
  72.         int size() const  
  73.         {  
  74.             return tree_size;  
  75.         }  
  76.         bool empty() const  
  77.         {  
  78.             return size() == 0;  
  79.         }  
  80.         bool contains(const T & x) const  
  81.         {  
  82.             return contains(x, root);  
  83.         }  
  84.         const T & findMin() const  
  85.         {  
  86.             if (empty())  
  87.             {  
  88.                 throw UnderflowException();  
  89.             }  
  90.             return findMin(root)->element;  
  91.         }  
  92.         const T & findMax() const  
  93.         {  
  94.             if (empty())  
  95.             {  
  96.                 throw UnderflowException();  
  97.             }  
  98.             return findMax(root)->element;  
  99.         }  
  100.         int rank(const T & x) const  
  101.         {  
  102.             if (!contains(x))  
  103.             {  
  104.                 return -1;  
  105.             }  
  106.             return rank(x, root);  
  107.         }  
  108.         const T & select(int _rank) const  
  109.         {  
  110.             if (_rank < 0)  
  111.             {  
  112.                 throw UnderflowException();  
  113.             }  
  114.             if (_rank >= size())  
  115.             {  
  116.                 throw OverflowException();  
  117.             }  
  118.             return select(_rank, root)->element;  
  119.         }  
  120.         void showTree() const  
  121.         {  
  122.             showTree(root);  
  123.             return ;  
  124.         }  
  125.   
  126.         void clear()  
  127.         {  
  128.             clear(root);  
  129.             tree_size = 0;  
  130.             return ;  
  131.         }  
  132.         void insert(const T & x)  
  133.         {  
  134.             if (contains(x))  
  135.             {  
  136.                 return ;  
  137.             }  
  138.             ++tree_size;  
  139.             insert(x, root);  
  140.             return ;  
  141.         }  
  142.         void remove(const T & x)  
  143.         {  
  144.             if (!contains(x))  
  145.             {  
  146.                 return ;  
  147.             }  
  148.             --tree_size;  
  149.             remove(x, root);  
  150.             return ;  
  151.         }  
  152.   
  153.   
  154.     private:  
  155.   
  156.         SizeBalancedNode * root;  
  157.         int tree_size;  
  158.   
  159.         int getNodeSize(SizeBalancedNode * t) const  
  160.         {  
  161.             if (NULL == t)  
  162.             {  
  163.                 return 0;  
  164.             }  
  165.             return t->node_size;  
  166.         }  
  167.         bool contains(const T & x, SizeBalancedNode * t) const  
  168.         {  
  169.             while (t != NULL)  
  170.             {  
  171.                 if (x < t->element)  
  172.                 {  
  173.                     t = t->left;  
  174.                 }  
  175.                 else if (t->element < x)  
  176.                 {  
  177.                     t = t->right;  
  178.                 }  
  179.                 else  
  180.                 {  
  181.                     return true;  
  182.                 }  
  183.             }  
  184.             return false;  
  185.         }  
  186.         SizeBalancedNode * clone(SizeBalancedNode * t) const  
  187.         {  
  188.             if (NULL == t)  
  189.             {  
  190.                 return NULL;  
  191.             }  
  192.             return new SizeBalancedNode(t->element,   
  193.                 clone(t->left), clone(t->right));  
  194.         }  
  195.         SizeBalancedNode * findMin(SizeBalancedNode * t) const  
  196.         {  
  197.             if (t != NULL)  
  198.             {  
  199.                 while (t->left != NULL)  
  200.                 {  
  201.                     t = t->left;  
  202.                 }  
  203.             }  
  204.             return t;  
  205.         }  
  206.         SizeBalancedNode * findMax(SizeBalancedNode * t) const  
  207.         {  
  208.             if (t != NULL)  
  209.             {  
  210.                 while (t->right != NULL)  
  211.                 {  
  212.                     t = t->right;  
  213.                 }  
  214.             }  
  215.             return t;  
  216.         }  
  217.         int rank(const T & x, SizeBalancedNode * t) const  
  218.         {  
  219.             int _rank = 0;  
  220.             while (t != NULL)  
  221.             {  
  222.                 if (x < t->element)  
  223.                 {  
  224.                     t = t->left;  
  225.                 }  
  226.                 else if (t->element < x)  
  227.                 {  
  228.                     _rank += getNodeSize(t->left) + 1;  
  229.                     t = t->right;  
  230.                 }  
  231.                 else  
  232.                 {  
  233.                     _rank += getNodeSize(t->left);  
  234.                     break ;  
  235.                 }  
  236.             }  
  237.             return _rank;  
  238.         }  
  239.         SizeBalancedNode * select(int _rank, SizeBalancedNode * t) const  
  240.         {  
  241.             while (t != NULL)  
  242.             {  
  243.                 if (_rank < getNodeSize(t->left))  
  244.                 {  
  245.                     t = t->left;  
  246.                 }  
  247.                 else if (getNodeSize(t->left) < _rank)  
  248.                 {  
  249.                     _rank -= getNodeSize(t->left) + 1;  
  250.                     t = t->right;  
  251.                 }  
  252.                 else  
  253.                 {  
  254.                     break ;  
  255.                 }  
  256.             }  
  257.             return t;  
  258.         }  
  259.         void showTree(SizeBalancedNode * t) const  
  260.         {  
  261.             if (t != NULL)  
  262.             {  
  263.                 cout << "The element of this Node is " << t->element << endl;  
  264.                 if (t->left != NULL)  
  265.                 {  
  266.                     cout << "Walk into left child!" << endl;  
  267.                     showTree(t->left);  
  268.                     cout << "Walk back!" << endl;  
  269.                 }  
  270.                 cout << "The element of this Node is " << t->element << endl;  
  271.                 if (t->right != NULL)  
  272.                 {  
  273.                     cout << "Walk into right child!" << endl;  
  274.                     showTree(t->right);  
  275.                     cout << "Walk back!" << endl;  
  276.                 }  
  277.             }  
  278.             return ;  
  279.         }  
  280.   
  281.         void clear(SizeBalancedNode * & t)  
  282.         {  
  283.             if (t != NULL)  
  284.             {  
  285.                 clear(t->left);  
  286.                 clear(t->right);  
  287.                 delete t;  
  288.                 t = NULL;  
  289.             }  
  290.             return ;  
  291.         }  
  292.         void rotateWithLeft(SizeBalancedNode * & k2)  
  293.         {  
  294.             SizeBalancedNode * k1 = k2->left;  
  295.             k2->left = k1->right;  
  296.             k1->right = k2;  
  297.             k1->node_size = getNodeSize(k2);  
  298.             k2->node_size = getNodeSize(k2->left) + getNodeSize(k2->right) + 1;  
  299.             k2 = k1;  
  300.             return ;  
  301.         }  
  302.         void rotateWithRight(SizeBalancedNode * & k2)  
  303.         {  
  304.             SizeBalancedNode * k1 = k2->right;  
  305.             k2->right = k1->left;  
  306.             k1->left = k2;  
  307.             k1->node_size = getNodeSize(k2);  
  308.             k2->node_size = getNodeSize(k2->left) + getNodeSize(k2->right) + 1;  
  309.             k2 = k1;  
  310.             return ;  
  311.         }  
  312.         void doubleWithLeft(SizeBalancedNode * & t)  
  313.         {  
  314.             rotateWithRight(t->left);  
  315.             rotateWithLeft(t);  
  316.             return ;  
  317.         }  
  318.         void doubleWithRight(SizeBalancedNode * & t)  
  319.         {  
  320.             rotateWithLeft(t->right);  
  321.             rotateWithRight(t);  
  322.             return ;  
  323.         }  
  324.         void maintain(SizeBalancedNode * & t)   //Need to optimize...  
  325.         {  
  326.             if (t->left != NULL)  
  327.             {  
  328.                 if (getNodeSize(t->right) < getNodeSize(t->left->left))  
  329.                 {  
  330.                     rotateWithLeft(t);  
  331.                 }  
  332.                 else if (getNodeSize(t->right) < getNodeSize(t->left->right))  
  333.                 {  
  334.                     doubleWithLeft(t);  
  335.                 }  
  336.             }  
  337.             if (t->right != NULL)  
  338.             {  
  339.                 if (getNodeSize(t->left) < getNodeSize(t->right->right))  
  340.                 {  
  341.                     rotateWithRight(t);  
  342.                 }  
  343.                 else if (getNodeSize(t->left) < getNodeSize(t->right->left))  
  344.                 {  
  345.                     doubleWithRight(t);  
  346.                 }  
  347.             }  
  348.             if (t->left != NULL)  
  349.             {  
  350.                 maintain(t->left);  
  351.             }  
  352.             if (t->right != NULL)  
  353.             {  
  354.                 maintain(t->right);  
  355.             }  
  356.             return ;  
  357.         }  
  358.         void simpleInsert(const T & x, SizeBalancedNode * & t)  
  359.         {  
  360.             if (NULL == t)  
  361.             {  
  362.                 t = new SizeBalancedNode(x, NULL, NULL);  
  363.                 return ;  
  364.             }  
  365.             ++t->node_size;  
  366.             if (x < t->element)  
  367.             {  
  368.                 simpleInsert(x, t->left);  
  369.             }  
  370.             else if (t->element < x)  
  371.             {  
  372.                 simpleInsert(x, t->right);  
  373.             }  
  374.             return ;  
  375.         }  
  376.         void insert(const T & x, SizeBalancedNode * & t)  
  377.         {  
  378.             if (NULL == t)  
  379.             {  
  380.                 t = new SizeBalancedNode(x, NULL, NULL);  
  381.                 return ;  
  382.             }  
  383.             ++t->node_size;  
  384.             if (x < t->element)  
  385.             {  
  386.                 simpleInsert(x, t->left);  
  387.             }  
  388.             else if (t->element < x)  
  389.             {  
  390.                 simpleInsert(x, t->right);  
  391.             }  
  392.             else  
  393.             {  
  394.                 return ;  
  395.             }  
  396.             maintain(t);  
  397.             return ;  
  398.         }  
  399.         void remove(const T & x, SizeBalancedNode * & t)  
  400.         {  
  401.             if (NULL == t)  
  402.             {  
  403.                 return ;  
  404.             }  
  405.             --t->node_size;  
  406.             if (x < t->element)  
  407.             {  
  408.                 remove(x, t->left);  
  409.             }  
  410.             else if (t->element < x)  
  411.             {  
  412.                 remove(x, t->right);  
  413.             }  
  414.             else  
  415.             {  
  416.                 if (t->left != NULL && t->right != NULL)  
  417.                 {  
  418.                     if (getNodeSize(t->left) < getNodeSize(t->right))  
  419.                     {  
  420.                         t->element = findMin(t->right)->element;  
  421.                         remove(t->element, t->right);  
  422.                     }  
  423.                     else  
  424.                     {  
  425.                         t->element = findMax(t->left)->element;  
  426.                         remove(t->element, t->left);  
  427.                     }  
  428.                 }  
  429.                 else  
  430.                 {  
  431.                     SizeBalancedNode * oldNode = t;  
  432.                     t = ((t->left != NULL) ? t->left : t->right);  
  433.                     delete oldNode;  
  434.                     oldNode = NULL;  
  435.                 }  
  436.             }  
  437.             return ;  
  438.         }  
  439.   
  440. };  
  441. /* 
  442.  *template <typename T> 
  443.  *const typename SizeBalancedTree<T>::SizeBalancedNode *  SizeBalancedTree<T>::nil 
  444.  *     = new SizeBalancedTree<T>::SizeBalancedNode(T(), NULL, NULL, 0); 
  445.  */  
  446.   
  447. #endif  
zdy0_2004
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【学习笔记】SBT学习笔记
weixin_30892037的博客
05-05 916
[## 一、什么是SBT SBT , 即 Size Balanced Tree，是一种平衡二叉排序树，根据其节点中 Size 域大小进行平衡，由陈启峰于2006年在冬令营提出 二、为什么写SBT： 书写简单：在常用的平衡树（ Spaly , Treap , AVL , Red-Black Tree ……）中，SBT的码量较小，只是在原有 BST 的基础上加入 Maintain 函数以及对Si...
SBT模板(平衡树)
04-02
本模板为 BZOJ3224：文艺平衡树 的源程序 含各种操作，旋转，插入，删除，求前驱，后继，查询值为x的数的排名，查询排名为k的数，求最大值，最小值……
SBT和AVL的C++模板实现 最新版
04-11
SBT和AVL的C++模板实现，提供了与stl中的set类似接口，支持迭代器，并提供了set所不支持的动态顺序统计功能，内含参考手册。
SBT和AVL的C++模板实现
03-13
SBT和AVL的C++模板实现，提供了与stl中的set类似接口，支持迭代器，并提供了set所不支持的动态顺序统计功能，内含参考手册。
sbt.rar_SBT_Size Balanced Tree
09-22
SBT，全称为Size Balanced Tree，是一种特殊类型的自平衡二叉搜索树，设计用于高效地执行插入、查找和删除操作。这种数据结构在计算机科学中主要用于动态存储有序数据，尤其适用于需要频繁进行增删查改操作的应用...
10.陈启峰《Size Balanced Tree》.ppt
09-17
10.陈启峰《Size Balanced Tree》.ppt
balancedTree.zip_数据结构_Visual_C++_
08-11
在“balancedTree.zip”这个压缩包中，包含了一个名为“平衡2x树.cpp”的源代码文件，这很可能是用C++实现的平衡二叉树的示例程序。 平衡二叉树有多种类型，如AVL树和红黑树。AVL树是最早被提出的一种自平衡二叉...
Balanced-binary-tree.rar_Balanced Binary Tree
09-23
在本项目中，“Balanced-binary-tree.rar”是一个压缩包，包含了一个C++实现平衡二叉树的实例，对于学习C++编程以及理解数据结构的深度是很有帮助的。 平衡二叉树分为几种类型，如AVL树和红黑树。AVL树是最先被提出...
pinghen.rar_avl_avl tree_balanced tree_二叉树_平衡二叉树
09-24
平衡二叉树（Balanced Binary Tree）是一种特殊的二叉树数据结构，它的主要特性在于保持了树的高度平衡。这种平衡状态使得在二叉查找树（Binary Search Tree, BST）中的操作，如插入、删除和搜索等，都能在对数时间...
节点大小平衡树(（Size Balanced Tree, c++和python源码）
02-26
我自己写的SBTree的实现 参考了http://www.nocow.cn/index.php/Size_Balanced_Tree的算法 声明：此源码可以用于商业用途，但请注明来源于random
sbt从入门到半熟
beikexp的专栏
07-03 261
zt http://www.kaopua.com/blog/2012/02/03/1328280189872.html   SBT = (not so) Simple Build Tool,是scala的构建工具，与java的maven地位相同。其设计宗旨是让简单的项目可以简单的配置，而复杂的项目可以复杂的配置。。。 https://github.com/notyy/sbtTemplat...
一个使用sbt编译的JNI C 的模板
bcghgfr的博客
11-07 108
一个使用sbt编译的JNI C 的模板
一个使用sbt编译的JNI C++ 的模板
热门推荐
引路蜂移动软件
09-01 1万+
如果你需要在Scala或是Java中调用C或C++函数库，就需要使用JNI， 这里就涉及到编译scala ,java 和C(C++)代码，在这里给出一个程序的框架，我们使用sbt 缺省的代码目录文件目录src—>main——–>java——–>scala——–>c其中目录c存放C++代码 ，java目录放置Java代码， scala目录放置Scala代码项目组用来编译的相关文件为build.sbt
为什么要学习SBT？
齐梦星空
05-12 8059
SBT教程 前言   写这篇教程只针对新手，如果你已经有一定的通过SBT管理项目的经验的时候这篇教程可能已经不太适合你了。因为写的都是一些很基础的入门的东西。 SBT简介   为了文章结构完整，在这里把把能找到的一些sbt简介附上让大家看一下： sbt is a build tool for Scala, Java, and more. It requires Java 1.6...
Size Balanced Tree(SBT树)整理
weixin_30414245的博客
11-29 553
不想用treap和Splay，那就用SB树把，哈哈，其实它一点也SB，厉害着呢。 先膜拜一下作者陈启峰。Orz 以下内容由我搜集整理得来。 一、BST及其局限性 二叉查找树（Binary Search Tree），也称有序二叉树（ordered binary tree）,排序二叉树（sorted binary tree），是指一棵空树或者具有下列性质的二叉树： 1.若任意...
size balanced tree (平衡二叉树) ----- 傻X树----陈启峰论文
杨鑫newlife的专栏
11-05 4990
Size Balanced Tree(SBT)是一种平衡二叉查找树。它的论文由中国广东中山纪念中学的陈启峰于2006年底完成，并在Winter Camp 2007中发表。由于SBT的拼写很容易找到中文谐音，它常被中国的OIer们戏称为“傻X树”、“Super BT”等。但它的性能并不SB，编写起来也并不BT。恰恰相反，SBT易于实现，且据陈启峰论文中所言，“这是目前为止速度最快的高级二叉搜
【模板】SBT 普通平衡树
高斯的博客
11-24 2452
平衡树
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...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值