数据结构（5） treap

已于 2023-01-18 22:41:02 修改
阅读量1.3k 收藏
点赞数
分类专栏： 摆烂日记from acwing 文章标签： 数据结构 算法
于 2023-01-18 22:40:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_64197656/article/details/128731036
版权
Treap是一种自平衡的二叉查找树，通过结合堆的性质和随机权值来保证操作的平均时间复杂度为logN。插入和删除操作通过旋转保持平衡，同时维护BST和堆的性质。文章详细介绍了Treap的结构、操作方法以及如何实现插入、删除等基本操作。
摘要由CSDN通过智能技术生成

活动 - AcWing

参考—《算法竞赛进阶指南》-lyd

目录

一、概述

二、具体操作详解

1.常见操作

 2.结构定义

3.操作基础函数

（1）pushup

 （2） 获得一个新节点

（3）左旋右旋

（4）建树

（5）插入操作（如插入k）

（6）删除操作

（7） 查询操作

实际应用

 

一、概述

满足bst性质的二叉查找树不是唯一的。我们可以通过改变二叉查找树的形态，使得左右子树大小达到平衡，从而使整棵树的深度维持在logn级别。

改变方式分为“左旋”和“右旋”。具体方式请参考数据结构教材。

Treap是tree和heap的合成词。如果节点值是随机的，那么构成的树深度平均为logn级别。

Treap在插入新节点时，给该节点一个随机的权值。然后像二叉堆的插入过程一样，自底向上检查，当某个节点不满足大根堆性质的时候就执行单旋转，使得该点与其父节点的关系发生对换。

特别地，对于删除操作，我们可以直接把删除节点向下旋转成叶节点，然后直接删掉。

总之，Treap通过适当的单旋转，维持了bst性质，同时还使得节点上随机生成的额外权值满足大根堆性质。所有操作都是logN级别。

二、具体操作详解

1.常见操作

 2.结构定义

int n;
struct Node{
    int l,r;
    int key,val;
    int cnt,size;
}tr[N];

int root,idx;

l，r表示左右子节点编号。key表示节点的值，val表示随机权值。cnt表示当前的key出现了多少次，size表示这整个子树有多少个节点。

cnt和size都是为了满足根据排名求值 和根据值求排名这两个操作设立的

3.操作基础函数

（1）pushup

根据子节点计算size。为了3 4操作

void pushup(int p)
{
    tr[p].size=tr[tr[p].l].size+tr[tr[p].r].size+tr[p].cnt;
}

 （2） 获得一个新节点

int get_node(int key)
{
    tr[++idx].key=key;
    tr[idx].val=rand();
    tr[idx].cnt=tr[idx].size=1;
    return idx;
}

（3）左旋右旋

注意引用

void zig(int &p)//右旋
{
    int q=tr[p].l;
    tr[p].l=tr[q].r,tr[q].r=p,p=q;
    pushup(tr[p].r),pushup(p);
}

void zag(int &p)
{
    int q=tr[p].r;
    tr[p].r=tr[q].l,tr[q].l=p,p=q;
    pushup(tr[p].l),pushup(p);
}

（4）建树

安排两个哨兵。哨兵先后顺序不要反了。

void build()
{
    get_node(-INF),get_node(INF);
    root=1,tr[root].r=2;
    pushup(root);
    
    if(tr[1].val<tr[2].val) zag(root);
}

（5）插入操作（如插入k）

如果p为空，就创建一个新节点。

如果当前key==k，则该节点cnt++

如果大于k，则在左子树插入，回溯时根据需要右旋

如果小于k，则在右子树插入，回溯时根据需要左旋

最后对每个节点，由于插入改变了子树信息，所以要pushup当前节点

void insert(int &p,int key)
{
    if(!p) p=get_node(key);
    else if(tr[p].key==key) tr[p].cnt++;
    else if(tr[p].key>key)
    {
        insert(tr[p].l,key);
        if(tr[tr[p].l].val>tr[tr[p].r].val) zig(p);
    }
    else
    {
        insert(tr[p].r,key);
        if(tr[tr[p].r].val>tr[tr[p].l].val) zag(p);
    }
    pushup(p);
}

（6）删除操作

如果空节点，则无意义，直接return

如果当前节点key==k：

        如果cnt>1，直接cnt--即可

        如果不是叶节点：

                如果没有右子树，或者需要右旋：就右旋，然后递归在p的右子树上删除

                对应的如果没有左子树或者需要左旋：就左旋，然后递归左子树

        剩下情况为叶节点：直接p=0删除即可

如果当前节点key>k 递归左子树

else 递归右子树

最后依然需要记得pushup！！！！

void remove(int &p,int key)
{
    if(!p) return;
    if(tr[p].key==key)
    {
        if(tr[p].cnt>1) tr[p].cnt--;
        else if(tr[p].l||tr[p].r)
        {
            if(!tr[p].r||tr[tr[p].l].val>tr[tr[p].r].val)
            {
                zig(p);
                remove(tr[p].r,key);
            }
            else
            {
                zag(p);
                remove(tr[p].l,key);
            }
        }
        else p=0;
    }
    else if(tr[p].key>key) remove(tr[p].l,key);
    else remove(tr[p].r,key);
    pushup(p);
}

（7） 查询操作

int get_rank_by_key(int p,int key)
{
    if(!p) return 0;
    if(tr[p].key==key) return tr[tr[p].l].size+1;
    if(tr[p].key>key) return get_rank_by_key(tr[p].l,key);
    return tr[tr[p].l].size+tr[p].cnt+get_rank_by_key(tr[p].r,key);
}

int get_key_by_rank(int p,int rank)
{
    if(!p) return INF;
    if(tr[tr[p].l].size>=rank) return get_key_by_rank(tr[p].l,rank);
    if(tr[tr[p].l].size+tr[p].cnt>=rank) return tr[p].key;
    return get_key_by_rank(tr[p].r,rank-tr[tr[p].l].size-tr[p].cnt);
}

int get_prev(int p,int key)
{
    if(!p) return -INF;
    if(tr[p].key>=key) return get_prev(tr[p].l,key);
    return max(tr[p].key,get_prev(tr[p].r,key));
    
}
int get_next(int p, int key)    // 找到严格大于key的最小数
{
    if (!p) return INF;
    if (tr[p].key <= key) return get_next(tr[p].r, key);
    return min(tr[p].key, get_next(tr[p].l, key));
}

完整代码：

#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;

const int N =1e5+10,INF=1e8;

int n;
struct Node{
    int l,r;
    int key,val;
    int cnt,size;
}tr[N];

int root,idx;

void pushup(int p)
{
    tr[p].size=tr[tr[p].l].size+tr[tr[p].r].size+tr[p].cnt;
}

int get_node(int key)
{
    tr[++idx].key=key;
    tr[idx].val=rand();
    tr[idx].cnt=tr[idx].size=1;
    return idx;
}

void zig(int &p)//右旋
{
    int q=tr[p].l;
    tr[p].l=tr[q].r,tr[q].r=p,p=q;
    pushup(tr[p].r),pushup(p);
}

void zag(int &p)
{
    int q=tr[p].r;
    tr[p].r=tr[q].l,tr[q].l=p,p=q;
    pushup(tr[p].l),pushup(p);
}

void build()
{
    get_node(-INF),get_node(INF);
    root=1,tr[root].r=2;
    pushup(root);
    
    if(tr[1].val<tr[2].val) zag(root);
}

void insert(int &p,int key)
{
    if(!p) p=get_node(key);
    else if(tr[p].key==key) tr[p].cnt++;
    else if(tr[p].key>key)
    {
        insert(tr[p].l,key);
        if(tr[tr[p].l].val>tr[tr[p].r].val) zig(p);
    }
    else
    {
        insert(tr[p].r,key);
        if(tr[tr[p].r].val>tr[tr[p].l].val) zag(p);
    }
    pushup(p);
}

void remove(int &p,int key)
{
    if(!p) return;
    if(tr[p].key==key)
    {
        if(tr[p].cnt>1) tr[p].cnt--;
        else if(tr[p].l||tr[p].r)
        {
            if(!tr[p].r||tr[tr[p].l].val>tr[tr[p].r].val)
            {
                zig(p);
                remove(tr[p].r,key);
            }
            else
            {
                zag(p);
                remove(tr[p].l,key);
            }
        }
        else p=0;
    }
    else if(tr[p].key>key) remove(tr[p].l,key);
    else remove(tr[p].r,key);
    pushup(p);
}

int get_rank_by_key(int p,int key)
{
    if(!p) return 0;
    if(tr[p].key==key) return tr[tr[p].l].size+1;
    if(tr[p].key>key) return get_rank_by_key(tr[p].l,key);
    return tr[tr[p].l].size+tr[p].cnt+get_rank_by_key(tr[p].r,key);
}

int get_key_by_rank(int p,int rank)
{
    if(!p) return INF;
    if(tr[tr[p].l].size>=rank) return get_key_by_rank(tr[p].l,rank);
    if(tr[tr[p].l].size+tr[p].cnt>=rank) return tr[p].key;
    return get_key_by_rank(tr[p].r,rank-tr[tr[p].l].size-tr[p].cnt);
}

int get_prev(int p,int key)
{
    if(!p) return -INF;
    if(tr[p].key>=key) return get_prev(tr[p].l,key);
    return max(tr[p].key,get_prev(tr[p].r,key));
    
}
int get_next(int p, int key)    // 找到严格大于key的最小数
{
    if (!p) return INF;
    if (tr[p].key <= key) return get_next(tr[p].r, key);
    return min(tr[p].key, get_next(tr[p].l, key));
}

int main()
{
    build();
    cin>>n;
    while(n--)
    {
        int op,x;
        cin>>op>>x;
        if(op==1)   insert(root,x);
        else if(op==2)  remove(root,x);
        else if(op==3)  cout<<get_rank_by_key(root,x)-1<<endl;
        else if(op==4)  cout<<get_key_by_rank(root,x+1)<<endl; 
        else if(op==5)  cout<<get_prev(root,x)<<endl;
        else
        {
            cout<<get_next(root,x)<<endl;
        }
    }
    
    return 0;
}

实际应用

#include<iostream>
#include<algorithm>
#include<cstring>
#include<cstdio>
using namespace std;

const int N =33010,INF=1e8;
typedef long long LL;

int n;
struct Node{
    int l,r;
    int key,val;
}tr[N];

int root,idx;

int get_node(int key)
{
    tr[++idx].key=key;
    tr[idx].val=rand();
    return idx;
}

void zig(int &p)
{
    int q=tr[p].l;
    tr[p].l=tr[q].r,tr[q].r=p,p=q;
}

void zag(int &p)
{
    int q=tr[p].r;
    tr[p].r=tr[q].l,tr[q].l=p,p=q;

}

void build()
{
    get_node(-INF),get_node(INF);
    root=1,tr[root].r=2;
    //if(tr[root].val<tr[tr[root].r].val) zag(root);
}

void insert(int &p,int key)
{
    if(!p) p=get_node(key);
    else if(tr[p].key==key) return;
    else if(tr[p].key>key)
    {
        insert(tr[p].l,key);
        if(tr[tr[p].l].val>tr[p].val) zig(p);
    }
    else
    {
        insert(tr[p].r,key);
        if(tr[tr[p].r].val>tr[p].val) zag(p);
    }

}

int get_prev(int p,int key)
{
    if(!p) return -INF;
    if(tr[p].key>key) return get_prev(tr[p].l,key);
    return max(tr[p].key,get_prev(tr[p].r,key));
}

int get_next(int p,int key)
{
    if(!p) return INF;
    if(tr[p].key<key) return get_next(tr[p].r,key);
    return min(tr[p].key,get_next(tr[p].l,key));
}

int main()
{
    build();
    cin>>n;

    LL res=0;
    for(int i=1;i<=n;i++)
    {
        int x;
        cin>>x;
        if(i==1) res+=x;
        else res+= min(x - get_prev(root,x),get_next(root,x)-x);
        insert(root,x);
    }
    cout<<res;
    return 0;
}

作者：yankai
链接：https://www.acwing.com/activity/content/code/content/5279849/
来源：AcWing
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

BlessingSoftware1
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构8——无旋Treap
frankchenfu的博客
12-21 167
无旋Treap
【学习笔记】数据结构：无旋Treap
LeeCongWei的博客
01-02 1020
最近学习了一下无旋Treap，发现无旋Treap真的太好打了，而且也很好理解，很好用。 Treap? 什么是Treap？ 顾名思义：Treap=Tree+heap，即“树堆”，“树”指的是二叉查找树，“堆”就是堆。 那二叉查找树跟堆有什么关系呢？ 当输入的数据十分恶心的时候，普通的二叉查找树的时间复杂度就会由 nlog2nnlog_2nnlog2​n 退化到 n2n^2n2 级别，时间复杂度难以让人接受。 而我们现在考虑优化，我们可以在每一个节点上多放一个数，然后使得这棵树既满足二叉排序树的性质也满足堆的性
线段树详解 原理解释 + 构建步骤 + 代码（带模板）
Cosmoshhhyyy的博客
07-29 1844
线段树（Segment Tree）是一种常用的数据结构，用于解决涉及区间查询的问题。它主要用于在数组或列表等数据结构上支持以下两类查询操作：区间查询：查询某个区间内的统计信息，例如求和、最大值、最小值等。区间更新：修改数组中某个区间元素的值，并相应地更新线段树中的信息。
python高级算法与数据结构:treap用于构造平衡二叉树的算法分析
tyler_download的专栏
10-16 331
treap数据结构用于记录两个维度的索引，一个维度跟随二叉树性质，能做到完全排序，另一个维度跟随堆性质，能做到部分排序，实际上treap本质目的并不在于此，它的目的在于用来平衡二叉树。在某些情况下二叉树可能会变成链表，例如依次插入已经排好序的元素时，所有的元素会沿着节点的有孩子，这种二叉树就不具备lg(n)搜索效率。 很多方法用来解决这个问题，例如2-3树，红黑树等。这些方法存在问题在于操作相当复杂，你去搜索一下红黑树的插入或删除操作就能体会它们应用起来的复杂性。前几节详细描述了treap如何根据其节点优先
线段树区间合并小结
sunyutian1998的博客
03-20 3309
个人感觉区间合并是线段树各种应用中变形最多 也是比较难琢磨的一种 (以下以求01序列中最长连续1为例) tree[cur].left代表以区间左端点为起点的连续段的长度 tree[cur].right代表右边 tree[cur].all代表该区间内最长的连续段 通过这三个变量的组合 对于每一个区间一般有四个值供我们使用 1 tree[cur].left代表以该区间左端点为起点的连续段的长度...
Treap树堆
weixin_57128596的博客
12-23 682
主要体现的思想是随机插入数字，会给每个数字赋予一个优先级——>目的是让插入的关键字满足二叉树（节点的性质满足=（关键字:优先级））特点：被旋转的节点的左子树会到原父节点的右子树上（节点左旋，那么节点的右子树还是一直挂着保护着的）2.后面发现关键字2的优先级
treap详解
zhaochuanfei666的博客
12-03 1201
Treap详解 Treap=Tree+Heap Treap中每个节点有2个值，其中一个满足二叉查找树的性质，一个满足大根堆的性质。把满足二叉查找树性质的值称作data，把满足大根堆性质的值称作value。 对于Treap来说，当前节点的data值大于左儿子，小于右儿子。当前节点的value值小于儿子节点的值。 每个节点的data我们无法改变，为了保证Treap的平衡性，我们需要让每个节点的value均为随机值，这样我们就可以保证这棵树“基本平衡”。 统计 up：计算儿子数 void up(int x) {
数据结构之Treap详解
09-04
【数据结构之Treap详解】 Treap是一种结合了二叉搜索树（BST）和堆（Heap）特性的数据结构，其名称由“tree”和“heap”组合而成。Treap的特点在于每个节点不仅包含键值，还包含一个优先级，这个优先级通常是随机...
数据结构入门基础1
08-08
5. **自定义数据结构**：如课程中的`Array`类，提供了二次封装的数组功能，可以动态地添加元素，同时避免了不必要的内存浪费。 学习数据结构能帮助我们理解算法背后的逻辑，设计更高效的程序。注意，选择合适的数据...
treap：有效实现隐式treap数据结构
02-04
**Treap：高效实现隐式Treap数据结构** Treap（树堆）是一种结合了随机化和二叉搜索树特性的数据结构，由Russo和Sedgewick在1989年提出。它的核心思想是将二叉搜索树与堆属性相结合，通过随机化的方式确保良好的...
treap代码实现
02-19
void Insert(Node * &o,int x){//0为左子树，1为右子树 if(o==NULL){o = new Node(); o->ch[0]=o->ch[1]=NULL;o->key=x;o->weight=rand();} else{ int d=o->cmp(x); Insert(o->ch[d],x); if(o->ch[d]->weight>o->weight) rotate(o,d^1); } }
常用数据结构 - C语言实现
06-18
数据结构 NOTONLLY的SBT模板.cpp NOTONLLY的划分树模板.cpp NOTONLLY的后缀数组模板.cpp RMQ-ST算法.cpp RMQ线段树.cpp SBT.cpp SBT2.cpp splay伸展树.cpp ST表.cpp Treap.cpp Trie树.cpp 二叉堆.cpp 二维线段树.cpp...
刷题算法提高阶段-数据结构6
12-22
其中，"4.5 平衡树-Treap.mp4"这个文件名提到了一个具体的平衡树类型——Treap，它是数据结构学习中的一个重要部分。 **Treap（树堆）** 是一种结合了二叉搜索树（BST）和堆属性的数据结构。它由Carlos R. Păcu于...
【数据结构】图文详解Treap平衡树
qq_49688477的博客
07-27 1677
一、前言 FHQ平衡树是一种树形数据结构，它是对二叉查找树的一种优化方式，但是学习的过程是真的非常的…痛苦。 二、二叉查找树的概念 首先，我们称具有以下3个性质的树为二叉查找树（BST） 1.左子树上所有结点的值均小于或等于它的根结点的值。 2.右子树上所有结点的值均大于或等于它的根结点的值。 3.左、右子树也分别为二叉排序树。 如图 在这张图中我们可以发现，在二叉查找树中，从根结点开始查找一个点的时间复杂度为logn级别，在我们想对树进行插入查找的时候都非常方便。 但是很遗憾，二叉查找树是有着它的缺陷的
【c++提高1】数据结构之线段树详解
小学生蒟蒻
09-09 1784
线段树的思想是将一个区间[1, n]划分成两个区间： [1, n/2]和[n/2+1, n]，接下来继续划分： [1, n/4], [n/4+1,n/2]和[n/2+1, n/2+n/4-1], [n/2+n/4,n] …示例：n = 81.pushup函数2.pushdown3.build4.modify5.query1.线段树的儿子存储2.线段树的节点信息存储 定义一个结构体，里面存储改节点信息和当前这个节点所管辖的区间的左右端点。1.建树函数build 递归建树。 怎样判断当前节点是叶子节点呢？2.查
Treap
wsyear的博客
03-02 367
Treap=Tree+Heap,介绍Treap思路及常用操作
【数据结构】Treap树堆
qq_23096319的博客
05-06 597
Treap就是Tree+heap，首先有二叉搜索树（BST）的数据，treapCnt记录当前的节点总数，节点和键值的映射key，每个节点的左右儿子childs，以及一个键可能存在多个副本，用cnt记录副本数，size记录子树大小，用于查找第k大元素。堆相关的数据：每个节点的优先级priority，这个优先级在创建节点时随机生成，保证了Treap的深度不会太大。
数据结构之Treap
cinience的专栏
04-20 722
作者:Dong | 可以转载, 但必须以超链接形式标明文章原始出处和作者信息及版权声明 网址:http://dongxicheng.org/structure/treap/ 1. 概述 同splay tree一样，treap也是一个平衡二叉树，不过Treap会记录一个额外的数据，即优先级。Treap在以关键码构成二叉搜索树的同时，还按优先级来满足堆的性质。因而，Treap=tre
排序（归并排序，非比较排序）
最新发布
qq_63074244的博客
08-20 957
稳定性：假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的 相对次序保持不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，⽽在排序后的序列中，r[i]仍在r[j]之 前，则称这种排序算法是稳定的；否则称为不稳定的。数据结构结构初阶的排序基本上总结完毕了，这里我学了冒泡，插入，选择，快排，希尔，堆，归并，计数排序，这几种排序在时间复杂度，空间复杂度以及稳定性上各有各的优点。下面我们用一张图进行总结。
并查集与高级数据结构——Treap树删除
"Treap树的删除-第5章高级数据结构(上) - 罗勇军 华东理工大学 数据结构 教材" 在高级数据结构中，Treap树是一种结合了二叉搜索树（BST）和堆特性的数据结构。它的主要优势在于通过随机化策略来保持树的平衡，从而...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值