替罪羊树学习总结

写在前面：

我们知道，一般的平衡树都依赖于旋转操作，如 Treap，Splay，SBT 等，它们都需要用到旋转操作来保持树的平衡。旋转操作在统计一些可以快速合并的信息的时候是没有问题的，但对于更加复杂的信息，就会遇到复杂度的问题。考虑一个简单的例子，我们想在一个平衡树的每个节点上维护一个集合，存储子树内所有的数。此时一次旋转操作的代价可能会达到 O(n) ，传统的旋转平衡树就无法发挥作用了。而重量平衡树则不同，它每次操作影响的最大子树的大小是最坏或者均摊或者期望的O(log n) 。这样即使按照上面所说的方式维护，复杂度也是可以接受的。替罪羊树就是重量平衡树中比较常用的一种，与其他数据结构相比，它的优点有：

①：思维难度小，和其他平衡树的思维难度差不多；

②：代码量少，思路清晰，实现简单，容易调试；

③：速度不慢；

④：不是旋转机制；

替罪羊树：

替罪羊树是一种依赖于暴力重构操作的平衡树。我们定义一个平衡树因子α ，对替罪羊树的每个节点t ，我们都需要满足：max（size l,size r）<=α*szie t其中l,r 分别是t 的左右子树。这个性质称为平衡性质。它的实现方式也非常简洁明了，每次我们进行普通 BST 的插入操作后，都要在这条插入的路径上，寻找最高的（深度最小）不满足平衡性质的节点，（如果有不满足平衡性质节点的话）我们将这个节点以及它的子树内所有节点，暴力重构成一棵完全二叉树。其余操作全部与普通 BST 无异。

简单吧，替罪羊树，下面是替罪羊树，来排序的代码；

代码：

#include <cstdio>
#include <iostream>
#include <cmath>
#include <algorithm>
#define ll long long
using namespace std ;
ll read()
{
    ll x=0,f=1;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
int q[200005],top;
int id,rt,cnt;
int t,n,ans;
int v[200005],ls[200005],rs[200005],size[200005],fa[200005];
// ls  zuo er zi, rs you er zi,size jie dian de er zi ge shu,fa jie dian de fu qing;
//rt geng jie dian ,q chong jian shu de ling shi shu zu
int insert(int &k,int x,int f)
{
    if(!k)
    {
        k=++cnt;
        size[k]=1;
        fa[k]=f;
        return k;
    }
    if(x<v[k])insert(ls[k],x,k);
    else insert(rs[k],x,k);
    if(max(size[ls[k]],size[rs[k]])>size[k]*0.7)id=k;
    size[k]=size[ls[k]]+size[rs[k]]+1;
    return k;
}
void build(int &k,int l,int r)
{
    if(l>r) return ;
    int mid = (l+r)>>1;
    k=q[mid];
    build(ls[k],l,mid-1);
    build(rs[k],mid+1,r);
    fa[ls[k]]=fa[rs[k]]=k;
    size[k]=size[ls[k]]+size[rs[k]]+1;
}
void dfs(int x)
{
    if(!x) return ;
    dfs(ls[x]);
    q[++top]=x;
    dfs(rs[x]);
}
void solve(int x)
{
    int pre = fa[x];
    dfs(x);
    for(int i=1;i<=top;i++)
    {
     size[q[i]]=fa[q[i]]=ls[q[i]]=rs[q[i]]=0;
    }
    if(!pre) build(rt,1,top);
    else if(ls[pre]==x) build(ls[pre],1,top);
    else build(rs[pre],1,top);
    fa[ls[pre]]=fa[rs[pre]]=pre;
    top=id=0;
}
int main()
{
n=read();
for(int i=1;i<=n;i++)
{
    v[i]=read();
    insert(rt,v[i],0);
    if(id)
        solve(id);
}
dfs(rt);
for(int i=1;i<=n;i++)
    printf("%d ",v[q[i]]);
return 0;
}

对于题目的要求，我们可以对α做一点文章，比如说

α越小，树越稠密，插入效率低，查询效率高；

α越大，树越稀疏，插入效率高，查询效率低；

做题时就可以根据题目查询与插入个数的多数，选择α；

当然替罪羊树也有缺点：

替罪羊树由于其平衡机制的限制，并不能支持一些复杂的操作，比如常用 Splay 来处理的提取区间的操作。同时由于它是一个用势能来分析的均摊结构，也无法简单的进行可持久化。