Treap

最新推荐文章于 2024-08-09 10:36:46 发布
最新推荐文章于 2024-08-09 10:36:46 发布
阅读量79 收藏
点赞数
文章标签： 数据结构与算法
原文链接：http://www.cnblogs.com/guoshaoyang/p/11300886.html
版权

Treap介绍

概述

Treap是平衡树大家族的一员，是众多平衡树中最基础、最容易实现的，常数也不大。可以维护权值（常用）和区间。
Treap是Tree和Heap的合成词，其既有二叉查找树BST的性质，又有堆Heap的性质，于是有能维护排名，有能保证深度在\(\Theta(\log N)\)的量级

申明：本文借鉴于【洛谷日报#119】浅析Treap

BST

概念

BST，即二叉查找树，是指对于任意节点，保证根左侧子树的所有节点比根小，右侧的所有节点比根大的树（没有相同节点），如图。

1593057-20190805075925559-1911487497.png

操作
查询x的排名

只要将x与根比较，如果相等，排名为左子树元素个数+1；
如果比根小，递归查询他在左子树的排名，排名为他在左子树的排名，空树排名为0；
如果比根大，递归查询他在右子树的排名，排名为右子树的排名+左子树元素个数+1

查询排名为x的数

先判断左子树元素个数是否大于等于x，
如果是就在左子树找，否则，如果刚好为左子树元素个数+1，就是根；
如果大于左子树元素个数+1，则必定在右子树。
思想和查询x的排名类似

插入x

我们不断地判断x与根的大小关系，
比根小，则递归左子树；比根大，则递归右子树，
直到来到一个空树，插入。

1593057-20190805075940395-345115956.png

删除x

如果一个节点是叶子节点，直接删除；否则，如果这个节点有一个子节点，直接将其连接到该节点的父亲；否则，沿着右子树的根一路向左到底，然后用那个值替换掉要删除的节点。
例如我们要删7时，会选定8和7交换，然后递归删除7（注意8可能有右子树）

1593057-20190805080002474-543313556.png

分析

BST支持Treap的所有一般操作，功能齐全，实现简单，在随机数据下也比Treap等平衡树快很多。

但BST毕竟不能维护树的平衡，BST的复杂度取决于它的平均深度，在特定数据下树会退化为链，使深度为线性，于是单次操作的复杂度会提升到\(\Theta(N)\)，明显不够优。

于是，我们需要引入Treap的下一个性质：Heap

Heap

概念

Heap，即堆，是一种保证任意节点的左右儿子都比自身小的完全二叉树，其深度始终保持在\(\log N\)的数量级，刚好符合了我们的需求

操作
查询

堆的根部即为最值，直接调取即可，但此处我们不需要用堆的这种性质。

插入

我们将新节点插入二叉树底端，

1593057-20190805080024680-1439923014.png

然后不断让新节点往上跳，直到它小于它的父亲或者自己为根

1593057-20190805080035654-1090673461.png

1593057-20190805080049933-610288333.png

删除

我们用二叉树底端的节点覆盖根，然后让新的根与左右儿子比较，用较大的儿子替换根，如此往复即可

1593057-20190805080138876-1190926406.png

1593057-20190805080152427-1428625975.png

1593057-20190805080208767-1473740083.png

Treap

概念

Treap就是集BST、Heap二者的性质于一身，即能够支持BST的操作，有能够保证Heap的深度。

可惜的是，BST和Heap的性质似乎有些矛盾，前者是左子树<根<右子树，后者是根<左儿子<右儿子。

其实Treap的本质还是BST，对于任意节点，保证根左侧子树的所有节点比根小，右侧的所有节点比根大的树（没有相同节点）。我们只是利用堆的性质，赋予每一个节点一个随机值，按照随机值维护堆的形状。于是我们需要一个操作，既能保持BST的性质，又能够将根节点与儿子替换，于是我们需要Treap的核心——旋转操作

旋转

rotate，即旋转操作，分为zig左旋和zag右旋，其思想是一致的，也可以统一实现，故一起介绍
rotate的目标是将一个儿子移到根处，并且在此过程中保持BST的性质。此处我们以右旋为例讲述（举Luogu日报上的例子）

1593057-20190805080232262-692433817.png

右旋以后效果为

1593057-20190805080250530-1159436609.png

其中爹成功走到了爷爷辈，并使爷爷到了爹的子辈，符合Heap调整的需求，而此时在BST的大小关系上
旋转前：你<爹<小明<爷爷<叔叔 
旋转后：你<爹<小明<爷爷<叔叔 
于是BST的性质没变，我们就可以肆无忌惮地用rotate调整Heap了！

分析

于是，我们在BST的前提下保证了Heap的深度，单词操作复杂度为\(\Theta(\log N)\)，足够优秀

实现

初始化

  • size[i]——以i为根的子树的节点数

  • key[i]——i节点的关键字

  • cnt[i]——由于可能有重复，所以存储的是i节点关键字的个数

  • son[i][2]——存储i节点的儿子，son[i][0]表示左儿子，son[i][1]表示右儿子。 

  • rd[i]——i节点的一个随机值，是在堆中的关键字？

push_up归并

顾名思义，拿儿子更新父亲p的节点数。p的节点数=左右儿子节点数之和+p本身存有数量

inline void push_up(int x){
    siz[x]=siz[son[x][0]]+siz[son[x][1]]+cnt[x];
}
rotate旋转

rotate(&p,d)——以p为根（可能有变）旋转，d=0左旋，d=1右旋

inline void rotate(int &x,int y){
    int ii=son[x][y^1];
    son[x][y^1]=son[ii][y];
    son[ii][y]=x;
    push_up(x);
    push_up(ii);
    x=ii;
}

让我们以d=0时左旋为例：

        A                         
       / \              
      B   C               
         / \              
        D   E

k=p的右儿子（暂时保存）

p的右儿子变成k的左儿子

        A(p)                         
       / \              
      B   D   C(k)               
               \              
                E                     

k的左儿子变成p

        C(k)
       / \
   (p)A   E
     / \   
    B   D

然后先pushup子代p的，再pushup父代k的

最后换根即可

        C(p)
       / \
      A   E
     / \   
    B   D
insert插入

ins(&p,x)——根为p，插入节点x

void ins(int &p,int x){
    if(!p){
        p=++sz;
        siz[p]=cnt[p]=1;
        key[p]=x;
        rd[p]=rand();
        return;
    }
    if(key[p]==x){
        cnt[p]++;
        siz[p]++;
        return;
    }
    int d=(x>key[p]);
    ins(son[p][d],x);
    if(rd[p]<rd[son[p][d]])
        rotate(p,d^1);
    push_up(p);
}

分类讨论

  1. p==0，也就是说当前是一个空节点 ，
    那么节点总数++，然后开辟一个新节点 。
    size[p]=1，共有1个节点在树中 ，
    v[p]=x，值为x ，
    num[p]=1，当前节点有一个重复数字 ，
    rd[p]=rand()，生成随机值，拿来维护堆。

  2. 有一个数和要插入的x重复，那么直接个数加加即可

  3. 值可能在子树中，我们需要找一个子树，使得Treap的二叉排序树性质成立
    以x>v[p]的情况为例
    d=1，此时去p的右子树。
    如果加完以后p的随机值小于它的右儿子，直接左旋调整，维护堆的性质
    x<v[p]同理

delete删除

del(&p,x)——根为p，删掉节点x

void del(int &p,int x){
    if(!p)
        return;
    if(x!=key[p])
        del(son[p][x>key[p]],x);
    else{
        if(!son[p][0]&&!son[p][1]){
            cnt[p]--;
            siz[p]--;
            if(cnt[p]==0)
                p=0;
        }else if(son[p][0]&&!son[p][1]){
            /*Ö±½Óreplace£¿*/
            rotate(p,1);
            del(son[p][1],x);
        }else if(!son[p][0]&&son[p][1]){
            rotate(p,0);
            del(son[p][0],x);
        }else{
            int d=rd[son[p][0]]>rd[son[p][1]];
            rotate(p,d);
            del(son[p][d],x);
        }
    }
    push_up(p);
}

一个一个情况来看：

  1. 空节点，根本就没这个数，直接返回

  2. 如果x和v[p]不相等，直接去相应子树解决问题

  3. 如果x=v[p]

    1. x是叶子节点，直接扣掉个数，如果个数为零删掉节点

    2. 有一个子节点，直接把子节点旋转上来，然后去相应子树解决

    3. 两个子节点，把大的那个转上来，然后去另一个子树解决

rank查询排名

rank(p,x)——根为p，查x在根为p的树中的排名

int get_rank(int p,int x){
    if(!p)
        return 0;
    if(key[p]==x)
        return siz[son[p][0]]+1;
    if(key[p]<x)
        return siz[son[p][0]]+cnt[p]+get_rank(son[p][1],x);
    /*if(key[p]>x)*/
    return get_rank(son[p][0],x);
}

  1. 空节点，直接返回掉

  2. x==v[p]，那么左子树的全部数必定小于x，直接返回左子树节点数+1

  3. x>v[p]，意味着x位于右子树，那么根和左子树一定比x小，先加上，然后再加上x在右子树里面的排名即可

  4. x<v[p]，x位于左子树，冲向左子树解决

find按排名查询值

find(p,x)——根为p，查在根为p的子树中排名为x的数

int find(int p,int x){
    if(!p)
        return 0;
    if(siz[son[p][0]]>=x)
        return find(son[p][0],x);
    else if(siz[son[p][0]]+cnt[p]<x)
        return find(son[p][1],x-cnt[p]-siz[son[p][0]]);
    else
        return key[p];
}

  1. 如果是空节点，返回特殊值

  2. 左子树节点数大于x，解在左子树中

  3. 左子树加根的节点数比x小，解在右子树中，查右子树的第x--名即可

  4. 左子树加根的节点大于等于x，意味着要找的就是当前的根节点v[p]

pre前驱

pre(p,x)——根为p，查在根为p的子树中x的前驱

int pre(int p,int x){
    if(!p)
        return -INF;
    if(key[p]>=x)
        return pre(son[p][0],x);
    else
        return max(key[p],pre(son[p][1],x));
}

  1. 空节点，没有前驱

  2. 如果x是根或在右子树，去左子树找

  3. 否则要么是根要么右子树，取一个max就可以了（前驱定义为小于x，且最大的数）

suf后继

su(p,x)——根为p，查在根为p的子树中x的后继

int suf(int p,int x){
    if(!p)
        return INF;
    if(key[p]<=x)
        return suf(son[p][1],x);
    else
        return min(key[p],suf(son[p][0],x));
}

与前驱超级类似

  1. 空节点无后继

  2. 如果在根或者左子树，去右子树找

  3. 否则要么根要么左子树，取min就可以了(后继定义为大于x，且最小的数)

例题

模板题：P3369 【模板】普通平衡树
#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const int INF=1e9+7,MAXN=1e5+10;
int sz,rt;
int siz[MAXN],key[MAXN],cnt[MAXN],rd[MAXN],son[MAXN][2];
inline void push_up(int x){
    siz[x]=siz[son[x][0]]+siz[son[x][1]]+cnt[x];
}
inline void rotate(int &x,int y){
    int ii=son[x][y^1];
    son[x][y^1]=son[ii][y];
    son[ii][y]=x;
    push_up(x);
    push_up(ii);
    x=ii;
}
void ins(int &p,int x){
    if(!p){
        p=++sz;
        siz[p]=cnt[p]=1;
        key[p]=x;
        rd[p]=rand();
        return;
    }
    if(key[p]==x){
        cnt[p]++;
        siz[p]++;
        return;
    }
    int d=(x>key[p]);
    ins(son[p][d],x);
    if(rd[p]<rd[son[p][d]])
        rotate(p,d^1);
    push_up(p);
}
void del(int &p,int x){
    if(!p)
        return;
    if(x!=key[p])
        del(son[p][x>key[p]],x);
    else{
        if(!son[p][0]&&!son[p][1]){
            cnt[p]--;
            siz[p]--;
            if(cnt[p]==0)
                p=0;
        }else if(son[p][0]&&!son[p][1]){
            rotate(p,1);
            del(son[p][1],x);
        }else if(!son[p][0]&&son[p][1]){
            rotate(p,0);
            del(son[p][0],x);
        }else{
            int d=rd[son[p][0]]>rd[son[p][1]];
            rotate(p,d);
            del(son[p][d],x);
        }
    }
    push_up(p);
}
int get_rank(int p,int x){
    if(!p)
        return 0;
    if(key[p]==x)
        return siz[son[p][0]]+1;
    if(key[p]<x)
        return siz[son[p][0]]+cnt[p]+get_rank(son[p][1],x);
    /*if(key[p]>x)*/
    return get_rank(son[p][0],x);
}
int find(int p,int x){
    if(!p)
        return 0;
    if(siz[son[p][0]]>=x)
        return find(son[p][0],x);
    else if(siz[son[p][0]]+cnt[p]<x)
        return find(son[p][1],x-cnt[p]-siz[son[p][0]]);
    else
        return key[p];
}
int pre(int p,int x){
    if(!p)
        return -INF;
    if(key[p]>=x)
        return pre(son[p][0],x);
    else
        return max(key[p],pre(son[p][1],x));
}
int suf(int p,int x){
    if(!p)
        return INF;
    if(key[p]<=x)
        return suf(son[p][1],x);
    else
        return min(key[p],suf(son[p][0],x));
}
int Q;
int main(){
    scanf("%d",&Q);
    while(Q--){
        int ii,jj;
        scanf("%d%d",&ii,&jj);
        switch(ii){
            case 1:{
                ins(rt,jj);
                break;
            }
            case 2:{
                del(rt,jj);
                break;
            }
            case 3:{
                printf("%d\n",get_rank(rt,jj));
                break;
            }
            case 4:{
                printf("%d\n",find(rt,jj));
                break;
            }
            case 5:{
                printf("%d\n",pre(rt,jj));
                break;
            }
            case 6:{
                printf("%d\n",suf(rt,jj));
                break;
            }
        }
    }
    return 0;
}

可以看到，Treap的代码比Splay简洁很多，评测时效率也略高

转载于:https://www.cnblogs.com/guoshaoyang/p/11300886.html

weixin_30955341
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
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->...
二叉搜索树（BST）详解 先了解定义，性质，然后无非是遍历+访问都弄清楚
qq_15821487的博客
09-03 402
二叉搜索树（BST）详解 </h1> <div class="clear"></div> <div class="postBody"> <div id="cnblogs_post_body" class="blogpost-body blogpost-body-html"> 前言：平衡树的前置知识吧 二叉搜索树的定义： 二叉搜索树或者是...
BST（二叉搜索树）_剑指offer23
qq_36399212的博客
04-13 182
BST（二叉搜索树） 特征： 根节点的值大于其左子树中任意一个节点的值，小于其右节点中任意一节点的值 目的： 是为了提高查找的性能，其查找在平均和最坏的情况下都是logn级别，接近二分查找。 ...
treap
zjy2015302395的博客
03-20 306
http://www.spoj.com/problems/ORDERSET/ In this problem, you have to maintain a dynamic set of numbers which support the two fundamental operations INSERT(S,x): if x is not in S, insert x into S DELE
TREAP
dengtun2502的博客
05-24 124
TREAP Treap = Tree + Heap. 树堆，在数据结构中也称Treap，是指有一个随机附加域满足堆的性质的二叉搜索树，其结构相当于以随机数据插入的二叉搜索树。其基本操作的期望时间复杂度为O(logn)。相对于其他的平衡二叉搜索树，Treap的特点是实现简单，且能基本实现随机平衡的结构。 Treap 维护堆的性质的方法只用到了左旋和右旋， 编程复杂度比Splay小一点(??...
FHQ Treap
俗世客01的博客
03-01 121
FHQ Treap 主要通过 mergemergemerge 和 spiltspiltspilt 两个操作来实现。 merge merge(x,y)merge(x,y)merge(x,y) 要求 xxx 所在子树中的元素均小于等于 yyy 所在子树中的元素，将两棵树合并，并返回合并后的根节点。 inline int merge(int x,int y){ if(!x||!y)return x+y; pushdown(x),pushdown(y); if(tr[x].dat<tr[y].dat){
Treap笔记
C_eeking的博客
08-25 331
Treap的基本实现与例题笔记
fhq Treap
weixin_51606521的博客
02-10 1720
普通Treap，既Tree加Heap。它让平衡树上的每一个结点存放两个信息：值和一个随机的索引。其中值满足二叉搜索树的性质，索引满足堆的性质，结合二叉搜索树和二叉堆的性质来使树平衡。这也是Treap的性质。 Treap用二叉堆来维护随机索引，其实就是相当于把插入次序随机化。插入一数值后你必然要让索引去满足二叉堆的特性，但又因为索引是随机的，那就会导致插入的数后不知道搞到哪里去了，相当于插入次序随机了。 （随机大法好，吊打一切毒瘤数据） fhq Treap的奇怪操作并且是核心操作只有两个：分裂和合并
数据结构之Treap详解
09-04
【数据结构之Treap详解】 Treap是一种结合了二叉搜索树（BST）和堆（Heap）特性的数据结构，其名称由“tree”和“heap”组合而成。Treap的特点在于每个节点不仅包含键值，还包含一个优先级，这个优先级通常是随机...
二叉平衡树treap详解
05-30
### 二叉平衡树Treap详解 #### 一、Treap概述 Treap是一种结合了二叉搜索树(Binary Search Tree, BST)与堆(Heap)特性的数据结构，它的名称来源于"Tree"与"Heap"两个词的组合。在Treap中，每个节点除了存储关键字外...
Treap树堆实现
11-04
**Treap树堆实现** Treap，又称为“随机优先搜索树”，是一种结合了二叉查找树（BST）和堆特性的数据结构。它在保持查找树特性的同时，通过引入随机化来保证平衡，从而避免了传统平衡二叉树如AVL或红黑树等在插入和...
基本Treap.ppt
09-17
基本Treap.ppt
双端队列Deque
最新发布
Jak的博客
08-09 448
Deque作为一个灵活且功能强大的数据结构，因其双端操作的特性，适用于广泛的场景。它的高效性能使得它在实际开发中被广泛应用，是许多算法和数据结构实现的基础。下面是基于LinkedList实现的Deque的示例，展示如何将LinkedList用作栈（LIFO）和队列（FIFO）。
LeetCode Hard｜【25. K 个一组翻转链表】
糖炒栗子
08-06 330
首先，做整表翻转的时候，我们的逻辑非常简单。这里简单直观多了，最大的区别是什么呢？
day021二叉树最后章节
m0_62956971的博客
08-06 563
思路: 二叉搜索树的中序遍历就是有序升序数组，所以想要将它在转换成二叉树，我想到的方法就是通过递归来做，通过中间节点找到二叉搜索树的根节点，然后根据left和right双指针逐层递归构造左右子树。思路:最开始没有判断当当前节点小于最小值时，当前节点的右侧节点的情况，和当前节点大于最大值时，当前节点的左节点的情况，所以出错了，因此要在代码中判断一下这两种情况。思路: 累加树 由题意可知，在二叉搜索树中的递归顺序是右中左的顺序，创建一个新的函数，进行右中左的遍历，在遍历中要将节点的值记录下来，用来做累加。
理解栈（Stack）及其在 C++ 中的应用【栈、数据结构】
qq_22841387的博客
08-07 386
栈是一种数据结构，它遵循“后进先出”（LIFO - Last In, First Out）的原则。栈就像是一叠盘子，你只能从最上面拿盘子，也只能在最上面放盘子。栈的这一特性使其在很多场景中非常有用，例如递归、回溯算法和表达式计算等。通过这篇博客，我们详细介绍了栈的基本概念及其在 C++ 中的实现。栈是一种非常有用的数据结构，尤其在处理递归、回溯和表达式计算等问题时。我们还讨论了如何将栈中的字符转换为字符串，以及如何使用栈解决括号匹配问题。
leetcode-27-移除元素
jiao_mrswang的博客
08-07 218
1、统计数组nums中出现val的次数n；2、利用循环进行n次删除nums中的val;3、返回nums的长度。
AcWing.算法提高课-第二章 搜索
m0_69379426的博客
08-07 700
ACwing算法提高课-搜索
Treap数据结构详解：操作与应用
"Treap是一种平衡二叉查找树，结合了树和堆的特性，用于高效的数据操作，如插入和删除。它通过随机化的优先级保证平衡性，从而实现平均情况下的优秀性能。本文深入探讨了Treap的原理、构建方法、特点以及在信息学...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值