Treap（树堆）

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

Treap（树堆）

Treap（树堆）是一种平衡二叉搜索树实现。分为带旋转的Treap和无旋转的Treap。其中，无旋转的Treap相比于AVL来说，其实现简单，方便快捷，是OI竞赛中的不二之选，但是因为其依靠随机化的因素，其平衡是期望平衡的，最坏情况退化为链表，但概率不大。其中无旋Treap（以下Treap均指无旋Treap），分为两个重要的操作，分别为Split（分割）、merge（合并）。

本文以为P3369例题，讲解其实现。

节点结构体

其节点和二叉树基本相同，其中prior成员需要特别注意，这个成员在合并的时候作为合并参考值。

struct Node
{
    int prior; // 节点优先级
    int key;   // 节点关键字
    int l;     // 左儿子节点
    int r;     // 右儿子节点
    int siz;   // 子树的大小
    int cnt;   // 节点的重度
} t[1000000];

以下为分配节点代码，其中，我们注意到：

t[tot].prior = rand();

prior为随机值，所以我们说Treap是期望平衡的。

int tot = 0;

int createNode(int key)
{
    tot++;
    t[tot].key = key;
    t[tot].prior = rand();
    return tot;
}

Split（分割）

函数原型如下：

pair<int, int> split(int root, int key);

给定一个Treap树，其root为根节点，将这颗树分解成两个Treap树，其中pair.first树的所有节点的权值都小于等于key，pair.second树的所有节点的权值都大于key。

我们判断root.key与key的关系，如果key<root.key那么说明根节点root连带其右子树都是pair.second的部分，我们递归分解左子树，然后将分解左子树的结果记为sp的sp.second作为root的新左子树，然后返回(sp.first,root)即可。

同样的，key大于等于root.key的时候，我们分解其右子树，以相对称的方式合并子树即可。

pair<int, int> split(int root, int key)
{
    if (root == 0)
    {
        return make_pair(0, 0);
    }

    if (key < t[root].key)
    {
        pair<int, int> lt = split(t[root].l, key);
        t[root].l = lt.second;
        t[root].siz = t[t[root].l].siz + t[t[root].r].siz + t[root].cnt;

        return make_pair(lt.first, root);
    }
    else
    {
        pair<int, int> rt = split(t[root].r, key);
        t[root].r = rt.first;
        t[root].siz = t[t[root].l].siz + t[t[root].r].siz + t[root].cnt;

        return make_pair(root, rt.second);
    }
}

Merge（合并）

函数原型如下：

int merge(int u, int v);

合并两个Treap子树u和v，其中要求u的所有节点的key都小于等于v所有节点的key。

合并两个Treap有两种不同的方法，采取哪种方法取决于uv中prior的大小的关系，如果，u的prior大于v，那么，将其u的右子树和v整个合并，作为u的新右子树。

合并

同样的，如果u的key值小于等于v的key值，那么就合并v的左子树和u作为v的新左子树即可。

int merge(int u, int v)
{
    if (u == 0)
        return v;
    if (v == 0)
        return u;
    if (t[u].prior > t[v].prior)
    {
        t[u].r = merge(t[u].r, v);
        t[u].siz = t[t[u].l].siz + t[t[u].r].siz + t[u].cnt;
        return u;
    }
    else
    {
        t[v].l = merge(u, t[v].l);
        t[v].siz = t[t[v].l].siz + t[t[v].r].siz + t[v].cnt;
        return v;
    }
}

我们还发现，prior的规则符合堆的规则，即两个子节点的prior的值必定小于等于父节点的key值，其具有堆的特性，又具有搜索二叉树的形式，所以叫Treap（树堆），其中可以证明，将一个随机序列建堆，我们得到的堆的形式更符合平衡树的形式。

提取节点

如果我们想提取树堆中的一个节点，我们该怎么做呢？

我们先将堆分割成两个部分，按照key-1分割，记为 s p sp sp，其中 s p . f i r s t sp.first sp.first的节点值全部小于等于key-1， s p . s e c o n d sp.second sp.second的值全部大于key-1，然后，我们再次按key分割 s p . s e c o n d sp.second sp.second，记为 s s p ssp ssp，那么 s s p . f i r s t ssp.first ssp.first的值将是权值为key的节点， s s p . s e c o n d ssp.second ssp.second的节点都是大于key的节点。

这样 s s p . f i r s t ssp.first ssp.first就是我们想要的节点了。

pair<int, int> sp1 = split(root, key - 1);
pair<int, int> sp2 = split(sp1.second, key);

插入节点

int insert(int root, int key)
{
    pair<int, int> sp1 = split(root, key - 1);
    pair<int, int> sp2 = split(sp1.second, key);
    if (sp2.first == 0)
    {
        sp2.first = createNode(key);
    }

    t[sp2.first].siz++;
    t[sp2.first].cnt++;

    return merge(merge(sp1.first, sp2.first), sp2.second);
}

删除节点

int del(int root, int key)
{
    pair<int, int> sp1 = split(root, key - 1);
    pair<int, int> sp2 = split(sp1.second, key);
    if (sp2.first != 0)
    {
        if (t[sp2.first].cnt == 1)
        {
            sp2.first = 0;
        }
        else
        {
            t[sp2.first].cnt--;
            t[sp2.first].siz--;
        }
    }

    return merge(merge(sp1.first, sp2.first), sp2.second);
}

排名查询

int count(int root, int key, int &ans)
{
    pair<int, int> sp = split(root, key - 1);
    ans = t[sp.first].siz + 1;
    return merge(sp.first, sp.second);
}

int query(int root, int x)
{
    if (t[t[root].l].siz < x && t[t[root].l].siz + t[root].cnt >= x)
    {
        return t[root].key;
    }
    if (t[t[root].l].siz >= x)
        return query(t[root].l, x);
    return query(t[root].r, x - t[t[root].l].siz - t[root].cnt);
}

查询前驱、后继节点

int prv(int root, int key, int &ans)
{
    pair<int, int> sp = split(root, key - 1);
    int curr = sp.first;
    while (curr != 0 && t[curr].r != 0)
    {
        curr = t[curr].r;
    }
    ans = t[curr].key;
    return merge(sp.first, sp.second);
}

int nxt(int root, int key, int &ans)
{
    pair<int, int> sp = split(root, key);
    int curr = sp.second;
    while (curr != 0 && t[curr].l != 0)
    {
        curr = t[curr].l;
    }
    ans = t[curr].key;
    return merge(sp.first, sp.second);
}

模板

#include <bits/stdc++.h>

using namespace std;

#define FR freopen("in.txt", "r", stdin)
#define FW freopen("out11.txt", "w", stdout)

#define MOD 998244353

typedef long long ll;

struct Node
{
    int prior; // 节点优先级
    int key;   // 节点关键字
    int l;     // 左儿子节点
    int r;     // 右儿子节点
    int siz;   // 子树的大小
    int cnt;   // 节点的重度
} t[1000000];

int tot = 0;

int createNode(int key)
{
    tot++;
    t[tot].key = key;
    t[tot].prior = rand();
    return tot;
}

pair<int, int> split(int root, int key)
{
    if (root == 0)
    {
        return make_pair(0, 0);
    }

    if (key < t[root].key)
    {
        pair<int, int> lt = split(t[root].l, key);
        t[root].l = lt.second;
        t[root].siz = t[t[root].l].siz + t[t[root].r].siz + t[root].cnt;

        return make_pair(lt.first, root);
    }
    else
    {
        pair<int, int> rt = split(t[root].r, key);
        t[root].r = rt.first;
        t[root].siz = t[t[root].l].siz + t[t[root].r].siz + t[root].cnt;

        return make_pair(root, rt.second);
    }
}

int merge(int u, int v)
{
    if (u == 0)
        return v;
    if (v == 0)
        return u;
    if (t[u].prior > t[v].prior)
    {
        t[u].r = merge(t[u].r, v);
        t[u].siz = t[t[u].l].siz + t[t[u].r].siz + t[u].cnt;
        return u;
    }
    else
    {
        t[v].l = merge(u, t[v].l);
        t[v].siz = t[t[v].l].siz + t[t[v].r].siz + t[v].cnt;
        return v;
    }
}

int insert(int root, int key)
{
    pair<int, int> sp1 = split(root, key - 1);
    pair<int, int> sp2 = split(sp1.second, key);
    if (sp2.first == 0)
    {
        sp2.first = createNode(key);
    }

    t[sp2.first].siz++;
    t[sp2.first].cnt++;

    return merge(merge(sp1.first, sp2.first), sp2.second);
}

int del(int root, int key)
{
    pair<int, int> sp1 = split(root, key - 1);
    pair<int, int> sp2 = split(sp1.second, key);
    if (sp2.first != 0)
    {
        if (t[sp2.first].cnt == 1)
        {
            sp2.first = 0;
        }
        else
        {
            t[sp2.first].cnt--;
            t[sp2.first].siz--;
        }
    }

    return merge(merge(sp1.first, sp2.first), sp2.second);
}

int count(int root, int key, int &ans)
{
    pair<int, int> sp = split(root, key - 1);
    ans = t[sp.first].siz + 1;
    return merge(sp.first, sp.second);
}

void update(int root)
{
    if (root == 0)
        return;
    update(t[root].l);
    update(t[root].r);

    t[root].siz = t[t[root].l].siz + t[t[root].r].siz + t[root].cnt;
}

int query(int root, int x)
{
    if (t[t[root].l].siz < x && t[t[root].l].siz + t[root].cnt >= x)
    {
        return t[root].key;
    }
    if (t[t[root].l].siz >= x)
        return query(t[root].l, x);
    return query(t[root].r, x - t[t[root].l].siz - t[root].cnt);
}

int prv(int root, int key, int &ans)
{
    pair<int, int> sp = split(root, key - 1);
    int curr = sp.first;
    while (curr != 0 && t[curr].r != 0)
    {
        curr = t[curr].r;
    }
    ans = t[curr].key;
    return merge(sp.first, sp.second);
}

int nxt(int root, int key, int &ans)
{
    pair<int, int> sp = split(root, key);
    int curr = sp.second;
    while (curr != 0 && t[curr].l != 0)
    {
        curr = t[curr].l;
    }
    ans = t[curr].key;
    return merge(sp.first, sp.second);
}

int ans = 0;

void output(int root)
{
    if (root == 0)
        return;
    output(t[root].l);
    if (t[root].key == 815809)
        printf(" !%d! ", ans);
    printf("%d:%d ", t[root].key, t[root].cnt);
    ans += t[root].cnt;
    output(t[root].r);
}

int main()
{
    srand(time(NULL));
    srand(rand());
    srand(rand());
    srand(rand());

    int T;
    int root = 0;
    scanf("%d", &T);
    int ans = 0;
    while (T--)
    {
        int op;
        int x;
        scanf("%d %d", &op, &x);
        switch (op)
        {
        case 1:
            root = insert(root, x);
            break;
        case 2:
            root = del(root, x);
            break;
        case 3:
            root = count(root, x, ans);
            printf("%d\n", ans);
            break;
        case 4:
            ans = query(root, x);
            printf("%d\n", ans);
            break;
        case 5:
            root = prv(root, x, ans);
            printf("%d\n", ans);
            break;
        case 6:
            root = nxt(root, x, ans);
            printf("%d\n", ans);
            break;
        default:
            break;
        }
    }
    return 0;
}
爱寂寞的时光
关注
专栏目录
Treap树简化的平衡树实现与应用分析
一键难忘的博客
11-06 3104
Treap树是一种基于随机化策略的数据结构，结合了二叉查找树和堆的特性。二叉查找树的性质：对于每个节点，左子树的所有节点的键值都小于该节点的键值，右子树的所有节点的键值都大于该节点的键值。堆的性质：每个节点都被赋予一个随机的优先级（priority），并且树中的每个节点的优先级满足堆的性质，即父节点的优先级大于等于子节点的优先级。这种随机化的平衡策略使得Treap树在操作过程中保持平衡，期望时间复杂度为O(log n)。
Java实现Treap树
weixin_45754452的博客
03-08 651
文章目录Treap树数据结构遍历查询增加删除完整代码 Treap树 Treap树是平衡二叉搜索树的一种实现方式，但它不是完全平衡的。平衡二叉搜索树的实现方式还有AVL树、红黑树、替罪羊树、伸展树 数据结构 Treap树的节点除了有二叉搜索树的 class TreeNode { int value; int priority; TreeNode left; TreeNode right; public TreeNode(int value, int priority)
Treap
wsyear的博客
03-02 389
Treap=Tree+Heap,介绍Treap思路及常用操作
treap(树堆)
weixin_33923148的博客
05-06 147
一棵treap是一棵修改了结点顺序的二叉查找树，如图，显示一个例子，通常树内的每个结点x都有一个关键字值key[x]，另外，还要为结点分配priority[x]，它是一个独立选取的随机数。假设所有的优先级是不同的，所有的关键字也是不同的。treap的结点排列成让关键字遵循二叉查找树性质，并且优先级遵循最小堆顺序性质：1.如果v是u的左孩子，则key[v] &lt; key[u].2.如果v是u的右...
［转载］Treap
zr9558
07-15 750
http://www.nocow.cn/index.php/Treap Treap Treap，就是有另一个随机数满足堆的性质的二叉搜索树，其结构相当于以随机顺序插入的二叉搜索树。其基本操作的期望复杂度为O(log n)。 其特点是实现简单，效率高于伸展树并且支持大部分基本功能，性价比很高。 目录  [隐藏]  1 前言2
Treap 树堆 和 Skip Lists
07-17
Treap树，也被称为二叉搜索树堆，是一种二叉搜索树，它将堆（Heap）的性质与二叉搜索树（Binary Search Tree）的性质结合起来。Treap树中的每个节点都同时拥有一个搜索键（search key）和一个优先级（priority）。它...
Treap树堆实现
11-04
**Treap树堆实现** Treap，又称为“随机优先搜索树”，是一种结合了二叉查找树（BST）和堆特性的数据结构。它在保持查找树特性的同时，通过引入随机化来保证平衡，从而避免了传统平衡二叉树如AVL或红黑树等在插入和...
treap树VB实现
10-26
Treap树是一种自平衡二叉搜索树，由Russo在1989年提出，它的全称是“随机优先堆树”（Tree-Heap）。它结合了二叉搜索树和堆的特点，通过引入随机性来保持平衡，从而在平均情况下达到较高的查找、插入和删除操作的...
TREAP
dengtun2502的博客
05-24 148
TREAP Treap = Tree + Heap. 树堆，在数据结构中也称Treap，是指有一个随机附加域满足堆的性质的二叉搜索树，其结构相当于以随机数据插入的二叉搜索树。其基本操作的期望时间复杂度为O(logn)。相对于其他的平衡二叉搜索树，Treap的特点是实现简单，且能基本实现随机平衡的结构。 Treap 维护堆的性质的方法只用到了左旋和右旋， 编程复杂度比Splay小一点(??...
6天通吃树结构—— 第三天 Treap树
weixin_34224941的博客
07-30 130
               我们知道，二叉查找树相对来说比较容易形成最坏的链表情况，所以前辈们想尽了各种优化策略，包括AVL，红黑，以及今天 要讲的Treap树。        Treap树算是一种简单的优化策略，这名字大家也能猜到，树和堆的合体，其实原理比较简单，在树中维护一个"优先级“，”优先级“ 采用随机数的方法，但是”优先级“必须满足根堆的性质，当然是“大根堆”或者“小根堆”都无...
Treap树堆
weixin_57128596的博客
12-23 695
主要体现的思想是随机插入数字，会给每个数字赋予一个优先级——>目的是让插入的关键字满足二叉树（节点的性质满足=（关键字:优先级））特点：被旋转的节点的左子树会到原父节点的右子树上（节点左旋，那么节点的右子树还是一直挂着保护着的）2.后面发现关键字2的优先级
树堆treap
cj1064789374的博客
12-30 154
树堆treap
树 堆
最新发布
m0_66054454的博客
03-27 246
树的基本概念，堆的实现，堆排序，TopK
树堆
08-14 526
原文链接：http://blog.csdn.net/yang_yulei/article/details/46005845 Treap Treap=Tree+Heap。Treap本身是一棵二叉搜索树，它的左子树和右子树也分别是一个Treap，和一般的二叉搜索树不同的是，Treap纪录一个额外的数据，就是优先级。Treap在以关键码构成二叉搜索树的同时，还满足堆的性质
树-堆
好记性不如烂笔头
03-05 395
参考： 深入理解堆（最大堆，最小堆及堆排序）
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值