初探treap

最新推荐文章于 2022-01-26 23:16:04 发布
最新推荐文章于 2022-01-26 23:16:04 发布
阅读量623 收藏
点赞数
分类专栏： 数据结构 treap 文章标签： treap入门
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bit_Line/article/details/45458831
版权

treap的基本操作

treap类似二分查找树，只是加了一个堆，用随机值维护平衡，只是期望平衡。小数据下表现并不是特别优秀，但是足够用了。
先水两发，之后再继续搞- -、

poj1338 Ugly Numbers

把质因子只含2,3,5的数叫Ugly Number.通式为:

x=2i×3j×5k

注意到是一个幂次计算，因此大致地有:
0≤i,j,k≤30
那么我们只需要枚举 ∏(0≤i≤30,x=2,3,5)xi ，然后排序即可。当然也可以直接 logn 地插入，于是可以用 STL 的 set 维护，这里不用set，用Treap维护一下，每个节点还要增加一个 rank ，用来维护子树节点的数量。
代码： 

#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <ctime>
#include <algorithm>
using namespace std;

typedef long long type;
struct node {
    type val;
    int fix;
    int rank; //增加维护一个rank值,保存以该节点为根子树的节点数目
    node* left;
    node* right;
    node() {
        left = right = NULL;
    }
    node(type x) {
        val = x;
        fix = rand();
        left = right = NULL;
    }
};

inline int rank(node* &T) {
    return T == NULL ? 0 : T->rank;
}

void rotate_left(node* &T) {
    //printf("rotate_left %d\n", T->val);
    node* tp = T->right;
    T->right = tp->left;
    T->rank = rank(T->left) + rank(T->right) + 1;
    tp->left = T;
    tp->rank = rank(tp->left) + rank(tp->right) + 1;
    T = tp;
}

void rotate_right(node* &T) {
    //printf("rotate_right %d\n", T->val);
    node* tp = T->left;
    T->left = tp->right;
    T->rank = rank(T->left) + rank(T->right) + 1;
    tp->right = T;
    tp->rank = rank(tp->left) + rank(tp->right) + 1;
    T = tp;
}

void insert(node* &T, type& val) {
    if (T == NULL) {
        T = new node(val);
        T->rank = 1;
    } else if (val == T->val) {
        return;
    } else if (val < T->val) {
        insert(T->left, val);
        ++T->rank;
        if (T->left->fix < T->fix) {
            rotate_right(T);
        }
    } else {
        insert(T->right, val);
        ++T->rank;
        if (T->right->fix < T->fix) {
            rotate_left(T);
        }
    }
}

void erase(node* &T, type& val) {
    if (val == T->val) {
        if (T->left == NULL || T->right == NULL) {
            node* t = T;
            if (T->left == NULL) {
                T = T->right;
            } else {
                T = T->left;
            }
            T->rank = rank(T->left) + rank(T->right) + 1;
            delete t;
        } else {
            if (T->left->fix < T->right->fix) {
                rotate_right(T);
                erase(T->right, val);
            } else {
                rotate_left(T);
                erase(T->left, val);
            }
        }
    } else if (val < T->val) {
        erase(T->left, val);
        --(T->rank);
    } else {
        erase(T->right, val);
        --(T->rank);
    }
}

bool exist(node* &T, type val) {
    if (T == NULL) {
        return false;
    } else if (T->val == val) {
        return true;
    } else if (val < T->val) {
        return exist(T->left, val);
    } else {
        return exist(T->right, val);
    }
}

void clear(node* &T) {
    if (T == NULL) return;
    clear(T->left);
    clear(T->right);
    delete T;
    T = NULL;
}

const type INF = 0xfffffff;
type find_k(node* &T, int k) {
    //printf("find_k(%d)\n", k);
    if (k <= 0 || k > rank(T)) {
        return INF;
    } else if (k == rank(T->left) + 1) {
        return T->val;
    } else if (k <= rank(T->left)) {
        return find_k(T->left, k);
    } else {
        return find_k(T->right, k - 1 - rank(T->left));
    }
}

void visit(node* &T) {
    if (T == NULL) return;
    visit(T->left);
    printf("(%d,%d) ", T->val, T->rank);
    visit(T->right);
}

const int MAX = 32;
type p2[MAX], p3[MAX], p5[MAX];

int main() {
    p2[0] = p3[0] = p5[0] = 1;
    for (int i = 1; i < MAX; ++i) {
        p2[i] = p2[i - 1] << 1;
        p3[i] = p3[i - 1] * 3;
        p5[i] = p5[i - 1] * 5;
    }
    node* T = NULL;
    for (int i = 0; i < MAX; ++i) {
        if (p2[i] <= 0) break;
        for (int j = 0; j < MAX; ++j) {
            if (p3[j] <= 0) break;
            for (int k = 0; k < MAX; ++k) {
                long long t = p2[i] * p3[j] * p5[k];
                if (t <= 0) break;
                //printf("insert %d\n", t);
                insert(T, t);
            }
        }
    }
    //visit(T);
    //puts("");

    int n;
    while (~scanf(" %d", &n)) {
        if (n == 0) break;
        printf("%lld\n", find_k(T, n));
    }
    clear(T);

    return 0;
}

poj1552

这题只需要用到查找操作，遍历维护的 treap ，对任意节点 x 只需要检查是否存在元素2×x即可。代码：

#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <ctime>
#include <algorithm>
using namespace std;

typedef int type;
struct node {
    type val;
    int fix;
    node* left;
    node* right;
    node() {
        left = right = NULL;
    }
    node(type x) {
        val = x;
        fix = rand();
        left = right = NULL;
    }
};

void rotate_left(node* &T) {
    node* tp = T->right;
    T->right = tp->left;
    tp->left = T;
    T = tp;
}

void rotate_right(node* &T) {
    node* tp = T->left;
    T->left = tp->right;
    tp->right = T;
    T = tp;
}

void insert(node* &T, type& val) {
    if (T == NULL) {
        T = new node(val);
    } else if (val <= T->val) {
        insert(T->left, val);
        if (T->left->fix < T->fix) {
            rotate_right(T);
        }
    } else {
        insert(T->right, val);
        if (T->right->fix < T->fix) {
            rotate_left(T);
        }
    }
}

void erase(node* &T, type& val) {
    if (val == T->val) {
        if (T->left == NULL || T->right == NULL) {
            node* t = T;
            if (T->left == NULL) {
                T = T->right;
            } else {
                T = T->left;
            }
            delete t;
        } else {
            if (T->left->fix < T->right->fix) {
                rotate_right(T);
                erase(T->right, val);
            } else {
                rotate_left(T);
                erase(T->left, val);
            }
        }
    } else if (val < T->val) {
        erase(T->left, val);
    } else {
        erase(T->right, val);
    }
}

bool exist(node* &T, type val) {
    if (T == NULL) {
        return false;
    } else if (T->val == val) {
        return true;
    } else if (val < T->val) {
        return exist(T->left, val);
    } else {
        return exist(T->right, val);
    }
}

void clear(node* &T) {
    if (T == NULL) return;
    clear(T->left);
    clear(T->right);
    delete T;
    T = NULL;
}

int query(node* &root, node* &T) {
    if (T == NULL) return 0;
    return exist(root, (T->val) * 2)
        + query(root, T->left) + query(root, T->right);
}

void visit(node* &T) {
    if (T == NULL) return;
    visit(T->left);
    printf("%d ", T->val);
    visit(T->right);
}

int main() {
    node* T = NULL;
    int n;
    while (~scanf(" %d", &n) && n != - 1) {
        while (n != 0) {
            insert(T, n);
            //visit(T);
            //puts("");
            scanf(" %d", &n);
        }
        printf("%d\n", query(T, T));
        clear(T);
    }
    return 0;
}

HDU5058 So easy

题意类似判断两个集合是否相等。即是否一个数组中的元素在另一个元素中也一定存在。去重后比较即可。但是，同样地，用treap来练习…
代码：

#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <ctime>
#include <algorithm>
using namespace std;

typedef int type;
struct node {
    type val;
    int fix;
    node* left;
    node* right;
    node() {
        left = right = NULL;
    }
    node(type x) {
        val = x;
        fix = rand();
        left = right = NULL;
    }
};

void rotate_left(node* &T) {
    node* tp = T->right;
    T->right = tp->left;
    tp->left = T;
    T = tp;
}

void rotate_right(node* &T) {
    node* tp = T->left;
    T->left = tp->right;
    tp->right = T;
    T = tp;
}

void insert(node* &T, type& val) {
    if (T == NULL) {
        T = new node(val);
    } else if (val == T->val) {
        return;
    } else if (val < T->val) {
        insert(T->left, val);
        if (T->left->fix < T->fix) {
            rotate_right(T);
        }
    } else {
        insert(T->right, val);
        if (T->right->fix < T->fix) {
            rotate_left(T);
        }
    }
}

void erase(node* &T, type& val) {
    if (val == T->val) {
        if (T->left == NULL || T->right == NULL) {
            node* t = T;
            if (T->left == NULL) {
                T = T->right;
            } else {
                T = T->left;
            }
            delete t;
        } else {
            if (T->left->fix < T->right->fix) {
                rotate_right(T);
                erase(T->right, val);
            } else {
                rotate_left(T);
                erase(T->left, val);
            }
        }
    } else if (val < T->val) {
        erase(T->left, val);
    } else {
        erase(T->right, val);
    }
}

bool exist(node* &T, type val) {
    if (T == NULL) {
        return false;
    } else if (T->val == val) {
        return true;
    } else if (val < T->val) {
        return exist(T->left, val);
    } else {
        return exist(T->right, val);
    }
}

void clear(node* &T) {
    if (T == NULL) return;
    clear(T->left);
    clear(T->right);
    delete T;
    T = NULL;
}

bool query(node* &root, node* &T) {
    if (T == NULL) return true;
    return exist(root, T->val)
        && query(root, T->left) && query(root, T->right);
}

int main() {
    int n;
    type x;
    node* T1 = NULL, *T2 = NULL;
    while (~scanf(" %d", &n)) {
        for (int i = 0; i < n; ++i) {
            scanf(" %d", &x);
            insert(T1, x);
        }
        for (int i = 0; i < n; ++i) {
            scanf(" %d", &x);
            insert(T2, x);
        }
        puts(query(T1, T2) && query(T2, T1) ? "YES" : "NO");
        clear(T1);
        clear(T2);
    }
    return 0;
}
bit_line
关注
专栏目录
go当中的内存管理
粉丝头子的故事
06-05 606
文章目录1.mspan源码2.mcahe源码3.mcentral源码4.mheap源码5.具体分配源码1.微对象和小对象2.大对象 1.mspan源码 type mspan struct { //mspan是一个双向链表结构，所以包含next指针和prev指针，分别指向后继节点和前驱节点 next *mspan prev *mspan // 好像是用来debug的，具体不是很清楚 list *mSpanList // mspan主要是用来管理heap当中的内存，其实质为hea
go语言实现--二叉树
米兰的小铁匠1943的博客
03-10 9447
二叉树是每个结点最多有两个子树的树结构。通常子树被称作“左子树”（left subtree）和“右子树”（right subtree）。二叉树常被用于实现二叉查找树和二叉堆。 二叉树的每个结点至多只有二棵子树(不存在度大于2的结点)，二叉树的子树有左右之分，次序不能颠倒。二叉树的第i层至多有2^{i-1}个结点；深度为k的二叉树至多有2^k-1个结点；对任何一棵二叉树T，如果其终端结点数为n_0...
数据结构STL——golang实现树堆Treap
l2975的博客
12-25 353
github仓库存储地址：https://github.com/hlccd/goSTL 概述 ​ 树堆（Treap）是一个比较特殊的结构，它同之前实现的二叉搜索树和完全二叉搜有着类似的性质，它即满足二叉搜索树的查找性质，又满足完全二叉树的极值处于堆顶的性质。 ​ 树堆由一个根节点和根节点下属的多层次的子结点构成，任意一个结点最多只能拥有两个子结点，即左右子结点。它的这一特性同二叉搜索树完全一致，但除此之外，它还有另一个特质：给每一个结点赋予一个随机的优先级，使得其在插入的时候，通过左右旋转的方式，保证其
go专业数据结构与算法高级
12-06
本节为go专业数据结构与算法高级，继续讲解go中的数据结构以及相关的算法。 
go-heaps：Go中堆数据结构的参考实现-treap，skew，leftlist，pairing，fibonacci
02-05
堆 Go中堆数据结构的参考实现 安装 $ go get -u github.com/theodesp/go-heaps 内容 堆 ：配对堆是一种堆数据结构，具有相对简单的实现和出色的实际摊销性能。 ：二进制堆的变体。 每个节点都有一个s值，即到最近叶子的距离。 与二进制堆相反，左派树试图变得非常不平衡。 ：一个斜堆（或自调整堆）是作为二进制树实现的堆的数据结构。 偏斜堆是有利的，因为它们的合并能力比二进制堆快。 ：Fibonacci堆是用于优先级队列操作的数据结构，由一组按堆排序的树组成。 它具有比包括二进制堆和二项式堆在内的许多其他优先级队列数据结构更好的摊销运行时间。 ：二项式
POJ1741（点分治初探）
ChrysanDog的博客
12-05 294
树 时间限制：1000MS1000MS1000MS 内存限制：30MB30MB30MB 题目描述 给一个有nnn个顶点的树，每个边都有一个长度（正整数小于100110011001）。 定义dist（u，v）=dist（u，v）=dist（u，v）=节点uuu和vvv之间的最短距离。 给出一个整数kkk，当且仅当dist（u，v）dist（u，v）dist（u，v）不超过kkk时，每个（u，v）...
ACM之路（20）—— Splay初探
ddmxynl793173的博客
12-19 159
　　由于数据结构上老师讲了AVL树的rotate，然后去学了一下treap和Splay，这些数据结构还真是神奇啊！ 　　treap暂时只知道名次树的作用（就是一段动态变化的有序数列，找第K大的元素，用set显然是O(n)的。。）。 　　好，正式介绍SplayTree这个神奇的数据结构：暂时的理解是，用于解决一些线段树解决不了的区间问题，比方说区间翻转，区间删除并插入等等（似乎分块也可...
IOI国家集训队1999-2020年论文集（附网盘免费下载链接）
繁凡さん的博客
03-13 9564
国家集训队1999-2019年论文（合集）（文末有网盘下载链接） 累死我了（；´д｀）ゞ 大家跟我每天一篇论文集， 一起自闭每一天 文末有百度网盘免费链接哦 国家集训队1999论文集 陈宏：《数据结构的选择与算法效率——从IOI98试题PICTURE谈起》 来煜坤：《把握本质，灵活运用——动态规划的深入探讨》 齐鑫：《搜索方法中的剪枝优化》 邵铮：《数学模型的建立、比较和应用》 石润婷：《隐蔽化、...
算法学习笔记15：红黑树
JRcoder
01-26 244
眼前的黑不是黑，你说的红是什么红，本篇博客带你初探红黑树的奥秘。
treap：有效实现隐式treap数据结构
02-04
**Treap：高效实现隐式Treap数据结构** Treap（树堆）是一种结合了随机化和二叉搜索树特性的数据结构，由Russo和Sedgewick在1989年提出。它的核心思想是将二叉搜索树与堆属性相结合，通过随机化的方式确保良好的...
数据结构之Treap详解
09-04
【数据结构之Treap详解】 Treap是一种结合了二叉搜索树（BST）和堆（Heap）特性的数据结构，其名称由“tree”和“heap”组合而成。Treap的特点在于每个节点不仅包含键值，还包含一个优先级，这个优先级通常是随机...
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->...
基本Treap.ppt
09-17
基本Treap.ppt
Treap
wsyear的博客
03-02 376
Treap=Tree+Heap,介绍Treap思路及常用操作
[模板] 树堆 - Treap的指针和数组实现及一些例题
LucienShui
08-19 677
指针版：template <class T, class Compare = std::less<T> > class Treap { private: struct treap {//成员结构体 int size, fix;//以当前节点为根的树的节点数目，和调整树结构的fix随机数 T key;//每个节点的权，可以定义成自己想要的类型 C
comsol模拟不同形状晶粒的煤体、岩体、土体的水力压裂、煤层压裂相场本构模型，内含不同尺寸的骨料、晶粒 案例文件众多，包含不
最新发布
10-10
comsol模拟不同形状晶粒的煤体、岩体、土体的水力压裂、煤层压裂相场本构模型，内含不同尺寸的骨料、晶粒。 案例文件众多，包含不同尺寸方形晶粒、圆形晶粒、椭圆形晶粒、微小晶粒等。
病房管理系统 SSM毕业设计 源码+数据库+论文（JAVA+SpringBoot+Vue.JS）.zip
10-09
病房管理系统 SSM毕业设计 源码+数据库+论文（JAVA+SpringBoot+Vue.JS） 启动教程：https://www.bilibili.com/video/BV1GK1iYyE2B
技术资料分享非常好的通俗易懂的开关电源原理与维修5.zip
10-09
技术资料分享非常好的通俗易懂的开关电源原理与维修5.zip
Treap数据结构详解：操作与应用
"Treap是一种平衡二叉查找树，结合了树和堆的特性，用于高效的数据操作，如插入和删除。它通过随机化的优先级保证平衡性，从而实现平均情况下的优秀性能。本文深入探讨了Treap的原理、构建方法、特点以及在信息学...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值