【数据结构】Treap的实现与应用

最新推荐文章于 2021-12-30 14:54:34 发布
最新推荐文章于 2021-12-30 14:54:34 发布
阅读量420 收藏
点赞数
分类专栏： 实用数据结构 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cww97/article/details/77574920
版权

本篇博客作者：czj

Treap的本质是一颗二叉查找树，只是在每个结点上都附加了一个优先级的信息。保证每个点的优先级都比左右儿子小，利用优先级，我们可以把这颗树看成一个小根堆。
Treap树在随机给优先级的情况下，可以在期望O(logn)的时间复杂度里完成：

  • 一个结点的插入。
  • 一个结点的删除。
  • 查询第K大的值。
  • 给定一个值返回它是第几大。

以上四种操作。

那么话不多说，先上模板。这里准备了两个模板，第一个来自红书，代码量89行（有三个冗余函数居然还短些），第二个据说来自刘汝佳的《训练指南》，代码量99行但是变量名比较短，或许打起来可以更快些。

第一个模板：

#include <bits/stdc++.h>

using namespace std;
const int maxNode = 444444;
const int INF = 0x3f3f3f3f;

struct Treap {
    int root, treapCnt, key[maxNode], priority[maxNode],
     childs[maxNode][2], cnt[maxNode], size[maxNode];

    Treap() {
        root = 0;
        treapCnt = 1;
        priority[0] = INF;
        size[0] = 0;
    }
    void update(int x) {
        size[x] = size[childs[x][0]] + cnt[x] + size[childs[x][1]];
    }
    void rotate(int &x, int t) {
        int y = childs[x][t];
        childs[x][t] = childs[y][1 - t];
        childs[y][1 - t] = x;
        update(x);
        update(y);
        x = y;
    }
    void __insert(int &x, int k) {
        if(x) {
            if(key[x] == k) {
                cnt[x]++;
            } else {
                int t = key[x] < k;
                __insert(childs[x][t], k);
                if(priority[childs[x][t]] < priority[x]) {
                    rotate(x, t);
                }
            }
        } else {
            x = treapCnt++;
            key[x] = k;
            cnt[x] = 1;
            priority[x] = rand();
            childs[x][0] = childs[x][1] = 0;
        }
        update(x);
    }

    void __erase(int &x, int k) {
        if(key[x] == k) {
            if(cnt[x] > 1) {
                cnt[x]--;
            } else {
                if(childs[x][0] == 0 && childs[x][1] == 0) {
                    x = 0;
                    return;
                }
                int t = priority[childs[x][0]] > priority[childs[x][1]];
                rotate(x, t);
                __erase(x, k);
            }
        } else {
            __erase(childs[x][key[x] < k], k);
        }
        update(x);
    }
    int __getKth(int &x, int k) {
        if(k <= size[childs[x][0]]) {
            return __getKth(childs[x][0], k);
        }
        k -= size[childs[x][0]] + cnt[x];
        if(k <= 0) {
            return key[x];
        }
        return __getKth(childs[x][1], k);
    }

    void insert(int k) {
        __insert(root, k);
    }

    void erase(int k) {
        __erase(root, k);
    }

    int getKth(int k) {
        return __getKth(root, k);
    }
};

int main() {

    return 0;
}

注释详见红书190页。

第二个模板：

#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<cassert>
using namespace std;
struct Node
{
    Node *ch[2];
    int r,v,s;//s表示节点数

    Node(int v):v(v)
    {
        ch[0]=ch[1]=NULL;
        r=rand();//在cstdlib头声明
        s=1;
    }

    int cmp(int x)
    {
        if(x==v)return -1;
        return x<v?0:1;
    }
    void maintain()
    {
        s=1;
        if(ch[0]!=NULL) s+=ch[0]->s;
        if(ch[1]!=NULL) s+=ch[1]->s;
    }
}; //root全局使用的话可以在这里跟上*root
void rotate(Node* &o,int d)
{
    Node *k=o->ch[d^1];
    o->ch[d^1]=k->ch[d];
    k->ch[d]=o;
    o->maintain();
    k->maintain();
    o=k;
}
void insert(Node* &o,int x)//o子树中事先不存在x
{
    if(o==NULL) o=new Node(x);
    else
    {
        //如这里改成int d=o->cmp(x);
        //就不可以插入相同的值，因为d可能为-1
        int d=x<(o->v)?0:1;
        insert(o->ch[d],x);
        if(o->ch[d]->r > o->r)
            rotate(o,d^1);
    }
    o->maintain();
}

void remove(Node* &o,int x)
{
    if(o==NULL) return ;//空时返回

    int d=o->cmp(x);
    if(d==-1)
    {
        Node *u=o;
        if(o->ch[0] && o->ch[1])
        {
            int d2=(o->ch[0]->r < o->ch[1]->r)?0:1;
            rotate(o,d2);
            remove(o->ch[d2],x);
        }
        else
        {
            if(o->ch[0]==NULL) o=o->ch[1];
            else o=o->ch[0];
            delete u;//这个要放里面
        }
    }
    else remove(o->ch[d],x);
    if(o) o->maintain();//之前o存在,但是删除节点后o可能就是空NULL了,所以需要先判断o是否为空
}

//返回关键字从小到大排序时的第k个值
//若返回第K大的值，只需要把ch[0]和ch[1]全互换就可以了
int kth(Node* o,int k)
{
    assert(o && k>=1 && k<=o->s);//保证输入合法,根据实际问题返回
    int s=(o->ch[0]==NULL)?0:o->ch[0]->s;
    if(k==s+1) return o->v;
    else if(k<=s) return kth(o->ch[0],k);
    else return kth(o->ch[1],k-s-1);
}

//返回值x在树中的排名,就算x不在o树中也能返回排名
//返回值范围在[1,o->s+1]范围内
int rank(Node* o,int x)
{
    if(o==NULL) return 1;//未找到x;

    int num= o->ch[0]==NULL ? 0:o->ch[0]->s;
    if(x==o->v) return num+1;
    else if(x < o->v) return rank(o->ch[0],x);
    else return rank(o->ch[1],x)+num+1;
}


int main()
{
    int n=0;
    while(scanf("%d",&n)==1 && n)
    {
        Node *root=NULL; //初始化为NULL
        for(int i=0; i<n; i++)
        {
            int x;
            scanf("%d",&x);
            if(root==NULL) root=new Node(x);
            else insert(root,x);
        }

        int v;
        while(scanf("%d",&v)==1)
        {
            printf("%d\n",rank(root,v));
        }
    }
    return 0;
}

个人更加喜欢第二个模板，并用它AC了一道模板题：POJ 2985
简要题意：有N只猫,开始每只猫都是一个小组,下面要执行M个操作,操作0 i j 是把i猫和j猫所属的小组合并,操作1 k 是问你当前第k大的小组大小是多少. 且k<=当前的最大组数。
思路：并查集+Treap，并查集维护集合合并，Treap负责查询第K大。可以只把合并后的组扔到Treap里，做一个优化。

AC代码：

#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<cassert>
#include<iostream>
using namespace std;
struct Node
{
    Node *ch[2];
    int r,v,s;//s表示节点数

    Node(int v):v(v)
    {
        ch[0]=ch[1]=NULL;
        r=rand();//在cstdlib头声明
        s=1;
    }

    int cmp(int x)
    {
        if(x==v)return -1;
        return x<v?0:1;
    }
    void maintain()
    {
        s=1;
        if(ch[0]!=NULL) s+=ch[0]->s;
        if(ch[1]!=NULL) s+=ch[1]->s;
    }
} *root;
void rotate(Node* &o,int d)
{
    Node *k=o->ch[d^1];
    o->ch[d^1]=k->ch[d];
    k->ch[d]=o;
    o->maintain();
    k->maintain();
    o=k;
}
void insert(Node* &o,int x)//o子树中事先不存在x
{
    if(o==NULL) o=new Node(x);
    else
    {
        //如这里改成int d=o->cmp(x);
        //就不可以插入相同的值，因为d可能为-1
        int d=x<(o->v)?0:1;
        insert(o->ch[d],x);
        if(o->ch[d]->r > o->r)
            rotate(o,d^1);
    }
    o->maintain();
}

void remove(Node* &o,int x)
{
    if(o==NULL) return ;//空时返回

    int d=o->cmp(x);
    if(d==-1)
    {
        Node *u=o;
        if(o->ch[0] && o->ch[1])
        {
            int d2=(o->ch[0]->r < o->ch[1]->r)?0:1;
            rotate(o,d2);
            remove(o->ch[d2],x);
        }
        else
        {
            if(o->ch[0]==NULL) o=o->ch[1];
            else o=o->ch[0];
            delete u;//这个要放里面
        }
    }
    else remove(o->ch[d],x);
    if(o) o->maintain();//之前o存在,但是删除节点后o可能就是空NULL了,所以需要先

判断o是否为空
}

//返回关键字从小到大排序时的第k个值
int kth(Node* o,int k)
{
    //assert(o && k>=1 && k<=o->s);//保证输入合法
    if(!(o && k>=1 && k<=o->s)) return 1;
    int s=(o->ch[1]==NULL)?0:o->ch[1]->s;
    if(k==s+1) return o->v;
    else if(k<=s) return kth(o->ch[1],k);
    else return kth(o->ch[0],k-s-1);
}

//返回值x在树中的排名,就算x不在o树中也能返回排名
//返回值范围在[1,o->s+1]范围内
int rank(Node* o,int x)
{
    if(o==NULL) return 1;//未找到x;

    int num= o->ch[0]==NULL ? 0:o->ch[0]->s;
    if(x==o->v) return num+1;
    else if(x < o->v) return rank(o->ch[0],x);
    else return rank(o->ch[1],x)+num+1;
}

const int MAXN = 2e5 + 5;
int far[MAXN], rnk[MAXN], siz[MAXN];

int Find(int x) {
    if(far[x] == x) return x;
    return far[x] = Find(far[x]);
}
void Unite(int x, int y) {
    x = Find(x);
    y = Find(y);
    if(x == y) return;
    if(rnk[x] > rnk[y]) swap(x, y);
    if(siz[x] > 1) remove(root, siz[x]);
    if(siz[y] > 1) remove(root, siz[y]);
    insert(root, siz[x] + siz[y]);
    far[x] = y;
    siz[y] += siz[x];
}
int main()
{
    int N, M;
    cin >> N >> M;
    for(int i = 1; i <= N; i++) {
        far[i] = i;
        rnk[i] = 0;
        siz[i] = 1;
    }
    root = NULL;
    while(M--) {
        int c;
        scanf("%d", &c);
        if(c == 0) {
            int x, y;
            scanf("%d%d", &x, &y);
            Unite(x, y);
        } else {
            int m;
            scanf("%d", &m);
            printf("%d\n", kth(root, m));
        }
    }
    return 0;
}

据说这道题可以用树状数组来A，而且代码比Treap短，我再去学习一波~

伟大的蚊子
关注
专栏目录
数据结构之Treap
cinience的专栏
04-20 736
作者:Dong | 可以转载, 但必须以超链接形式标明文章原始出处和作者信息及版权声明 网址:http://dongxicheng.org/structure/treap/ 1. 概述 同splay tree一样，treap也是一个平衡二叉树，不过Treap会记录一个额外的数据，即优先级。Treap在以关键码构成二叉搜索树的同时，还按优先级来满足堆的性质。因而，Treap=tre
treap 排序二叉树的模板
moon_NO2015的博客
08-21 457
 Description 有一个序列含有一定数量的元素，现在要求写一个程序，满足以下几个要求： 【A】支持插入操作（这个序列不允许有重复元素，即是说，如果待插入的元素已经出现在这个序列中，那么请忽略此操作） 【B】支持删除操作（如果此序列中不包含待删除的这个元素，则忽略此操作，否则删除这个元素） 【C】查找元素x的前继元素（前继元素是指：小于x且与x最接近的元素，当然，如果x已经是序列
Treap原理和实现方法
热门推荐
ACdreamer
09-07 1万+
Treap是一棵二叉搜索树，只是每个节点多了一个优先级fix，对于每个节点，该节点的优先级小于等于其所有孩子的优先级。   所以，这样看来就是：Treap中对于节点的关键字key来说，它是一棵二叉搜索树，而对于fix来说，它是一个最小堆，所以 Treap可以看成是Tree+Heap，只是这里的Heap不一定是完全二叉树。Treap的平均时间复杂度为log(n).   Treap跟笛卡尔树
数据结构之Treap详解
09-04
【数据结构之Treap详解】 Treap是一种结合了二叉搜索树（BST）和堆（Heap）特性的数据结构，其名称由“tree”和“heap”组合而成。Treap的特点在于每个节点不仅包含键值，还包含一个优先级，这个优先级通常是随机...
treap：有效实现隐式treap数据结构
02-04
5. **Haskell中的Treap实现** - 在Haskell这样的纯函数式编程语言中，数据结构的实现通常更加抽象和概念化。在Haskell中，Treap可以通过Monoid和Homomorphism等高级概念来实现。 - Monoid是一个具有零元素和结合律...
深入Treap平衡树算法与数据结构应用
本章内容主要集中在平衡树的数据结构之一——Treap的介绍和应用。Treap是一种结合了二叉搜索树和堆数据结构特点的平衡二叉树，它能有效地支持动态集合操作，如查找、插入和删除操作。在描述中，我们了解到该资源主要...
Treap数据结构详解：操作与应用
6. Treap与其他数据结构的比较： - 相比AVL树和红黑树，Treap的插入和删除操作更简单，但平衡调整可能更频繁。 - 与Splay树相比，Treap在插入和删除操作上同样高效，但Splay树优化了最近访问的节点的访问速度。 7...
数据结构详解：Treap的构造与操作
数据结构之Treap详解深入剖析了平衡二叉树的一种特殊变体——Treap（二叉搜索树与堆的结合）。Treap的独特之处在于每个节点除了包含常规的键值对外，还额外记录了一个优先级。这种设计使得Treap同时具备二叉搜索树的...
treap的实现及应用
DeepStarSky的博客
12-30 587
treap及非旋转treap的实现
Treap树概念及应用
ComingLiu的博客
01-30 587
Treap树概念实现结构旋转操作左旋和右旋右旋左旋旋转总结插入操作删除操作第K大 概念 Treap一词是Tree和Heap的合成词，也就是这是一颗带有堆性质的树，即树堆，Treap树是一种排序二叉树（也成二叉搜索树、二分检索树 Binary Serach Tree），简称BST，也就是满足value值大小关系是左孩子<根<右孩子，这样就满足了排序二叉树，刚才讲过，Treap树还满足堆的性质，那么它的哪个值满足堆的性质呢，并不是value，而是一个优先级rank值，这个rank值是人为添加的，一
Treap树实现
weixin_53388254的博客
08-14 272
Treap树是BST算法中的一种，Treap是由Tree和Heap各取一半组成的词，即Treap是树和堆的结合。二叉搜索树每个节点都有一个键值，而Treap树多了一个被称为优先级的权值，根结点的优先级最大。 Treap树其基本操作（插入，删除，查询）的期望时间复杂度为O(​​​​)。相对于其他的平衡二叉搜索树，Treap的特点是实现简单，且能基本实现随机平衡的结构，Treap树维护堆平衡的方式是旋转，包括左旋和右旋。。Treap树还有FHQ_Treap树（无旋Treap树），这里只做介绍。 Tr
Treap
code
03-31 2793
Treap         Treap是一种动态平衡的BST(Binary Search Tree)，它每个节点拥有键值和优先级两种属性。对于键值而言，它是一颗排序二叉树。对于优先级而言，这棵树是堆(优先级最高的是根节点)。可以证明Treap中插入，删除和查找的期望时间复杂度均为O(logn)。关于Treap的更多介绍，可见刘汝佳《训练指南》P230。 一般我们用Treap就是用来替代平衡二叉
Treap的实现方法 [BZOJ 3224]
江澤妮可
06-01 549
传说，有一种排序二叉树叫做Treap。 而 Treap = Tree + Heap 所以，Treap既具有树，也具有堆的性质。 它的基本操作和普通的树相近，但也有一些差异。（以上全部为乱讲系列）（如果要看详细介绍，这里给出lmy大神关于平衡树的研究讲解http://blog.csdn.net/lemonoil/article/details/54405613)（详细介绍之后会补充的）如何写出一
Acwing_265营业额统计【平衡树Treap】
DJL新时代农民工DJL
08-19 159
题目链接:Acwing_265营业额统计 思路很简单,平衡树的话可以自己手写一个或者利用set集合也可以做这个题目 #include <iostream> #include <ctime> #include <cstdio> using namespace std; typedef long long LL; const int N = 34000, INF = 1e7; int n, idx, root; LL res; struct Node{ int l,
树堆（Treap）图文详解与实现
Dablelv 的博客专栏。
03-05 1万+
1.Treap的定义树堆（Treap）是二叉排序树（Binary Sort Tree）与堆（Heap）结合产生的一种拥有堆性质的二叉排序树。但是这里要注意两点，第一点是Treap和二叉堆有一点不同，就是二叉堆必须是完全二叉树，而Treap并不一定是；第二点是Treap并不严格满足平衡二叉排序树（AVL树）的要求，即树堆中每个节点的左右子树高度之差的绝对值可能会超过1，只是近似满足平衡二叉排序树的性质...
《数据结构与算法分析》第十二章，AA-树，Treap树简要介绍与实现
yw8355507的专栏
10-16 1213
前言：        这里我要介绍的这4个数据结构，是在《数据结构与算法分析》一书上的最后4种数据结构了。这些数据结构给出来了实现的代码，实现的难度并不大，一天之内我就把这四个数据结构的测试代码给调通了。        这四个数据结构里，一个是红黑树的变种，对红黑树进行了化简，一个是为了多维查询范围所设计的数据结构。最后一个是变种的斐波那契堆,目的同样是为了化简实现。本来我想这几个数据
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值