非旋转 Treap 学习笔记(二)

本文详细介绍了非旋转Treap的数据结构及其在区间操作上的优势,包括插入、翻转等基本操作实现方法。通过具体示例解释了如何进行区间翻转,并提供了一段完整的C++代码实现。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

非旋转 Treap 学习笔记(一) 没有涉及一些区间的操作只是最基本的 Treap 操作,这篇才是非旋 Treap 真正优秀的地方。

要注意涉及区间操作时插入就是按照位置插入的,而不是按照权值的排名插入了。

Luogu P3391 【模板】文艺平衡树(Splay)

插入的时候分离前 pos - 1 个。
比如 1 2 3 4 5,在第 3 个位置插入一个 8,变成 1 2 8 3 4 5
把前面 1 2 分裂出来,后面 3 4 5 分裂出来

1 ~ n 分为 1 ~ (l - 1), l ~ r, (r + 1) ~ n 找到要翻转的区间 l ~ r 并标记。
在 pushDown 时翻转,就是将标记的节点 v 的左右子树交换,并不断将标记下传。
每次在 split 和 merge 的时候记得 pushDown。

最后 dfs 中序遍历一次求出最终翻转后的数列。

#include <bits/stdc++.h>

using namespace std;
const int N = 1e5 + 5;

struct Treap {
    struct Node {
        Node *lc, *rc;
        int x, size, key;
        bool rev;
        Node(int x) : lc(NULL), rc(NULL), x(x), size(1), key(rand() * rand() * rand()), rev(false) {}

        inline void reverse() { rev ^= 1; }

        inline void pushDown() {
            if (rev) {
                swap(lc, rc);
                if (lc) lc->reverse();
                if (rc) rc->reverse();
                rev = false;
            }
        }

        inline void maintain() { size = (lc ? lc->size : 0) + (rc ? rc->size : 0) + 1; }

        inline int lSize() { return lc ? lc->size : 0; } 
    } *root;

    /*int lowerCount(int x) {
        Node *v = root;
        int res = 0;
        while (v) {
            v->pushDown();
            if (x <= v->x) v = v->lc;
            else res += v->lSize() + 1, v = v->rc;
        }
        return res;
    }

    int upperCount(int x) {
        Node *v = root;
        int res = 0;
        while (v) {
            v->pushDown();
            if (x < v->x) v = v->lc;
            else res += v->lSize() + 1, v = v->rc;
        }
        return res;
    }*/ 

    inline void split(Node *v, int k, Node *&l, Node *&r) {
        if(!v) { l = r = NULL; return ; }

        v->pushDown();

        int s = v->lSize();
        if(k <= s) {
            split(v->lc, k, l, r);
            v->lc = r;
            r = v;
        } else {
            split(v->rc, k - s - 1, l, r);
            v->rc = l;
            l = v;
        }

        v->maintain();
    }

    Node *merge(Node *a, Node *b) {
        if (!a && !b) return NULL;
        if (!a) { b->maintain(); return b; } //
        if (!b) { a->maintain(): return a; }

        a->pushDown();
        b->pushDown();

        if (a->key > b->key) {
            a->rc = merge(a->rc, b);
            a->maintain();
            return a;
        } else {
            b->lc = merge(a, b->lc);
            b->maintain();
            return b;
        }
    }

    inline void insert(int pos, int x) {
        Node *pred, *tmp;
        split(root, pos - 1, pred, tmp);

        Node *v = new Node(x);

        root = merge(pred, merge(v, tmp));
    }

    bool reverse(int l, int r) {
        Node *pred, *tmp;
        split(root, l - 1, pred, tmp);

        Node *target, *succ;
        split(tmp, r - l + 1, target, succ);

        target->reverse();

        root = merge(pred, merge(target, succ));
    }

    void dfs(Node *v, int *&p) {
        if (!v) return ;
        v->pushDown();
        dfs(v->lc, p);
        *p ++ = v->x;
        dfs(v->rc, p);
    }

    void fetch(int a[]) { // p 是引用,会在整个递归过程中改变
        int *p = &a[1];
        dfs(root, p);
    }
} treap;

int main() {
    int n, m;
    scanf("%d%d", &n, &m);

    for (int i = 1; i <= n; i ++) treap.insert(i, i);

    for (int i = 1; i <= m; i ++) {
        int l, r;
        scanf("%d%d", &l, &r);
        treap.reverse(l, r);
    }

    static int a[N];
    treap.fetch(a); // 中序遍历一遍

    for (int i = 1; i <= n; i ++) printf("%d%c", a[i], " \n"[i ==n]);
    return 0;
}
Treap(Tree + Heap)是一种结合了叉搜索树(BST)和堆(Heap)特性的平衡叉搜索树数据结构。其核心原理在于每个节点维护两个值:一个用于叉搜索树性质的键值(key),以及一个用于最大堆性质的优先级(priority)。通过这两个属性,Treap在插入和删除操作时保持树的平衡性,从而确保操作的时间复杂度接近于对数级别。 ### Treap的基本原理 1. **叉搜索树性质**:对于任意节点,其左子树中所有节点的键值小于当前节点的键值,右子树中所有节点的键值大于当前节点的键值。 2. **堆性质**:每个节点的优先级大于其子节点的优先级,这样可以确保树的结构在插入或删除时通过旋转操作保持平衡。 在插入新节点时,Treap首先按照叉搜索树的方式找到合适的位置,并赋予该节点一个随机的优先级。如果该节点的优先级违反了堆性质,则通过旋转操作调整树的结构以恢复堆性质。删除操作类似,通过旋转确保堆性质得以维持。 ### 无Treap的实现 无Treap(Non-Rotating Treap)是Treap的一个变种,它通过分裂(Split)和合并(Merge)操作来实现树的平衡,而不是传统的旋转操作。分裂操作将树按照某个键值或位置分割为两部分,而合并操作将两个树合并为一个。这种方式简化了实现逻辑,尤其是在处理复杂操作时[^2]。 例如,分裂操作可以通过以下方式实现(以键值为分割点): ```python def split(node, key): if node is None: return (None, None) if node.key <= key: left, right = split(node.right, key) node.right = left return (node, right) else: left, right = split(node.left, key) node.left = right return (left, node) ``` 合并操作则需要确保堆性质的维护: ```python def merge(left, right): if left is None: return right if right is None: return left if left.priority > right.priority: left.right = merge(left.right, right) return left else: right.left = merge(left, right.left) return right ``` ### 应用场景 Treap由于其高效的平衡特性,广泛应用于需要高效查找、插入和删除操作的场景。常见的应用包括: - **数据库索引**:Treap可以用于实现高效的索引结构,支持快速的数据检索。 - **内存中的集合与映射**:在需要频繁插入和删除元素的场景中,Treap提供了良好的性能保障。 - **算法竞赛**:在某些需要高效数据结构的竞赛题中,Treap常被用来实现动态集合操作[^1]。 ### 实现细节 在实现Treap时,需要注意以下几点: - **随机优先级生成**:为了保证树的平衡性,每个节点的优先级应随机生成,通常使用大范围的整数以减少冲突的可能性。 - **递归与递归实现**:虽然递归实现较为直观,但在大规模数据处理时可能会导致栈溢出,因此在实际应用中可以考虑递归实现。 - **类型安全与内存管理**:特别是在使用Rust等语言时,需注意类型约束和内存安全,以确保程序的稳定性和可靠性[^1]。 通过理解Treap的原理和实现方式,开发者可以更好地将其应用于实际项目中,并根据需求进行扩展和优化。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值