平衡树-Treap

最新推荐文章于 2024-10-31 21:13:19 发布
最新推荐文章于 2024-10-31 21:13:19 发布
阅读量79 收藏
点赞数
文章标签： 数据结构与算法
原文链接：http://www.cnblogs.com/Flower-Z/p/9800714.html
版权

感谢：https://www.cnblogs.com/chenhuan001/p/5788272.html

Treap是平衡树中最简单的形式

平衡树就是左节点一定小于当前节点，右节点一定大于当前节点的数，这样的树按道理来讲，对于一个序列，你按照顺序向上添加数字，应该画出来的是恒定的一个

为什么会有这么多不一样的平衡树呢，Treap , Splay , SBT

因为，但但的按照值排序的平衡树最坏的情况下可能是一条链，并且我们通过左旋和右旋的一些操作，这个树我们可以依旧保持是平衡的

因为在我们解题的过程中，数字的插入顺序显得并没与那么重要

于是，我们就引入了一个新的衡量办法，使得这棵树尽可能的均衡，就是每个节点赋予一个pri值，这个值要么大的在上面，要么小的在上面，这个倒不重要

在Treap中这个值是随机生成的，这样的话尽可能的保证了这个树的均衡性，时间复杂度也就可以尽可能的接近于O(log)

下面是今天写的三道简单题：

从word上面粘贴的代码直接到CB上可能无法运行 需要再ubunte上粘贴一下，据说是在word上直接粘贴会有一些暗藏的东西编译不了

POJ 3481
1.题意：三种操作，每个人有一个优先级和一个id，现在来银行办业务，1操作就是id为x的优先级为y的来银行办业务，也就是插入，2寻找优先级最高的那个人的id，3寻找优先级最低的那个人的id

2.不允许有相同的优先级，相同的优先级有相同的数字也不可以，因为节点值中只记录了值，没有记录出现次，在询问之后就直接删除了

 

#include<stdio.h>
#include<iostream>
#include<algorithm>
#include<string.h>
using namespace std;
const int Maxn = 1000006;    ///最多的点数
struct Tree
{
    int key , num , pri , son[2];   ///key 是树上的键值 pri是随机分配的数字 为了保证树的均衡性 使得复杂度保持在log级别
    Tree() {}
    Tree(int _key , int _num , int _pri)
    {
        key = _key;
        num = _num;
        pri = _pri;
        son[0] = son[1] = 0;
    }
} T[Maxn];
int cnt , root;

void init()
{
    cnt = 1;   ///初始化 cnt=1
    root = 0;
}
void Rotate(int &x , int p)  //1 右旋  0 左旋
{
    int y = T[x].son[!p];
    T[x].son[!p] = T[y].son[p];
    T[y].son[p] = x;
    x = y;
}
void Insert(int &x , int key , int num)   ///插入一个数字  值是num  优先级是key
{
    if(x == 0)
    {
        T[x=cnt++]=Tree(key,num,rand());
/*
        显示建的树
        printf("%d...\n" , x);
        for(int i=0; i<=x; i++)
        {
            printf("%d...%d.%d.%d.%d.%d.\n" , i , T[i].key , T[i].pri , T[i].num , T[i].son[0] , T[i].son[1]);
        }
*/
    }
    else
    {
        int p = key<T[x].key;
        Insert(T[x].son[!p],key,num);
        if(T[x].pri<T[T[x].son[!p]].pri)
            Rotate(x,p);
    }

}
int get(int x , int p)   ///p=1 获得优先级最大的点的数字 p=0 获得优先级最小的点的数字
{
    while( T[x].son[p] )
    {
        x = T[x].son[p];
    }
    return x;
}
void del(int &x , int key)   ///删除一个键值是key的点
{
    if(T[x].key == key)
    {
        if(T[x].son[0] && T[x].son[1])
        {
            int p = T[T[x].son[0]].pri > T[T[x].son[1]].pri;
            Rotate(x ,p);
            del(T[x].son[p] , key);
        }
        else
        {
            if( !T[x].son[0] )
                x = T[x].son[1];
            else
                x = T[x].son[0];
        }
    }
    else
    {
        int p = T[x].key > key;
        del(T[x].son[!p], key);
    }
}
int main()
{
    int flag;
    init();
    while( scanf("%d" ,&flag) != EOF )
    {
        if(flag == 0) break;
        if(flag == 1)
        {
            int num , key;
            scanf("%d%d" , &num , &key);
            Insert(root , key , num);   ///每次新建点之后 root指向的依然是最终的根节点标号
        }
        else if(flag == 2)   ///获取优先级最高的那个点的值
        {
            int x = get(root , 1);
            if(x)
            {
                printf("%d\n" , T[x].num);
                del(root , T[x].key);
            }
            else
            {
                printf("0\n");
            }
        }
        else if(flag == 3)   ///获取优先级最低的那个点的值
        {
            int x = get(root , 0);
            if(x)
            {
                printf("%d\n" , T[x].num);
                del(root , T[x].key);
            }
            else
            {
                printf("0\n");
            }
        }
    }
    return 0;
}
View Code

 

POJ1442

题意：现在有一个序列长度为n，下面给出这个序列，接下来m个询问，第i次询问问前u[i]个数字里面第i大的是谁

  1. 第一想法就是可以主席书写一下
  2. 现在发现平衡树也可以写，主席书的实现是多棵线段树，平衡树就是一个二叉树，主席书带有修改操作，单点修改，区间修改什么的
  3. 在上一题的基础上，将询问函数改了，每个节点现在的key值就是他本身，另外需要记录一个子树节点数，接下来像主席书一样的查找第k大
  4. 时间复杂度O(logn)
  5. 不要忘记调用init函数
#include<stdio.h>
#include<iostream>
#include<algorithm>
#include<string.h>

using namespace std;
const int Maxn = 30004;
int a[Maxn];
int u[Maxn];

struct Tree
{
    int key , Size , pri , son[2];   ///需要记录的是每个节点的子孩子的节点的个数
    Tree() {}
    Tree(int _key , int _Size , int _pri)
    {
        key = _key;
        Size = _Size;
        pri = _pri;
        son[0] = son[1] = 0;
    }
}T[Maxn];
int root , cnt;
void init()
{
    root = 0;
    cnt = 1;
}
void Rotate(int &x , int p)
{
    int y = T[x].son[!p];
    T[x].Size = T[x].Size-T[y].Size+T[T[y].son[p]].Size;
    T[x].son[!p] = T[y].son[p];
    T[y].Size = T[y].Size-T[T[y].son[p]].Size+T[x].Size;
    T[y].son[p] = x;
    x = y;
}
void Insert(int &x , int key)
{
    if(x == 0)
    {
        T[x=cnt++] = Tree(key , 1 , rand());
    }
    else
    {
        T[x].Size++;
        int p = key<T[x].key;
        Insert(T[x].son[!p] , key);
        if(T[x].pri < T[T[x].son[!p]].pri)
            Rotate(x,p);
    }
}
int fin(int &x , int p)
{
    if(p==T[T[x].son[0]].Size+1)
        return T[x].key;
    if(p>T[T[x].son[0]].Size+1)
        fin(T[x].son[1] , p-T[T[x].son[0]].Size-1);
    else
        fin(T[x].son[0] , p);
}
int main()
{
    int n , m;
    u[0] = 0;
    while( scanf("%d%d" , &n , &m) != EOF )
    {
        init();
        for(int i=0; i<n; i++)
            scanf("%d" , &a[i]);
        for(int i=1; i<=m; i++)
        {
            scanf("%d" , &u[i]);
            for(int j=u[i-1]; j<u[i]; j++)
            {
                Insert(root , a[j]);   ///键值就是本身的值
            }
            printf("%d\n" , fin(root , i));    ///寻找区间第i大
        }
    }


    return 0;
}
View Code

 

POJ 2352

题意：有n个星星，每个星星有自己的x坐标y坐标，星星的等级等于x轴不超过它，y轴不超过它的星星的数量，问每个等级有多少个星星

做法：这个题输入是按照y轴从小到大，x轴从小到大输入的，线段树可解，Treap就是统计x大小不超过它的有多少个

  1. 不能忘记初始化函数
  2. 输出等级是0~n-1 不是1~n

 

#include<stdio.h>
#include<iostream>
#include<algorithm>
#include<string.h>
using namespace std;
const int Maxn = 15005;
int ans[Maxn];  ///询问不同等级的有多少个星星 要是询问每个点在低级等级也是一样的
struct Tree
{
    int key , Size , pri , son[2];
    Tree(){}
    Tree(int _key , int _Size , int _pri)
    {
        key = _key;
        Size = _Size;
        pri = _pri;
        son[0] = son[1] = 0;
    }
}T[Maxn];
int root , cnt;
void init()
{
    cnt = 1;
    root = 0;
    memset(ans , 0 , sizeof(ans));
}
void Rotate(int &x , int p)
{
    int y = T[x].son[!p];
    T[x].Size = T[x].Size-T[y].Size+T[T[y].son[p]].Size;
    T[x].son[!p] = T[y].son[p];
    T[y].Size = T[y].Size-T[T[y].son[p]].Size+T[x].Size;
    T[y].son[p] = x;
    x = y;
}
void Insert(int &x , int key)
{
    if(x == 0)
    {
        T[x=cnt++] = Tree(key , 1 , rand());
    }
    else
    {
        T[x].Size++;
        int p = key<T[x].key;
        Insert(T[x].son[!p] , key);
        if(T[x].pri > T[T[x].son[!p]].pri)
            Rotate(x , p);
    }
}
int fin(int &x , int p)
{
    if(x == 0)
        return 0;
    if(T[x].key <= p)
        return T[T[x].son[0]].Size+1+fin(T[x].son[1] , p);
    else
        return fin(T[x].son[0] , p);
}
int main()
{
    int n , x , y;
    while( scanf("%d" , &n) != EOF )
    {
        init();
        for(int i=1; i<=n; i++)
        {
            scanf("%d%d" , &x , &y);   ///题目给的很友好 Y轴按照升序给出，y轴也按照升序给出
                                       ///于是对于每一个输入，只要统计x坐标比较小的有多少个就可以了
            ans[fin(root , x)]++;
            Insert(root , x);
        }
        for(int i=0; i<n; i++)
            printf("%d\n" , ans[i]);
    }
}
View Code

 

转载于:https://www.cnblogs.com/Flower-Z/p/9800714.html

weixin_34388207
关注
平衡树 - treap
繁凡さん的博客
08-20 751
整理的算法模板合集： ACM模板 operator 1 : 插入一个数 operator 2 : 删除一个数 operator 3 : 通过数值找排名 operator 4 : 通过排名找数值 operator 5 : 找到严格小于key的最大数（前驱） operator 6 : 找到严格大于key的最小数（后继） /*P3369 【模板】普通平衡树*/ const int N = 100010, INF = 1e8 + 7; int n, m; struct node{ int l, r;//左
平衡树-Treap基础内容
Tinberlake的博客
08-06 190
平衡树-Treap 2021年8月6日 什么是平衡树？ 平衡树是指任意节点左右子树高度差都小于等于1的二叉树。 平衡树干什么？ 平衡树对序列的排序，寻找元素的位置有很方便的操作 算法原理 建树 Treap通过随机赋予节点一个权值进行建树，由此大概率避免了建树成链的情况。 【1】、初始化树 初始化时，需要首先新建key值为正负无穷的两个节点，作为树的两端。随后依据随机赋予的权值进行平衡操作。 void built() { get_node(-INF), get_node(INF); root = 1; t
平衡树---Treap
weixin_42638946的博客
04-13 862
平衡树—Treap 1. Treap原理 原理 平衡树的种类：AVL、RBTree、Splay、Treap、sbt、… Treap=Tree(BST) + Heap 首先来看什么是BST：Binary Search Tree，即二分搜索树。其定义是递归定义，对于每一个点，其权值严格大于其左子树中所有节点的值，严格小于其右子树所有节点的的值。 BST有一个很重要的性质：其中序遍历的结果一定是从小到大的序列。 BST的本质：动态维护一个有序序列（集合）。 这里实现的BST，默认BST中
平衡树1---treap
w75779的博客
10-18 373
treap平衡树
蒟蒻的笔记本四、平衡树-Treap
diker 的博客
12-01 203
树上的动态规划 一、
数据结构（1）浅谈平衡树--treap(树堆）
m0_72987517的博客
09-19 673
详细介绍treap及其核心操作，比如旋转等等。。。
平衡树--treap
m0_63729880的博客
10-06 511
平衡树——treap
FHQ-Treap 树 ← 洛谷P3369、AcWing253
hnjzsyjyj的专栏
09-19 260
●FHQ−Treap，也称非旋 Treap，由范浩强提出。顾名思义，FHQ−Treap 就是不需要通过旋转，而是通过分裂（split）与合并（merge）维护的 Treap。FHQ−Treap 与 Treap 的另外一个区别是 FHQ−Treap 可持久化。​​​​​​​ ● FHQ-Treap 的高明之处在于所有的操作都只用到了分裂（split）与合并（merge）这两个基本操作。
平衡树入门-Treap
qq_61305213的博客
09-06 141
平衡树
【数据结构】平衡树 - treap
繁凡さん的博客
08-20 424
treap = tree + heap 树堆（treap：让BST尽量随机） 动态维护一个有序序列 对于一个大根堆： 最大值：一直往右走 最小值：一直往左走 treap实现操作 set实现 ①插入 insert ②删除（使其变成叶子节点） erase ③找前驱（中序遍历的前一个位置）/后继（中序遍历的后一个位置） lower_bound ④找最大/最小 begin(),end(); ⑤求某个值的排名 无 ⑥求排名是k的数是谁 无 ⑦比某个数小的最大值 ( 这个数可以不
FHQ-Treap 简介
zhaoweiming2019的博客
08-11 807
FHQ-treap 即非旋Treap，是一种短小精悍，功能丰富的平衡树。据说它的效率介于 Treap 和 Splay 之间（可能是我的FHQ常数比较小，跑得比我的Treap还快）。它可以实现 Splay 可以实现的所有功能，包括平衡树的基本操作和区间翻转操作。它的实现难度比 Splay 要简单很多，没有 Splay 那么多转来转去的操作，不会令人头晕，而且FHQ代码的对称性良好，易于调试。有两种 FHQ-Treap，一种是按值为关键字的，一种是按下标为关键字的（适用于区间翻转等操作时）。...
【学习笔记】FHQ-Treap
Fight_for_NOIP的博客
07-24 756
FHQ-Treap，也称非旋Treap，顾名思义，就是不需要通过旋转，而是通过split和merge维护的Treap。与Treap有点不同，FHQ-Treap能可持久化
模板 - FHQ - treap 无旋平衡树
繁凡さん的博客
08-21 709
整理的算法模板合集： ACM模板 #include<bits/stdc++.h> using namespace std; const int N = 100007; int n, m, tot, root; struct node{ int l, r; int key;//权值 int val;//平衡因子 int size;//子树个数 }tr[N]; void pushup(int p){ tr[p].size = tr[tr[p].l]
HJ51输出单向链表中倒数第k个结点
晴山の博客
10-29 300
HJ51输出单向链表中倒数第k个结点。
【LeetCode】每日一题 2024_10_29 生成不含相邻零的二进制字符串（DFS）
Locky136的博客
10-29 306
【LeetCode】每日一题 2024_10_29 生成不含相邻零的二进制字符串（DFS）
算法练习：四数之和
2302_80652761的博客
10-28 330
四数之和
Leetcode 合并 K 个升序链表
985小菜鸡
10-29 369
题目要求合并 ( K ) 个已经升序排列的链表，输出一个合并后的有序链表。代码使用**优先队列（PriorityQueue）**来实现，以确保每次取出当前最小的节点，这样可以高效地合并多个链表。这段代码通过优先队列实现了多链表的高效合并，每次从优先队列中取出最小节点并连接到结果链表上，从而保证了结果链表的有序性。这样就可以在相对较低的时间复杂度下完成 ( K ) 个有序链表的合并。
线程安全的集合类
最新发布
zrwcnm的博客
10-31 342
如果修改同一个链表上的两个元素，可能就有线程安全问题，比如把这俩元素插入同一元素后面就可能产生竞争。效率更高，按照桶级别进行加锁，而不是给整个哈希加一个全局锁，有效降低锁冲突的概率。如果修改的两个元素，在不同链表上，本身就不涉及线程安全问题（修改不同变量）服务器代码中的其他逻辑就会读取这些数组/哈希中的值，不会修改。确保读取过程中，要么读到的是旧版数据，要么读到的是新版数据。把旧哈希中的所有元素搬运到新的哈希中（元素很多，耗时很长）服务器就会创建新的数组/哈希，加载新的配置。
深入Treap平衡树算法与数据结构应用
本章内容主要集中在平衡树的数据结构之一——Treap的介绍和应用。Treap是一种结合了二叉搜索树和堆数据结构特点的平衡二叉树，它能有效地支持动态集合操作，如查找、插入和删除操作。在描述中，我们了解到该资源主要...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值