平衡树的主要算法
发布网友
发布时间：2022-04-14 12:41
共2个回答
懂视网
时间：2022-04-14 17:02
一、2-3-4树介绍 2-3-4树是一种多叉树(multiway tree)，它的每个节点最多有四个子节点和3个数据项，2-3-4 树可以看做是阶为4 的B树。B树是另一种平衡的多叉树，专门用在外部存储中来组织数据(通常是指磁盘驱动器)。B树中的节点可以有几时或几百个。 2-3-4树
一、2-3-4树介绍
2-3-4树是一种多叉树(multiway tree)，它的每个节点最多有四个子节点和3个数据项，2-3-4 树可以看做是阶为4 的B树。B树是另一种平衡的多叉树，专门用在外部存储中来组织数据(通常是指磁盘驱动器)。B树中的节点可以有几时或几百个。
2-3-4树名字中的2、3、4的含义是指一个节点可能含有的子节点数。
有1个数据项的节点总是有2个子节点
有2个数据项的节点总是有3个子节点
有3个数据项的节点总是有4个子节点
简言之，非叶子节点的子节点数总是比它含有的数据项多1
在2-3-4树中不允许一个节点只有一个链接,这与传统的二叉树不同。
二、B树、B+树
二叉树提供了良好的性能，但是当数据有序插入时会失去平衡，2-3-4树和2-3树是一种平衡树,是多路的，而红-黑树（见上一篇文章）是一种二叉平衡树，通过严格的红黑规则保持平衡。B树是一种平衡的多路查找树，可以看做一种扩展的2-3-4树，它的数据项个数和子节点数没有限制(如果结点的元素数量非常多的话那就退化成节点内部的线性查找了)，在文件系统中有所应用，主要用作文件的索引。
B树插入节点要注意从子节点开始分裂,一直上溯到根
B+树是B树的一种变型
B+树中的非叶子节点不是最终指向文件内容的节点，而只是叶子节点中关键字的索引。所有的叶子节点包含了全部关键字的信息，且叶子节点本身依关键字自小而大顺序链接。所以任何关键字的查找都必须走一条从根节点到叶子节点的路(导致每一个数据的查询效率相当)。
总而言之，B 树在提高了磁盘IO 性能的同时并没有解决元素遍历效率低下的问题。正是为了解决这个问题，B+树应运而生。B+树只要遍历叶子节点就可以实现整棵树的遍历，支持基于范围的查询，而B树不支持range-query 这样的操作（或者说效率太低）。
通过以上介绍，大致将B 树，B+树，B*树总结如下：
● B 树：有序数组+平衡多叉树；
● B+树：有序数组链表+平衡多叉树；
● B*树：一棵丰满的B+树。
B树相关的参考资料http://www.2cto.com/database/201401/272612.html
热心网友
时间：2022-04-14 14:10
红黑树的平衡是在插入和删除的过程中取得的。对一个要插入的数据项，插入程序要检查不会破坏树一定的特征。如果破坏了，程序就会进行纠正，根据需要更改树的结构。通过维持树的特征，保持了树的平衡。
红黑树有两个特征：
(1) 节点都有颜色
(2) 在插入和删除过程中，要遵循保持这些颜色的不同排列的规则。
红黑规则：
1. 每一个节点不是红色的就是黑色的
2. 根总是黑色的
3. 如果节点是红色的，则它的子节点必须是黑色的（反之不一定成立）
4. 从根到叶节点或空子节点的每条路径，必须包含相同数目的黑色节点。
（空子节点是指非叶节点可以接子节点的位置。换句话说，就是一个有右子节点的节点可能接左子节点的位置，或是有左子节点的节点可能接右子节点的位置） AVL树，它或者是一颗空二叉树，或者是具有下列性质的二叉树：
(1) 其根的左右子树高度之差的绝对值不能超过1；
(2) 其根的左右子树都是二叉平衡树。
AVL树查找的时间复杂度为O(logN)，因为树一定是平衡的。但是由于插入或删除一个节点时需要扫描两趟树，依次向下查找插入点，依次向上平衡树，AVL树不如红黑树效率高，也不如红黑树常用。
AVL树插入的C++代码： template<classT>ResultCodeAVLTree<T>::Insert(AVLNode<T>*&p,T&x,bool&unBalanced)...{ResultCoderesult=Success;if(p==null)...{//插入新节点p=newAVLNode<T>(x);unBalanced=true;}elseif(x<p->element)...{//新节点插入左子树result=Insert(p->lChild,x,unBalanced);if(unBanlanced)...{switch(p->bF)...{case-1:p->bF=0;unBalanced=false;break;case0:p->bF=1;break;case1:LRotation(p,unBalanced);}}}elseif(x==p->element)...{//有重复元素，插入失败unBalanced=false;x=p->element;result=Duplicate;}else...{//新节点插入右子树result=Insert(p->rChild,x,unBalanced);if(unBalanced)...{switch(p->bF)...{case1:p->bF=0;unBalanced=false;break;case0:p->bF=-1;break;case-1:RRotation(p,unBalanced);}}}returnresult;}template<classT>voidAVLTree<T>::LRotation(AVLNode<T>*&s,bool&unBalanced)...{AVLNode<T>*u,*r=s->lChild;if(r->bF==1)...{//LL旋转s->lChild=r->rChild;r->rChild=s;s->bF=0;s=r;//s指示新子树的根}else...{//LR旋转u=r->rChild;r->rChild=u->lChild;u->lChild=r;s->lChild=u->rChild;u->rChild=s;switch(u->bF)...{case1:s->bF=-1;r->bF=0;break;case0:s->bF=r->bF=0;break;case-1:s->bF=0;r->bF=1;}s=u;//s指示新子树的根}s->bF=0;//s的平衡因子为0unBalanced=false;//结束重新平衡操作}通常我们使用二叉树的原因是它可以用O（logn）的复杂度来查找一个数，删除一个数，对吧？？可是有时候会发现树会退化，这个就可能使O（logn）->O（n）的了，那么还不如用直接搜一次呢！！所以我们就要想办法使一棵树平衡。而我仅仅看了（AVL）的那个，所以也仅仅能说（AVL）的那个，至于（TREAP），我还不懂，如果你们知道算法的话，欢迎告诉我~！谢谢~
首先引入一个变量，叫做平衡因子（r），节点X的r就表示x的左子树的深度-右子树的深度。然后我们要保证一棵树平衡，就是要保证左右子树的深度差小于等于1.所以r的取值能且仅能取0，-1，1.
其次，我要介绍旋转，旋转有两种方式，就是左旋（顺时针旋转）和右旋（逆时针旋转）。
左旋（左儿子代替根）：即用左儿子取代根，假设我们要旋转以X为根，LR分别为X的左右儿子，那么我们只需要把L的右儿子取代X的左儿子，然后把更新后的X赋值为L的右儿子，就可以了。
右旋（右儿子代替根）：即用右儿子取代根，假设我们要旋转以X为根，LR分别为X的左右儿子，那么我们只需要把R的左儿子取代X的右儿子，然后把更新后的X赋值为R的左儿子，就可以了。 Size Balanced Tree(SBT平衡树）是2007年Winter Camp上由我国著名OI选手陈启峰发布的他自己创造的数据结构。相比于一般的平衡树，此平衡树具有的特点是：快速（远超Treap，超过AVL)、代码简洁、空间小（是线段树的1/4左右）、便于调试和修改等优势。
与一般平衡搜索树相比，该数据结构只靠维护一个Size来保持树的平衡，通过核心操作Maintain(修复）使得树的修改平摊时间为O(1)。因而大大简化代码实现复杂度、提高运算速度。
参见百度百科SBT。 平衡树的一种，每次将待操作节点提到根，每次操作时间复杂度为O(logn)。见伸展树。 constintSPLAYmaxn=200005;constintSPLAYinf=100000000;structSplay_Node{intl,r,fa,v,sum;};structSplay{Splay_Nodet[SPLAYmaxn];introot,tot;voidcreate(){root=1,tot=2;t[1].v=-SPLAYinf;t[2].v=SPLAYinf;t[1].r=t[1].sum=2;t[2].fa=t[2].sum=1;}voipdate(intnow){t[now].sum=t[t[now].l].sum+t[t[now].r].sum+1;}voidleft(intnow){intfa=t[now].fa;t[now].fa=t[fa].fa;if(t[t[fa].fa].l==fa)t[t[fa].fa].l=now;if(t[t[fa].fa].r==fa)t[t[fa].fa].r=now;t[fa].fa=now;t[fa].r=t[now].l;t[t[now].l].fa=fa;t[now].l=fa;up(fa);}voidright(intnow){intfa=t[now].fa;t[now].fa=t[fa].fa;if(t[t[fa].fa].l==fa)t[t[fa].fa].l=now;if(t[t[fa].fa].r==fa)t[t[fa].fa].r=now;t[fa].fa=now;t[fa].l=t[now].r;t[t[now].r].fa=fa;t[now].r=fa;update(fa);}voidsplay(intnow,intFA=0){while(t[now].fa!=FA){intfa=t[now].fa;if(t[fa].fa==FA)if(t[fa].l==now)right(now);elseleft(now);elseif(t[t[fa].fa].l==fa)if(t[fa].l==now)right(fa),right(now);elseleft(now),right(now);elseif(t[fa].l==now)right(now),left(now);elseleft(fa),left(now);}update(now);if(!FA)root=now;}intlower_bound(intv){intans=0,la=0;for(intnow=root;now;){la=now;if(t[now].v>=v)ans=now,now=t[now].l;elsenow=t[now].r;}splay(la);returnans;}voidinsert(intv){for(intnow=root;;){++t[now].sum;if(t[now].v>=v)if(t[now].l)now=t[now].l;else{t[now].l=++tot;t[tot].sum=1;t[tot].fa=now;t[tot].v=v;splay(tot);return;}elseif(t[now].r)now=t[now].r;else{t[now].r=++tot;t[tot].sum=1;t[tot].fa=now;t[tot].v=v;splay(tot);return;}}}intget_lower(inta){splay(a);for(a=t[a].l;t[a].r;a=t[a].r);returna;}intget_upper(inta){splay(a);for(a=t[a].r;t[a].l;a=t[a].l);returna;}intget_rank(inta){splay(a);returnt[t[a].l].sum;}voiddel(intl,intr){l=get_lower(l);r=get_upper(r);splay(l);splay(r,l);t[r].l=0;update(r);update(l);}intget_kth(intk){++k;for(intnow=root;;){if(t[t[now].l].sum==k-1)returnnow;if(t[t[now].l].sum>=k)now=t[now].l;elsek-=t[t[now].l].sum+1,now=t[now].r;}}};
