RE：从零开始的数据结构生活

最新推荐文章于 2022-08-27 11:45:58 发布
最新推荐文章于 2022-08-27 11:45:58 发布
阅读量108 收藏
点赞数
文章标签： 数据结构与算法
原文链接：http://www.cnblogs.com/Loi-Vampire/p/6017027.html
版权

今天突然想打打splay，结果发现以前学的都忘光了，所以只能从头开始啦~

splay是基于二叉搜索树的结构，通过旋转来完成各种操作。
所以splay的基本性质：

左儿子的权值都小于父节点的权值， 右儿子的权值都大于父节点的权值

splay的功能：

询问数的排名，查询k大的数，查询一个数的前驱和后继

时间复杂度均摊O(log n)

关于splay的具体实现：

结构体里

struct node
{
    node *ch[2], *f;
    int sz, cnt, v;

    void maintain()
    {
        sz = cnt + ch[0] -> sz + ch[1] -> sz;
    }

    int cmp(int x)
    {
        if(x == v) return -1;
        return x < v ? 0 : 1;
    }

    int dir()
    {
        return f -> ch[1] == this;
    }

    void setc(node *x, int d)
    {
        (ch[d] = x) -> f = this;
    }

}T[SZ], *root, *null;

各成员函数的作用：

maintain()：用来更新子树大小和当前数值的个数
cmp() ：比较x和当前节权值的大小，以便继续向儿子方向转移
dir() ：如果当前节点是右儿子则返回真，否则返回假
setc() : 把x置为当前节点的左儿子或右儿子

关于插入操作：

void insert(node *p, int x)
{
    if(root == null) //如果树为空，直接插入 
    {
        root = newnode(x, null);
        return ;
    }
    while(p != null)
    {
        p -> sz++;
        int d = p -> cmp(x); 
        if(d == -1) //要插入的值与当前节点的值相等 
        {
            p -> cnt++;
            break;
        }
        if(p -> ch[d] == null) //没有儿子了，直接插入 
        {
            p -> ch[d] = newnode(x, p);
            p = p -> ch[d];
            break;
        }
        p = p -> ch[d];
    }
    splay(p); //把p旋转至根节点位置 
}

关于删除操作：

void erase(node *p, int x)
{
    while(p != null)
    {
        p -> sz--;
        int d = p -> cmp(x);
        if(d == -1)
        {
            p -> cnt--;
            break;
        }
        p = p -> ch[d];
    } //找到x的过程
    if(p -> cnt) return ; //如果x不只一个，直接返回
    splay(p); //将x旋转至根节点处
    if(p -> ch[0] == null) //如果没有左儿子，则右儿子做根节点
    {
        root = p -> ch[1];
        root -> f = null;
        return ;
    }
    if(p -> ch[1] == null) //如果没有右儿子，左儿子做根节点
    {
        root = p -> ch[0];
        root -> f = null;
        return ;
    }
    p = p -> ch[0]; //需要满足基本性质
    while(p -> ch[1] != null) p = p -> ch[1];
    splay(p, root);
    p -> ch[1] = root -> ch[1];
    p -> ch[1] -> f = p;
    p -> f = null; 
    p -> maintain();
    root = p;
}

重头戏！！！splay() 和 rotate()!

void splay(node *p, node *rt = null)
{
    while(p -> f != rt)
    {
        if(p -> f -> f == rt) //若p的父亲为根节点，直接旋转 
            rotate(p);
        else
        {
            if(p -> dir() == p -> f -> dir()) //p与它的父亲均为左儿子或右儿子 
                rotate(p -> f), rotate(p);
            else rotate(p), rotate(p); //否则 连续旋转两次p
        }
    }
    p -> maintain(); //更新节点 
}
void rotate(node *p)
{
    node *fa = p -> f;
    int d = p -> dir();
    fa -> f -> setc(p, fa -> dir());
    fa -> setc(p -> ch[d ^ 1], d); 
    fa -> maintain();
    p -> setc(fa, d ^ 1);
    p -> maintain();
    if(fa == root) root = p;
}

之前一直搞不懂结构体里的setc()函数，现在终于理解了。

模拟rotate()的过程：

这里写图片描述
当前节点为p，p的父节点为黄色，p的左儿子为蓝色，右儿子为红色

这里写图片描述
首先将p的父节点置为原父节点的父节点

这里写图片描述
将p的右儿子置为原父节点的右儿子，以保证满足基本性质

将p的原父节点置为p的左儿子
这里写图片描述

大功告成！

关于查询操作：

int ask_rank(node *p, int x) //查询一个数的排名
{
    int ans = 0;
    while(p != null)
    {
        int d = p -> cmp(x);
        if(d == -1) return ans + p -> ch[0] -> sz + 1;
        if(d == 1) ans += p -> ch[0] -> sz + p -> cnt;
        p = p -> ch[d];
    }
    return -1;
}

int ask_num(node *p, int k) //查询k大的数
{
    while(p != null)
    {
        int l = p -> ch[0] -> sz + 1;
        int r = p -> ch[0] -> sz + p -> cnt;
        if(l <= k && k <= r) return p -> v;
        if(k > r) k -= r, p = p -> ch[1];
        else p = p -> ch[0];
    }
}

int ask_pre(node *p, int x) //查询前驱
{
    int ans = 0;
    while(p != null)
    {
        if(p -> v < x) ans = p -> v, p = p -> ch[1];
        else p = p -> ch[0];
    }
    return ans;
}

int ask_suf(node *p, int x) //查询后继
{
    int ans = 0;
    while(p != null)
    {
        if(p -> v > x) ans = p -> v, p = p -> ch[0];
        else p = p -> ch[1];
    }
    return ans;
}

最后附一份完整的模板 PS：以BZOJ 3224 为例题

#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;
typedef long long LL;
const int SZ = 1000010;
const int INF = 1e9 + 10;

struct node
{
    node *ch[2], *f;
    int sz, cnt, v;

    void maintain()
    {
        sz = cnt + ch[0] -> sz + ch[1] -> sz;
    }

    int cmp(int x)
    {
        if(x == v) return -1;
        return x < v ? 0 : 1;
    }

    int dir()
    {
        return f -> ch[1] == this;
    }

    void setc(node *x, int d)
    {
        (ch[d] = x) -> f = this;
    }

}T[SZ], *root, *null;
int Tcnt = 0;

node* newnode(int x, node *f)
{
    node *k = T + (++Tcnt);
    k -> v = x;
    k -> ch[0] = k -> ch[1] = null;
    k -> sz = k -> cnt = 1;
    k -> f = f;
    return k;
}

void rotate(node *p)
{
    node *fa = p -> f;
    int d = p -> dir();
    fa -> f -> setc(p, fa -> dir());
    fa -> setc(p -> ch[d ^ 1], d); 
    fa -> maintain();
    p -> setc(fa, d ^ 1);
    p -> maintain();
    if(fa == root) root = p;
}

void splay(node *p, node *rt = null)
{
    while(p -> f != rt)
    {
        if(p -> f -> f == rt) //若p的父亲为根节点，直接旋转 
            rotate(p);
        else
        {
            if(p -> dir() == p -> f -> dir()) //p与它的父亲均为左儿子或右儿子 
                rotate(p -> f), rotate(p);
            else rotate(p), rotate(p); //否则 
        }
    }
    p -> maintain(); //更新节点 
}

void insert(node *p, int x)
{
    if(root == null) //如果树为空，直接加入 
    {
        root = newnode(x, null);
        return ;
    }
    while(p != null)
    {
        p -> sz++;
        int d = p -> cmp(x); 
        if(d == -1) //要插入的值与当前节点的值相等 
        {
            p -> cnt++;
            break;
        }
        if(p -> ch[d] == null) //没有儿子了，直接加入 
        {
            p -> ch[d] = newnode(x, p);
            p = p -> ch[d];
            break;
        }
        p = p -> ch[d];
    }
    splay(p); //把p旋转至根节点位置 
}

//RE:从零开始的数据结构生活 

void erase(node *p, int x)
{
    while(p != null)
    {
        p -> sz--;
        int d = p -> cmp(x);
        if(d == -1)
        {
            p -> cnt--;
            break;
        }
        p = p -> ch[d];
    }
    if(p -> cnt) return ;
    splay(p);
    if(p -> ch[0] == null)
    {
        root = p -> ch[1];
        root -> f = null;
        return ;
    }
    if(p -> ch[1] == null)
    {
        root = p -> ch[0];
        root -> f = null;
        return ;
    }
    p = p -> ch[0];
    while(p -> ch[1] != null) p = p -> ch[1];
    splay(p, root);
    p -> ch[1] = root -> ch[1];
    p -> ch[1] -> f = p;
    p -> f = null; 
    p -> maintain();
    root = p;
}

int ask_rank(node *p, int x)
{
    int ans = 0;
    while(p != null)
    {
        int d = p -> cmp(x);
        if(d == -1) return ans + p -> ch[0] -> sz + 1;
        if(d == 1) ans += p -> ch[0] -> sz + p -> cnt;
        p = p -> ch[d];
    }
    return -1;
}

int ask_num(node *p, int k)
{
    while(p != null)
    {
        int l = p -> ch[0] -> sz + 1;
        int r = p -> ch[0] -> sz + p -> cnt;
        if(l <= k && k <= r) return p -> v;
        if(k > r) k -= r, p = p -> ch[1];
        else p = p -> ch[0];
    }
}

int ask_pre(node *p, int x)
{
    int ans = 0;
    while(p != null)
    {
        if(p -> v < x) ans = p -> v, p = p -> ch[1];
        else p = p -> ch[0];
    }
    return ans;
}

int ask_suf(node *p, int x)
{
    int ans = 0;
    while(p != null)
    {
        if(p -> v > x) ans = p -> v, p = p -> ch[0];
        else p = p -> ch[1];
    }
    return ans;
}

void init() //初始化 
{
    null = newnode(-INF, null); //null为根 
    null -> sz = null -> cnt = 0;
    root = null;
}

int main()
{
    init();
    int n;
    scanf("%d", &n);
    while(n--)
    {
        int op, x;
        scanf("%d%d", &op, &x);
        switch(op)
        {
            case 1 : insert(root, x); break;
            case 2 : erase(root, x); break;
            case 3 : printf("%d\n", ask_rank(root, x)); break;
            case 4 : printf("%d\n", ask_num(root, x)); break;
            case 5 : printf("%d\n", ask_pre(root, x)); break;
            case 6 : printf("%d\n", ask_suf(root, x)); break;
        }
    }
    return 0;
}

转载于:https://www.cnblogs.com/Loi-Vampire/p/6017027.html

dataxiang6224
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
javalruleetcode-Re0-LeetCode:从零开始的LeetCode
06-29
从零开始的LeetCode 主要语言 : C，C++，Java 力扣前 250 名 前400题中重点250道 题号 状态 1 二和 完毕 3 无重复字符的最长子串 完毕 4 两个有序数组的中位数 完毕 5 最长回文子串 完毕 7 反转整数 去做 8 字符串到...
初学数据结构——从零开始的数据结构学习第一天（初识数据结构）
Lazy_ChessPlayer的博客
03-31 402
本博客为本人在学习结构路途上的一些学习心得，如觉得对有你有所帮助，还希望留下一个赞。由于博主只是一名大一新生，如果博文中出现错误，欢迎指正。如果想要转载，附上链接就行。逻辑结构概念：数据元素之间的逻辑关系特点：独立于计算机，与数据的存储无关物理结构（存储结构）概念：数据元素及其关系在计算机中的结构（存储方式）特点：存储于计算机之中，关系到数据元素的实际操作。
数据结构与生活
一个腰部以上的叛逆
12-08 3247
练武不练功，到老一场空。
如何设计一个数据结构
拥抱新生活
10-21 6885
引言这几天，刷题碰到了好多需要自己设计数据结构的题目，优化存储，提升方法效率，主要是访问和修改 比如，字符串的查找用字典树，TrieNode，节点树，每个char都是一个leaf。 很多时候，我们常用vector,queue,stack,map,set 使用不需要排序的map,set,使用unordered_map, unordered_set, 前者内部机制红黑树，后者hash这是我们在教材
从零开始_学_数据结构（一）——算法的基本概念
weixin_34202952的博客
03-20 209
从零开始_学_数据结构（一）——算法 算法的定义： 解决问题的方法。 对于同一个问题，一个好的算法比一个差的算法，效率更高，更节约资源。 For Computer：算法是解决特定问题的求解步骤的描述，在计算机中，表示指令的有限序列，每条指令表示一个或者多个操作。 简单来说，算法就是输入代码，告诉计算机，你应该怎么解决这个问题。 算法的特...
数据结构和算法（对生活的抽象）
zhhvera的博客
06-13 272
数据结构和算法 什么是数据结构？ 计算机中，存储和组织数据的方式 数据的组织方法对效率影响很大 数据结构类型： 队列 树 堆 数组 栈 链表 图 散列表 什么是算法（Algorithm）？ 不同的算法，执行效率不一样 一个有限指令集，每条指令的描述不依赖于语言 数据结构的实现离不开算法 （解决一个问题的方法步骤就是这个问题的算法） 具体数据结构介绍 数组 熟悉数组ApI的调用 数组是一种线性结构，并且可以在数组的任意位置 插入和删除数据 是一段一段的内存，扩容、插入和删除元素的操作耗时 数组通过下标来去
re:从0开始的CSS之旅 20. 渐变（暂完结撒花）
02-17
关键的CSS代码文件，HTML标签可以自己实现
re:从0开始的HTML学习之路 1. 标签间的关系与注释
最新发布
02-17
内容对应的网页源代码
swift-Re.从零开始的RunLoop实践
08-15
Re:从零开始的Runloop实践02-使用ports 或custom input sources 和其他线程通信
常见数据结构应用场景
weixin_30335353的博客
10-05 1811
通用数据结构 可以简单的按照速度将通用数据结构划分为：数组和链表（最慢），树（较快），哈希表（最快）。增、删、改、查是四大常见操作，不过其实可以浓缩为两个操作：增和查。删除操作和和修改操作都是建立在查找操作上的，所以完美的数据结构应该是具有较高的插入效率和查找效率。 通用数据结构关系 可以根据下图选择合适的通用数据结构： 数组 使用场景 数组在以下三个情形下很有用： 1）数据量较...
（ 从零开始的数据结构生活 ）二、栈
m0_71432177的博客
08-27 642
今天我们一起学习栈。代码部分我依旧引用了印度老哥Harsha Suryanarayana的代码，并对学习过程中有问题的点进行描述。当然，从这篇文章开始，我会说明我的原创点。
从零开始学习 --数据结构（一）
qq_48009872的博客
11-26 809
根据B站上自考数据结构课程讲解PPt （勉强吧） 手抄 方便后续复习和重点难点理解 转载需注明 线性表的链式存储结构（二） 单链表上的基本运算 单链表的建立 动态建立单链表的常用方法有两种：一个头插法一个尾插法。 头插法建表，从一个空表开始，重复读入数据，生成新的结点，将读入的数据放到新的结点的数据域中，然后将新的结点插入到当前链表的表头上，直到读入结束标志为止。 LinkList CreateListF() { LinkList head; listNode p; char ch; head = N
数据结构 - 二叉树 - 面试中常见的二叉树算法题
热门推荐
从零开始
01-17 2万+
数据结构 - 二叉树 - 面试中常见的二叉树算法题 数据结构是面试中必定考查的知识点，面试者需要掌握几种经典的数据结构：线性表（数组、链表）、栈与队列、树（二叉树、二叉查找树、平衡二叉树、红黑树）、图。 本文主要介绍树中的常见的二叉树数据结构。包括 概念简介 二叉树中树节点的数据结构（Java） 二叉树的遍历（Java） 常见的二叉树算法题（Java） 概念简介 如果对二叉
数据结构 - 用递归算法解决实际问题
hades's stack
06-01 3733
实验题目：编写一个程序exp5-2.cpp，求解背包问题：设有不同价值、不同重量的物品n件，求从这n件物品中选取一部分物品的方案，使选中物品的总重量不超过指定的限制重量，但选中物品的总价值最大。源码：#include<iostream> #define Max 100 using namespace std; struct bag { int weight; int value; }
数据结构解决相关问题
weixin_30896511的博客
05-06 266
Que1：两个字符串中的字符相同，出现的次数也相同，但是出现的顺序不同则认为这两个字符串是兄弟字符串。（eg：“ADB”和“DBA”就是兄弟字符串）现在提供一对字符串，如何确定他们是否是兄弟字符串？ 采用散列表的方式来解决这个问题，由于不考虑排列的问题，所以只需要记录出现的次数就可以了！详细的程序如下所示： 1 #include <stdio.h> 2 #include ...
从零开始_学_数据结构（二）——树的基本概念
weixin_33712881的博客
03-20 275
相比之前的帖子，对其进行了增添和完善。 ps：本颜色的字体是后续添加内容 —————————————————— 参考链接： 大话数据结构.pdf 图解数据结构（6）——树及树的遍历 http://www.cnblogs.com/yc_sunniwell/archive/2010/06/27/1766233.html 1.什么是树？ 是一种数据结...
有Python基础怎么从零开始学呢
03-12
2. 学习Python的标准库，包括常用的模块，如os、sys、re、datetime等，以及常用的数据结构和算法。 3. 学习Python的第三方库，如NumPy、Pandas、Matplotlib等，这些库可以帮助你更方便地处理数据和进行数据可视化。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值