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

最新推荐文章于 2024-07-20 18:10:49 发布
最新推荐文章于 2024-07-20 18:10:49 发布
阅读量629 收藏
点赞数
分类专栏： 算法 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
    评论
专栏目录
节点大小平衡树(（Size Balanced Tree, c++和python源码）
02-26
我自己写的SBTree的实现 参考了http://www.nocow.cn/index.php/Size_Balanced_Tree的算法 声明：此源码可以用于商业用途，但请注明来源于random
SBT和AVL的C++模板实现 最新版
04-11
SBT和AVL的C++模板实现，提供了与stl中的set类似接口，支持迭代器，并提供了set所不支持的动态顺序统计功能，内含参考手册。
Size Balanced Tree模板
wh2124335的专栏
10-11 599
#include #include #include using namespace std; const int maxn = 100001; int key[maxn],chd[maxn][2],siz[maxn],root,top; int new_node(int e,int s=1){ key[top]=e; chd[top][0]=chd[top][1]=0; siz[top]=
一个使用sbt编译的JNI C 的模板
bcghgfr的博客
11-07 110
一个使用sbt编译的JNI C 的模板
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）中的操作，如插入、删除和搜索等，都能在对数时间...
SBT模板(平衡树)
04-02
本模板为 BZOJ3224：文艺平衡树 的源程序 含各种操作，旋转，插入，删除，求前驱，后继，查询值为x的数的排名，查询排名为k的数，求最大值，最小值……
SBT和AVL的C++模板实现
03-13
SBT和AVL的C++模板实现，提供了与stl中的set类似接口，支持迭代器，并提供了set所不支持的动态顺序统计功能，内含参考手册。
一个使用sbt编译的JNI C++ 的模板
weixin_33913332的博客
06-18 103
假设你须要在Scala或是Java中调用C或C++函数库，就须要使用JNI。 这里就涉及到编译scala ,java 和C(C++)代码，在这里给出一个程序的框架，我们使用sbt 缺省的代码文件夹文件文件夹src—&gt;main——–&gt;java——–&gt;scala——–&gt;c当中文件夹c存放C++代码 ，java文件夹放置Java代码， scala文件夹放置Scala代码项目组...
【学习笔记】SBT学习笔记
weixin_30892037的博客
05-05 922
[## 一、什么是SBT SBT , 即 Size Balanced Tree，是一种平衡二叉排序树，根据其节点中 Size 域大小进行平衡，由陈启峰于2006年在冬令营提出 二、为什么写SBT： 书写简单：在常用的平衡树（ Spaly , Treap , AVL , Red-Black Tree ……）中，SBT的码量较小，只是在原有 BST 的基础上加入 Maintain 函数以及对Si...
有序表之SizeBalanceTree
Harrison的学习博客
04-04 652
SB树的平衡标准 任何以叔叔结点的为头的子树的结点个数不小于任何一个以自己侄子为头结点的子树的结点个数。
【模板】SBT 普通平衡树
高斯的博客
11-24 2459
平衡树
数据结构-SBT(Size Balanced Tree)
始往流离，终彼成章。
03-15 4438
/************************************************* 数据结构： SBT(Size Balanced Tree),又称傻逼树; 数据域： 值域key,左孩子left,右孩子right,保持平衡的size; 性质： 每棵子树的大小不小于其兄弟的子树大小; 插入： 插入算法先简单插入节点，然后调用一个维护过程以保持性质; 删除： 删除操作与普通维
C语言 之 理解指针（1）
最新发布
fallzzzzz的博客
07-20 1235
就是先获取该数组的首元素的地址，从前面我们知道，指针的类型的作用是指针+1 所跳过的字节数，int为整形，大小为4个字节，所以p+1就跳过4个字节，p+2就跳过8个字节，计算机的CPU（中央处理器）在处理数据的时候，需要的数据是在内存中读取的，处理后数据也会放回内存中，如果想对这些空间进行高效的管理，就可以。并且我们知道，数组的元素存放是随着下标增长，内存地址变大的。上面的代码创建了一个整型变量n，因为一个整形的大小是4个字节，所以内存中申请了4个字节，⽤于存放整数10，其中每个字节都有地址。
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、付费专栏及课程。

余额充值