【学习笔记】两种非旋转平衡树在OI中的应用

最新推荐文章于 2023-09-18 21:42:28 发布
最新推荐文章于 2023-09-18 21:42:28 发布
阅读量540 收藏 1
点赞数
分类专栏： # 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lvzelong2014/article/details/84587686
版权

【学习笔记】两种非旋转平衡树在OI中的应用

前言

N O I P NOIP NOIP挂完之后打算把数据结构啃完（不包括 L C C , E T T , A V L , z y f LCC,ETT,AVL,zyf LCC,ETT,AVL,zyf等神仙数据结构），于是就开始学习非旋转的平衡树了。然后发现自己被旋转平衡树坑了好久。。非旋转的代码各种吊打旋转平衡树。。。。废话不多说，今天主要讨论的两种非旋转平衡树分别是fhqTreap和替罪羊树。

fhqTreap

非旋转 T r e a p Treap Treap，范浩强 T r e a p Treap Treap。
众所周知， T r e a p Treap Treap相当于是 H e a p + B s t Heap+Bst Heap+Bst
而 T r e a p Treap Treap的复杂度保证基于期望意义下树的深度不超过 O ( l o g n ) O(logn) O(logn)，而Treap采用旋转是为了满足堆的性质。
也就是说， T r e a p Treap Treap的旋转操作和复杂度并不直接挂钩，我们抛弃以前的旋转做法，考虑如何插入一个节点 n w nw nw。
一种神奇的思路是，把一棵树劈开，分成两棵树 l e f t , r i g h t left,right left,right，这两棵树中 v l e f t ≤ v n w &lt; v r i g h t v_{left}\le v_{nw}&lt;v_{right} vleft​≤vnw​<vright​。把一个节点看成一棵树，把这三棵树合并起来。
这就是FHQ著名的两个操作 S p l i t Split Split和 M e r g e Merge Merge

Split

假设当前节点为 p p p，插入节点的权值是 v v v,分两种情况。

  • v [ p ] ≤ v a l v[p]\le val v[p]≤val，此时当前节点以及整个左子树都要放 l e f t left left中，之后如果再有节点放入左子树，一定在当前节点的右边。
  • v [ p ] &gt; v a l v[p]&gt; val v[p]>val，此时当前节点以及整个右子树都要放 r i g h t right right中，之后如果再有节点放入右子树，一定在当前节点的左边。

基于这个思路，采用引用的方式可以得到如下代码。

void Split(int u, int &a, int &b, int x) {
    if(!u) return void(a = b = 0);
    if(val[u] <= x)
        a = u, Split(rs[u], rs[a], b, x);
    else 
        b = u, Split(ls[u], a, ls[b], x);
    Up(u);
}

核心操作1结束了。

Merge

类似左偏树的合并，不过采用启发式合并，因为 T r e a p Treap Treap是一个堆，而 S p l i t Split Split的过程保证了 M e r g e Merge Merge的顺序，所以合并的时候比较一下键值大小即可。

int Merge(int u, int v) {
    if(!u || !v) return u | v;
    if(key[u] < key[v]) return rs[u] = Merge(rs[u], v), Up(u), u;
    return ls[v] = Merge(u, ls[v]), Up(v), v;
}
剩下的

插入的时候劈成两棵树合并即可。

void Ins(int x) {
    int a = 0, b = 0; Get(x);
    Split(rt, a, b, x);
    a = Merge(a, nw);
    rt = Merge(a, b);
}

删除的时候劈成三棵树删除即可。

void Del(int x) {
    int a = 0, b = 0, c = 0;
    Split(rt, a, b, x);
    Split(a, a, c, x - 1);
    st[++tp] = c; 
    c = Merge(ls[c], rs[c]);
    a = Merge(a, c);
    rt = Merge(a, b);
}

查找第 k k k大就是在平衡树上二分。

int Kth(int p, int k) {
    for(;p;) {
    	if(sz[ls[p]] + 1 == k) return val[p];
    	sz[ls[p]] < k ? k -= sz[ls[p]] + 1, p = rs[p] : p = ls[p];
    }
}

查找排名，前驱和后继就是劈开之后找第 1 1 1大或者第 n n n大

void Rk(int x)  {
    int a = 0, b = 0;
    Split(rt, a, b, x - 1);
    printf("%d\n", sz[a] + 1);
    rt = Merge(a, b);
}
void Pre(int x) {
    int a = 0, b = 0;
    Split(rt, a, b, x - 1);
    printf("%d\n", Kth(a, sz[a]));
    rt = Merge(a, b);
}
void Nxt(int x) {
    int a = 0, b = 0;
    Split(rt, a, b, x);
    printf("%d\n", Kth(b, 1));
    rt = Merge(a, b);
}

都是平衡树的正常操作，非旋转 T r e a p Treap Treap直观容易理解，掌握了 M e r g e Merge Merge和 S p l i t Split Split之后可以快速提取出需要的树，然后就是按照题意模拟即可。

总代码

来自luogu3369

#include<bits/stdc++.h>
const int N = 1e5 + 10;
int ri() {
    char c = getchar(); int x = 0, f = 1; for(;c < '0' || c > '9'; c = getchar()) if(c == '-') f = -1;
    for(;c >= '0' && c <= '9'; c = getchar()) x = (x << 1) + (x << 3) - '0' + c; return x * f;
}
int sz[N], ls[N], rs[N], val[N], key[N], st[N], tp, tot, rt = 1, nw, se = 233;
int Rand() {return se = 1LL * se * 998244353 & 0x7fffffff;}
void Get(int k) {
    nw = tp ? st[tp--] : ++tot;
    sz[nw] = 1; val[nw] = k; key[nw] = Rand();
    ls[nw] = rs[nw] = 0;
}
void Up(int u) {sz[u] = sz[ls[u]] + sz[rs[u]] + 1;}
void Split(int u, int &a, int &b, int x) {
    if(!u) return void(a = b = 0);
    if(val[u] <= x)
        a = u, Split(rs[u], rs[a], b, x);
    else 
        b = u, Split(ls[u], a, ls[b], x);
    Up(u);
}
int Merge(int u, int v) {
    if(!u || !v) return u | v;
    if(key[u] < key[v]) return rs[u] = Merge(rs[u], v), Up(u), u;
    return ls[v] = Merge(u, ls[v]), Up(v), v;
}
int Kth(int p, int k) {
    for(;p;) {
    	if(sz[ls[p]] + 1 == k) return val[p];
    	sz[ls[p]] < k ? k -= sz[ls[p]] + 1, p = rs[p] : p = ls[p];
    }
}
void Rk(int x)  {
    int a = 0, b = 0;
    Split(rt, a, b, x - 1);
    printf("%d\n", sz[a] + 1);
    rt = Merge(a, b);
}
void Pre(int x) {
    int a = 0, b = 0;
    Split(rt, a, b, x - 1);
    printf("%d\n", Kth(a, sz[a]));
    rt = Merge(a, b);
}
void Nxt(int x) {
    int a = 0, b = 0;
    Split(rt, a, b, x);
    printf("%d\n", Kth(b, 1));
    rt = Merge(a, b);
}
void Ins(int x) {
    int a = 0, b = 0; Get(x);
    Split(rt, a, b, x);
    a = Merge(a, nw);
    rt = Merge(a, b);
}
void Del(int x) {
    int a = 0, b = 0, c = 0;
    Split(rt, a, b, x);
    Split(a, a, c, x - 1);
    st[++tp] = c; 
    c = Merge(ls[c], rs[c]);
    a = Merge(a, c);
    rt = Merge(a, b);
}
int main() {
    int n = ri(); Get(0x7fffffff); sz[1] = 0;
    for(;n--;) {
        int op = ri(), x = ri();
        if(op == 1) Ins(x);
        else if(op == 2) Del(x);
        else if(op == 3) Rk(x);
        else if(op == 4) printf("%d\n", Kth(rt, x));
        else if(op == 5) Pre(x);
        else Nxt(x);
    }
    return 0;
}

效率和旋转的基本相同。

应用

非旋转 T r e a p Treap Treap最牛逼的地方在于，它能够做到可持久化。
可持久化最重要的是函数式编程的思想。
考虑 S p l i t Split Split和 M e r g e Merge Merge的时候仅仅会接触到 O ( d ) O(d) O(d)个节点，所以每次切割的操作都新建这 O ( d ) O(d) O(d)个节点，把原来的信息保留，把劈开或合并之后的信息接上去就可以做到 O ( n l o g n ) O(nlogn) O(nlogn)得到所有版本的平衡树。

可持久化平衡树

来自luogu3835

#include<bits/stdc++.h>
const int N = 5e5 + 10;
int ri() {
    char c = getchar(); int x = 0, f = 1; for(;c < '0' || c > '9'; c = getchar()) if(c == '-') f = -1;
    for(;c >= '0' && c <= '9'; c = getchar()) x = (x << 1) + (x << 3) - '0' + c; return x * f;
}
int se = 703;
int Rand() {return se = (se * 998244353LL & 0x7fffffff);}
struct Node {
    int ls, rs, val, key, sz;
    void Init(int x) {
        ls = rs = 0; sz = 1;
        key = rand(); val = x;
    }
}t[N * 50];
int Rt[N * 50], cnt, tp, st[N * 50];
int Nw() {return tp ? st[tp--] : ++cnt;}
void Up(int p) {t[p].sz = t[t[p].ls].sz + t[t[p].rs].sz + 1;}
void Split(int p, int k, int &lt, int &rt) {
    if(!p) return void(lt = rt = 0);
    if(t[p].val <= k)
        t[lt = Nw()] = t[p], Split(t[p].rs, k, t[lt].rs, rt), Up(lt);
    else
        t[rt = Nw()] = t[p], Split(t[p].ls, k, lt, t[rt].ls), Up(rt);
}
int Merge(int u, int v) {
    if(!u || !v) return u | v;
    int np = Nw();
    if(t[u].key > t[v].key) 
        t[np] = t[u], t[np].rs = Merge(t[u].rs, v);
    else
        t[np] = t[v], t[np].ls = Merge(u, t[v].ls); 
    return Up(np), np;
}
int Get(int val) {
    int np = Nw();
    return t[np].Init(val), np;
}
void Ins(int &p, int val) {
    int a = 0, b = 0;
    Split(p, val, a, b);
    p = Merge(Merge(a, Get(val)), b);
}
void Del(int &p, int val) {
    int a = 0, b = 0, c = 0;
    Split(p, val, a, c);
    Split(a, val - 1, a, b);
    if(b) st[++tp] = b, b = Merge(t[b].ls, t[b].rs);
    p = Merge(Merge(a, b), c);
}
void Kth(int p, int k) {
    for(;p && t[t[p].ls].sz + 1 != k;)
        t[t[p].ls].sz < k ? k -= t[t[p].ls].sz + 1, p = t[p].rs : p = t[p].ls;
    printf("%d\n", t[p].val);
}
void Rk(int &p, int val) {
    int a = 0, b = 0;
    Split(p, val - 1, a, b);
    printf("%d\n", t[a].sz + 1);
    p = Merge(a, b);
}
void Pre(int &p, int val) {
    int a = 0, b = 0;
    Split(p, val - 1, a, b);
    a ? Kth(a, t[a].sz), 0 : puts("-2147483647");
    p = Merge(a, b);
}
void Nxt(int &p, int val) {
    int a = 0, b = 0;
    Split(p, val, a, b);
    b ? Kth(b, 1), 0 : puts("2147483647");
    p = Merge(a, b);
}
int main() {
    srand(time(NULL));
    int n = ri();
    for(int i = 1;i <= n; ++i) {
        int v = ri(), op = ri(), x = ri();
        Rt[i] = Rt[v];
        if(op == 1) Ins(Rt[i], x);
        else if(op == 2) Del(Rt[i], x);
        else if(op == 3) Rk(Rt[i], x);
        else if(op == 4) Kth(Rt[i], x);
        else if(op == 5) Pre(Rt[i], x);
        else Nxt(Rt[i], x);
    }
    return 0;
}

替罪羊树

暴力是最优美的！
替罪羊树就是基于暴力重构的一种数据结构。
定义一个平衡因子 α ∈ [ 0.6 , 0.8 ] \alpha \in [0.6, 0.8] α∈[0.6,0.8]，如果 m a x ( s z [ l ] , s z [ r ] ) ≥ s z [ u ] max (sz[l],sz[r]) \ge sz[u] max(sz[l],sz[r])≥sz[u]，就暴力重构以 u u u为根的子树。
这样子的均摊复杂度是 O ( n l o g n ) O(nlogn) O(nlogn)的

重构

类似 K D − T r e e KD-Tree KD−Tree

void Build(int &p, int L, int R) {
    if(L > R) return void(p = 0); 
    int m = L + R >> 1; p = st[m]; 
    Build(ls, L, m - 1); Build(rs, m + 1, R);
    Up(p);
}
void Dfs(int p) {
    if(ls) Dfs(ls);
    if(!t[p].del) st[++tp] = p;
    if(rs) Dfs(rs);
}
void Build(int &p) {tp = 0; Dfs(p); Build(p, 1, tp);}
插入

注意一下，插入一个节点可能会导致从某个点到根路径上一连串的节点不满足平衡，我们只需要修改深度最低的节点即可，也就是 r b rb rb节点的作用。

void Ins(int &p, int val) {
    if(!p) return t[p = ++cnt].Init(val);
    ++t[p].sz; ++t[p].cnt;
    val < t[p].val ? Ins(ls, val) : Ins(rs, val);
    if(t[p].cnt * A + 20 > std::max(t[ls].cnt, t[rs].cnt)) {
    	if(rb) Build(ls == rb ? ls : rs), rb = 0;
    }
    else rb = p;
}
int main() {
...
if(op == 1) Ins(rt, x), rb ? Build(rt), rb = 0 : 0;
...
}
删除

注意是惰性删除，额外开一个 d e l del del标记当前节点是否被删除。
注意及时这个节点被惰性删除，这棵树计算平衡因子仍然要用真正子树大小，所以要额外开一个 c n t cnt cnt来记录。

void Era(int p, int k) {
    for(int x;t[p].del || t[ls].sz + 1 != k;) {
        --t[p].sz;
        (x = t[ls].sz + !t[p].del) < k ? k -= x, p = rs : p = ls;
    }
    --t[p].sz; t[p].del = true;
}

其余操作和其他平衡树类似，不写了咕咕咕此处不再赘述。

总代码

来自luogu3369
什么？你问我平衡因子设多少？当然是三分数据啦
平衡因子一般设 0.75 0.75 0.75

#include<bits/stdc++.h>
#define ls t[p].lc
#define rs t[p].rc
const int N = 2e5 + 10;
const double A = 0.75;
int ri() {
    char c = getchar(); int x = 0, f = 1; for(;c < '0' || c > '9'; c = getchar()) if(c == '-') f  = -1;
    for(;c >= '0' && c <= '9'; c = getchar()) x = (x << 1) + (x << 3) - '0' + c; return x * f;
}
struct Node {
    int lc, rc, cnt, sz, val; bool del;
    void Init(int _val) {cnt = sz = 1; lc = rc = 0; del = false; val = _val;}
}t[N];
int st[N], tp, cnt, rt, rb;
void Up(int p) {t[p].sz = t[ls].sz + t[rs].sz + !t[p].del;}
void Build(int &p, int L, int R) {
    if(L > R) return void(p = 0); 
    int m = L + R >> 1; p = st[m]; 
    Build(ls, L, m - 1); Build(rs, m + 1, R);
    Up(p);
}
void Dfs(int p) {
    if(ls) Dfs(ls);
    if(!t[p].del) st[++tp] = p;
    if(rs) Dfs(rs);
}
void Build(int &p) {tp = 0; Dfs(p); Build(p, 1, tp);}
void Ins(int &p, int val) {
    if(!p) return t[p = ++cnt].Init(val);
    ++t[p].sz; ++t[p].cnt;
    val < t[p].val ? Ins(ls, val) : Ins(rs, val);
    if(t[p].cnt * A + 20 > std::max(t[ls].cnt, t[rs].cnt)) {
    	if(rb) Build(ls == rb ? ls : rs), rb = 0;
    }
    else rb = p;
}
int Rk(int p, int val) {
    int r = 1;
    for(;p;)
        t[p].val < val ? r += t[ls].sz + !t[p].del, p = rs : p = ls;
    return r;
}
int Kth(int p, int k) {
    for(int x;t[p].del || t[ls].sz + 1 != k;)
        (x = t[ls].sz + !t[p].del) < k ? k -= x, p = rs : p = ls;
    return t[p].val;
}
void Era(int p, int k) {
    for(int x;t[p].del || t[ls].sz + 1 != k;) {
        --t[p].sz;
        (x = t[ls].sz + !t[p].del) < k ? k -= x, p = rs : p = ls;
    }
    --t[p].sz; t[p].del = true;
}
int main() {
    int n = ri();
    for(;n--;) {
        int op = ri(), x = ri();
        if(op == 1) Ins(rt, x), rb ? Build(rt), rb = 0 : 0;
        else if(op == 2) Era(rt, Rk(rt, x));
        else if(op == 3) printf("%d\n", Rk(rt, x));
        else if(op == 4) printf("%d\n", Kth(rt, x));
        else if(op == 5) printf("%d\n", Kth(rt, Rk(rt, x) - 1));
        else printf("%d\n", Kth(rt, Rk(rt, x + 1)));
    } 
    return 0;
}
应用

这玩意儿显然不能可持久化对吧。
没有旋转常数又大是吧。
但是人家可以套套套啊！
你说其他的树嘞?
旋转了你想套个啥？
f h q fhq fhq的 M e r g e Merge Merge不保证复杂度。
只有替罪羊的重构优秀啊。
什么时候要外层平衡树呢？
带插入区间第 k k k大啊。
外层用替罪羊树，内层用权值线段树。
这样子暴力重构是 O ( n l o g 3 ) O(nlog^3) O(nlog3)的。
不过有一个黑科技是可以采用函数树+线段树合并做到 O ( n l o g 2 ) O(nlog^2) O(nlog2)
第 k k k大把树抓出来在线段树上二分。
代码常数爆炸。
具体看代码吧！能鸽善鹉的我

替罪羊树套权值线段树

luogu真心过不去啊。
bzoj3065
人傻自带大常数。

#include<bits/stdc++.h>
int ri() {
    char c = getchar(); int x = 0, f = 1; for(;c < '0' || c > '9'; c = getchar()) if(c == '-') f = -1;
    for(;c >= '0' && c <= '9'; c = getchar()) x = (x << 1) + (x << 3) - '0' + c; return x * f;
}
const int N = 1e7 + 10, M = 1e5 + 10, Mx = 70000;
const double A = 0.75;
int a[M], rt[M], v[M], st[M], tp, st2[M], tp2, n, Rt, rb;
struct Segment {
    int ls[N], rs[N], sum[N], st[N], tp, cnt;
    int Nw() {return tp ? st[tp--] : ++cnt;}
    void Up(int p) {sum[p] = sum[ls[p]] + sum[rs[p]];}
    int Merge(int a, int b, int L, int R) {
        if(!a || !b) return a | b;
        int np = Nw();
        if(L == R) return sum[np] = sum[a] + sum[b], np;
        int m = L + R >> 1;
        ls[np] = Merge(ls[a], ls[b], L, m);
        rs[np] = Merge(rs[a], rs[b], m + 1, R);
        return Up(np), np;
    }
    void Del(int &p) {
        if(!p) return ;
        st[++tp] = p; Del(ls[p]); Del(rs[p]);
        sum[p] = ls[p] = rs[p] = 0; p = 0;
    }
    void Ins(int &p, int L, int R, int x, int f) {
        if(!p) p = Nw();
        if(L == R) return void(sum[p] += f); int m = L + R >> 1;
        if(x <= m) Ins(ls[p], L, m, x, f);
        else Ins(rs[p], m + 1, R, x, f);
        Up(p); if(!sum[p]) Del(p);
    }
}seg;
struct ScapeGoat {
    int ls[M], rs[M];
    void Build(int &p, int L, int R) {
        if(L > R) return void(p = 0);
        int m = L + R >> 1; p = a[m];
        Build(ls[p], L, m - 1); Build(rs[p], m + 1, R);
        for(int i = L;i <= R; ++i) seg.Ins(rt[p], 0, Mx, v[a[i]], 1);
    }
    void Del(int &p) {
        if(!p) return ; seg.Del(rt[p]);
        Del(ls[p]); st[++tp] = p; Del(rs[p]);
        p = 0;
    }
    void Build(int &p) {
        tp = 0; Del(p); 
        for(int i = 1;i <= tp; ++i) a[i] = st[i];
        Build(p, 1, tp);
    }
    void Ins(int &p, int k, int val) {
        if(!p) {
            v[p = ++n] = val;
            seg.Ins(rt[p], 0, Mx, val, 1);
            return ;
        }
        seg.Ins(rt[p], 0, Mx, val, 1);
        int lsz = seg.sum[rt[ls[p]]];
        lsz >= k ? Ins(ls[p], k, val) : Ins(rs[p], k - lsz - 1, val);
        if(seg.sum[rt[p]] * A + 20 > std::max(seg.sum[rt[ls[p]]], seg.sum[rt[rs[p]]])) {
            if(rb) {
                if(ls[p] == rb) Build(ls[p]);
                else Build(rs[p]);
                rb = 0;
            }
        }
        else rb = p;
    }
    int Mod(int p, int k, int val) {
        seg.Ins(rt[p], 0, Mx, val, 1);
        int lsz = seg.sum[rt[ls[p]]], pr;
        if(lsz + 1 == k) pr = v[p], v[p] = val;
        else pr = (lsz >= k ? Mod(ls[p], k, val) : Mod(rs[p], k - lsz - 1, val));
        seg.Ins(rt[p], 0, Mx, pr, -1);
        return pr;
    }
    void Get(int p, int st, int ed) {
        int L = seg.sum[rt[ls[p]]], R = seg.sum[rt[p]];
        if(st == 1 && ed == R) return void(::st[++tp] = rt[p]);
        if(st <= L + 1 && ed >= L + 1) st2[++tp2] = v[p];
        if(ed <= L) Get(ls[p], st, ed);
        else if(st > L + 1) Get(rs[p], st - L - 1, ed - L - 1);
        else {
            if(st <= L) Get(ls[p], st, L);
            if(ed > L + 1) Get(rs[p], 1, ed - L - 1);
        }
    }
    int Solve(int L, int R, int k) {
        tp = tp2 = 0; Get(Rt, L, R); --k;
        int l = 0, r = Mx;
        for(;l != r;) {
            int m = l + r >> 1, lsm = 0;
            for(int i = 1;i <= tp; ++i) lsm += seg.sum[seg.ls[st[i]]];
            for(int i = 1;i <= tp2; ++i) 
                if(st2[i] >= l && st2[i] <= m)
                    ++lsm;
            if(k < lsm) {
                for(int i = 1;i <= tp; ++i) st[i] = seg.ls[st[i]];
                r = m;
            }
            else {
                for(int i = 1;i <= tp; ++i) st[i] = seg.rs[st[i]];
                l = m + 1; k -= lsm;
            }
        }
        return l;
    }
}bst;
int main() {
    n = ri(); int La = 0;
    for(int i = 1;i <= n; ++i) v[i] = ri(), a[i] = i;
    bst.Build(Rt, 1, n);
    for(int m = ri();m--;) {
        char op = getchar(); for(;op != 'Q' && op != 'M' && op != 'I';) op = getchar();
        int u = ri() ^ La, v = ri() ^ La, k;
        if(op == 'Q') k = ri() ^ La, printf("%d\n", La = bst.Solve(u, v, k));
        else if(op == 'M') bst.Mod(Rt, u, v);
        else rb = 0, bst.Ins(Rt, u - 1, v), rb ? bst.Build(Rt), rb = 0 : 0;
    }
    return 0;
}

总结

不管什么平衡树，重点果然都是深度要期望/均摊 O ( l o g ) O(log) O(log)啊。
而 T r e a p Treap Treap的随机其实已经保证了这一点。
替罪羊的均摊基于优美的暴力重构。
两种树又分别有不同的用途。
一种指向可持久化，一种可以套套套。
但是都常数巨大的说。
接下来就是代码的世界了，靠底子抄了啊。
完结送命。

lvzelong2014
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
java中的数据结构——树
lx_Frolf的博客
10-22 6217
树 树形结构是一种层级式的数据结构，由节点和连接它们的边组成， java语言编写的程序中常常用引用来表示边。根是树中顶端的节 点：它没有父节点。节点表示保存在树中的数据对象。非平衡树是 指根左边的后代比右边多，或者相反。 区分树和图的主要特征是树中不存在环路。 树的节点 Root,parent,child,leaf,sibling 。 树的主要类型 N元树 平衡树 二叉树 二叉搜索树 AVL树 红...
平衡树与非平衡树简介
iFleetingtime的博客
12-20 2747
平衡树与非平衡树的简单介绍。
FHQ-Treap(非旋treap/平衡树)——从入门到入坟
yyh_getAC的博客
07-11 5133
平衡树有很多种，其中fhq-treap 可以说是最强的一种平衡树之一，它可以维护值域，也可以维护下标，还能维护区间修改，更难能可贵的是，它可以完成splay都完成不了的可持久化操作。其唯一弱于splay的就是在LCT上，splay维护LCT的复杂度是O(nlog(n)),而fhq-treap的复杂度为O(nlog^2(n))，稍微大了一点，但是比splay好写多了。............
【平衡树——非旋treap】笔记
最新发布
C2024XSC184的博客
09-18 130
无
数据结构二叉树、图以及非平衡树转换为平衡树
m566666的博客
11-15 1270
二叉树：用索引值父节点找左右孩子节点index*2+1or2 加1是左孩子节点加二是右孩子节点 无序树 完全树：除最后一层可以不满 满树：除叶子节点没有子节点，其他节点都有左右子节点 完美数：除叶子节点，每个节点都有两个子节点 哈夫曼树：最优二叉树 有序树 平衡树：每个节点左右差层不能超过1 红黑树 B类树（b数、B+树） 非平衡树 完全树图例：必须是从左节点到右节点，缺少左叶子节点不是完全树） 满树图例： 完美树图例： 非平衡树图例： 平衡树图例： ...
C++的pb_ds库在OI中的应用集合
12-25
`C++的pb_ds库在OI中的应用.pdf`这份文档很可能是对`pb_ds`在OI中的具体应用案例和技巧的详细讲解，是学习的好资料。 总之，`pb_ds`库是OI和ACM竞赛中提升代码效率和解决问题能力的重要工具。理解和熟练运用这个库...
pb_ds库在OI中的应用
08-24
本文将详细探讨pb_ds库在信息学奥林匹克竞赛（OI）中的应用，包括其基础用法和时间复杂度分析。 首先，pb_ds库的主要特点在于其高度的性能和灵活性。它提供了丰富的数据结构支持，而且其接口设计和STL保持了一致性...
OIread.rar_读取OI中的BLK程序
07-15
光成像技术是一种非侵入性的生物医学成像方法，广泛应用于神经科学研究，用于观察和记录生物组织内的光信号变化。 标题"OIread.rar_读取OI中的BLK程序"表明这个压缩包包含了一些MATLAB脚本，用于读取OI数据中的BLK...
余纪平—pb_ds库在OI中的应用.
07-20
余纪平—pb_ds 库在 OI 中的应用 pb_ds 库是 C++ std 库的扩展，提供了高性能的数据结构，包括平衡树、哈希表、字典树、堆等。gnu_pbds::priority_queue 是 pb_ds 库中的一个重要组件，提供了一个基于策略的优先...
C++的pb_ds库在OI中的应用
05-16
pb_ds库是C++编程语言中一个用于数据结构操作的库，它广泛应用于信息学奥林匹克竞赛（OI）中。这个库提供了许多高级的数据结构，使得在竞赛编程中实现复杂的数据管理变得更加简单和高效。在信息学奥林匹克竞赛中，...
ETT模板
扩展の灰(Extended Ash/Cooevjnz)
11-25 2285
其实这个是弹飞绵羊辣 ETT比lct好写很多 简单来说就是维护树的dfn序列，因为其长度为2n所以效率会不如lct 这里只有换父亲的操作（用一个超级根作为所有树的父亲，就可以支持link和cut），维护的信息是节点的深度，换根到时候再学 说一下几个实现的技巧 可以用splay来维护，由于需要用到抽出一段的操作，建议开一个数组存每个节点的前驱和后继，这样可以省去找前驱后继的常数，但是依然没有LCT的...
信息学奥赛（OI）知识点
日居月诸的博客
08-14 1731
记录了一些OI常考的知识点
ETT学习笔记
Lstdo的博客
03-11 1234
ETT（Eular Tour Tree）是一种维护有根树的数据结构，支持以下操作 修改一个点的点权 子树修改 单点查询 点到根路径查询 修改一个点的父亲 据说可以支持换根，但用的不多而且据说很难写，所以似乎失传了（ 其实没啥技术含量，顾名思义就是维护一棵树的欧拉序。 欧拉序指在 dfs 开始和结束时分别将当前点加入序列中，也称括号序。 用区间平衡树维护这个欧拉序。 平衡树不写 treap ，根...
红黑树、B(+)树、跳表、AVL等数据结构，应用场景及分析，以及一些英文缩写
weixin_34198762的博客
10-22 712
在网上学习了一些材料。 这一篇：https://www.zhihu.com/question/30527705 AVL树:最早的平衡二叉树之一。应用相对其他数据结构比较少。windows对进程地址空间的管理用到了AVL树 红黑树:平衡二叉树，广泛用在C++的STL中。map和set都是用红黑树实现的。我们熟悉的STL的map容器底层是RBtree,当然指的不是unordered_map,后者是...
各类平衡树的学习（一）——Splay
hzk_cpp的博客
02-28 418
一.一道模板题. 题目：loj104. 题目大意：在序列上维护一个数据结构支持： 1.插入数xxx. 2.删除数xxx（只删一个）. 3.查找xxx的最小排名. 4.查找排名为xxx的数. 5.查找xxx的前驱. 6.查找xxx的后继. 这种裸题一般都会卡掉一般的二叉查找树，所以我们现在需要用到平衡树来维护. 平衡树就是利用一些机制，使得每一次的操作效率是O(log⁡n)O(\log n)O(lo...
平衡树概述
lvmaooi的博客
03-28 1734
平衡树是排序二叉树的（SBT）的升级版。就是采取各种手段让排序二叉树变得更平衡，不然在数据极端的情况下，SBT退化成一条链，复杂度也退化成n2n2n^2了。总的来说，就是为了不被丧病出题人卡极端数据发明的算法。 \\ 我们直接把三种写法放在一起（可能会有点长，不过将就看吧）。 平衡树——替罪羊树概述 自从写了平衡树之后就整个人都不好了，我是个蒟蒻，打个200行的代码就不咋调得出来。...
平衡树之非旋Treap
agtvo48266的专栏
12-09 186
平衡树（二叉树） 线段树不支持插入or删除一个数于是平衡树产生了 常见平衡树：treap（比sbt慢，好写吧），SBT(快，比较好写，有些功能不支持)，splay（特别慢，复杂度当做根号n来用，功能强大，不好写），rbt（红黑树，特别快），//替罪羊树，朝鲜树 晚上要讲的不旋转平衡树： 平衡树： 节点的左儿子中的每一个一定比他小，右儿子中的每一个一定比他大 那么它的中序遍历是有序的 用下...
无旋平衡树
weixin_48940571的博客
04-15 293
无旋平衡树（treap）
平衡二叉树
Never_for_Never的专栏
11-14 952
平衡二叉树定义(AVL)：它或者是一颗空树，或者具有以下性质的二叉树：它的左子树和右子树的深度之差的绝对值不超过1，且它的左子树和右子树都是一颗平衡二叉树。 平衡因子(bf)：结点的左子树的深度减去右子树的深度，那么显然-1 很显然，平衡二叉树是在二叉排序树(BST)上引入的，就是为了解决二叉排序树的不平衡性导致时间复杂度大大下降，那么AVL就保持住了(BST)的最好时间复杂度O(logn)，
数据结构解析：线段树与树状数组在区间问题中的应用
这两种数据结构在解决信息竞赛（OI）中的题目时特别有用。 线段树是一种二叉树形数据结构，用于对动态区间进行高效查询和修改。它的核心特点是能够以O(logN)的时间复杂度完成区间查询和修改，其中N是区间长度。线段...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值