FHQ-Treap：无旋平衡树的原理与工程实践

1. 平衡树基础与FHQ-Treap的诞生背景

在计算机科学领域，平衡二叉搜索树（Balanced Binary Search Tree）一直是处理动态数据集的核心数据结构。传统AVL树和红黑树通过严格的旋转操作维持平衡，而Treap（Tree + Heap）则另辟蹊径，通过为每个节点随机分配优先级（priority），结合二叉搜索树的性质和堆的性质来实现概率平衡。

FHQ-Treap由范浩强（Fan Haoqiang）在2012年提出，其革命性在于完全摒弃了旋转操作。这种无旋特性使得代码实现异常简洁——核心操作仅需两个函数：split（分裂）和merge（合并）。实测表明，FHQ-Treap的代码量可比传统Treap减少40%，而时间复杂度仍保持期望O(log n)。

关键突破：split和merge操作的时间复杂度均为O(h)，其中h为树高。由于Treap的随机优先级特性，h的期望值为O(log n)，这使得FHQ-Treap在绝大多数场景下表现优异。

2. FHQ-Treap的核心原理解析

2.1 节点结构设计

FHQ-Treap的每个节点包含四个基本字段：

cpp复制struct Node {
    int val;        // 节点值（BST性质）
    int pri;        // 随机优先级（堆性质）
    int size;       // 子树大小（支持排名操作）
    Node *l, *r;    // 左右子节点指针
};

其中pri的随机性至关重要——通过系统随机数生成器（如C++的mt19937）为每个新节点分配优先级，确保树高期望平衡。

2.2 分裂操作(split)的数学本质

split操作接受一个参数x，将树划分为两个子树T1和T2，满足：

• T1包含所有val ≤ x的节点
• T2包含所有val > x的节点

递归实现的关键在于比较当前节点val与x的关系：

cpp复制void split(Node *t, int x, Node *&L, Node *&R) {
    if (!t) { L = R = nullptr; return; }
    if (t->val <= x) {
        L = t;
        split(t->r, x, t->r, R);
    } else {
        R = t;
        split(t->l, x, L, t->l);
    }
    update_size(t); // 维护子树大小
}

2.3 合并操作(merge)的堆性质维护

merge操作将两个Treap L和R合并，其中L的所有节点val ≤ R的所有节点val。合并时通过比较节点优先级决定父子关系：

cpp复制Node* merge(Node *L, Node *R) {
    if (!L || !R) return L ? L : R;
    if (L->pri > R->pri) {
        L->r = merge(L->r, R);
        update_size(L);
        return L;
    } else {
        R->l = merge(L, R->l);
        update_size(R);
        return R;
    }
}

3. 区间操作的实现艺术

3.1 基于size的分裂技巧

要实现类似线段树的区间操作，需要按子树大小而非节点值进行分裂。以下代码截取第l到第r个元素：

cpp复制void split_by_size(Node *t, int k, Node *&L, Node *&R) {
    if (!t) { L = R = nullptr; return; }
    int lsize = size(t->l);
    if (lsize < k) {
        L = t;
        split_by_size(t->r, k - lsize - 1, t->r, R);
    } else {
        R = t;
        split_by_size(t->l, k, L, t->l);
    }
    update_size(t);
}

Node* extract_range(Node *&root, int l, int r) {
    Node *L, *M, *R;
    split_by_size(root, l-1, L, M);
    split_by_size(M, r-l+1, M, R);
    root = merge(L, R);
    return M;
}

3.2 区间翻转的高效实现

通过惰性标记（lazy tag）实现O(log n)的区间翻转：

cpp复制struct Node {
    // ...原有字段
    bool rev;       // 翻转标记
};

void push_down(Node *t) {
    if (t && t->rev) {
        t->rev = false;
        swap(t->l, t->r);
        if (t->l) t->l->rev ^= 1;
        if (t->r) t->r->rev ^= 1;
    }
}

void reverse_range(Node *&root, int l, int r) {
    Node *L, *M, *R;
    split_by_size(root, l-1, L, M);
    split_by_size(M, r-l+1, M, R);
    M->rev ^= 1;
    root = merge(merge(L, M), R);
}

4. 实战：FHQ-Treap的工程优化

4.1 内存池技术

频繁new/delete会导致性能下降，采用预分配内存池可提升10倍性能：

cpp复制Node pool[MAXN], *alloc_ptr = pool;
Node* new_node(int val) {
    Node *p = alloc_ptr++;
    p->val = val;
    p->pri = rand();
    p->size = 1;
    p->rev = false;
    p->l = p->r = nullptr;
    return p;
}

4.2 非递归实现

递归版本在极端情况下可能栈溢出，改用迭代实现split/merge：

cpp复制void split_iter(Node *t, int x, Node *&L, Node *&R) {
    stack<Node**> stk;
    L = R = nullptr;
    Node **cur = t ? &t : nullptr;
    
    while (cur) {
        push_down(*cur);
        if ((*cur)->val <= x) {
            stk.push(cur);
            cur = &((*cur)->r);
        } else {
            cur = &((*cur)->l);
        }
    }
    
    while (!stk.empty()) {
        Node **p = stk.top(); stk.pop();
        (*p)->r = R;
        R = *p;
        update_size(R);
    }
    L = t;
}

5. 性能对比与适用场景

5.1 时间复杂度实测对比

在10^6次插入/删除操作下的表现（单位：ms）：

5.2 典型应用场景

1. 动态排名系统：实时维护用户积分排行榜
2. 文本编辑器：支持快速插入/删除的缓冲区
3. 区间问题：需要频繁翻转/移动子序列的场景
4. 离线算法：替代莫队算法中的分块结构

踩坑提醒：在需要严格O(log n)最坏时间保证的场景（如航空管制系统），应选择AVL树而非FHQ-Treap。但在ACM竞赛和大多数工程场景中，FHQ-Treap的简洁性和高效区间操作使其成为首选。