数据结构(二)

最新推荐文章于 2024-06-18 22:14:26 发布

-三生万物

最新推荐文章于 2024-06-18 22:14:26 发布

阅读量66

点赞数

分类专栏：算法基础文章标签：数据结构 c++ 算法

本文链接：https://blog.csdn.net/starryHW/article/details/130093238

版权

算法基础专栏收录该内容

10 篇文章 0 订阅

订阅专栏

1.树

1.1 原理

在这里插入图片描述

每个单词结尾处都要标记一下，因为这样才能知道检索出单词

1.2 代码实现

维护一个字符串集合，支持两种操作：

I x 向集合中插入一个字符串 x；
Q x 询问一个字符串在集合中出现了多少次。共有 N个操作，所有输入的字符串总长度不超过 105，字符串仅包含小写英文字母。

输入格式
第一行包含整数 N，表示操作数。
接下来 N行，每行包含一个操作指令，指令为 I x 或 Q x 中的一种。

输出格式
对于每个询问指令 Q x，都要输出一个整数作为结果，表示 在集合中出现的次数。

每个结果占一行。

数据范围
1≤N≤2∗104
输入样例：
5
I abc
Q abc
Q ab
I ab
Q ab
输出样例：
1
0
1

//Trie树快速存储字符集合和快速查询字符集合
#include <iostream>

using namespace std;

const int N = 100010;
//son[][]存储子节点的位置，分支最多26条；
//cnt[]存储以某节点结尾的字符串个数（同时也起标记作用）
//idx表示当前要插入的节点是第几个,每创建一个节点值+1
int son[N][26], cnt[N], idx;
char str[N];

void insert(char *str)
{
    int p = 0;  //类似指针，指向当前节点
    for(int i = 0; str[i]; i++)
    {
        int u = str[i] - 'a'; //将字母转化为数字
        if(!son[p][u]) son[p][u] = ++idx;   //该节点不存在，创建节点
        p = son[p][u];  //使“p指针”指向下一个节点
    }
    cnt[p]++;  //结束时的标记，也是记录以此节点结束的字符串个数
}

int query(char *str)
{
    int p = 0;
    for(int i = 0; str[i]; i++)
    {
        int u = str[i] - 'a'; // 将字母映射到0-25
        if(!son[p][u]) return 0;  //该节点不存在，即该字符串不存在
        p = son[p][u]; 
    }
    return cnt[p];  //返回字符串出现的次数
}

int main()
{
    int m;
    cin >> m;

    while(m--)
    {
        char op[2];
        scanf("%s%s", op, str);

        if(*op == 'I') insert(str);
        else printf("%d\n", query(str));
    }

    return 0;
}

2.并查集(出现频率高)

2.1 原理

在这里插入图片描述

2.2 代码实现

一共有 n个数，编号是 1∼n，最开始每个数各自在一个集合中。

现在要进行 m个操作，操作共有两种：

M a b，将编号为 a和 b的两个数所在的集合合并，如果两个数已经在同一个集合中，则忽略这个操作；
Q a b，询问编号为 a和 b的两个数是否在同一个集合中；
输入格式
第一行输入整数 n和 m。

接下来 m行，每行包含一个操作指令，指令为 M a b 或 Q a b 中的一种。

输出格式
对于每个询问指令 Q a b，都要输出一个结果，如果 a和 b在同一集合内，则输出 Yes，否则输出 No。

每个结果占一行。

数据范围
1≤n,m≤105
输入样例：
4 5
M 1 2
M 3 4
Q 1 2
Q 1 3
Q 3 4
输出样例：
Yes
No
Yes

在这里插入图片描述

上面用了op[2], 因为scanf 读字符串的时候会自动忽略回车等

给定一个包含 n个点（编号为 1∼n）的无向图，初始时图中没有边。

现在要进行 m个操作，操作共有三种：

C a b，在点 a 和点 b之间连一条边，a和 b可能相等；
Q1 a b，询问点 a和点 b是否在同一个连通块中，a和 b可能相等；
Q2 a，询问点 a所在连通块中点的数量；
输入格式
第一行输入整数 n和 m。

接下来 m行，每行包含一个操作指令，指令为 C a b，Q1 a b 或 Q2 a 中的一种。

输出格式
对于每个询问指令 Q1 a b，如果 a和 b 在同一个连通块中，则输出 Yes，否则输出 No。
对于每个询问指令 Q2 a，输出一个整数表示点 a所在连通块中点的数量

每个结果占一行。

数据范围
1≤n,m≤105
输入样例：
5 5
C 1 2
Q1 1 2
Q2 1
C 2 5
Q2 5
输出样例：
Yes
2
3

在这里插入图片描述

3.堆排序(非STL里面的堆，这里手写)

3.1 原理

在这里插入图片描述

注意：数组从下标为1 开始存，这样可以避免0的左孩子还是0

小根堆 down操作：

对应up操作可推

由上面的down 和 up操作可以退出开始提到的堆5中操作：
在这里插入图片描述

3.2例题

说明：在刚开始建堆时候，可以采用一次次的插入方式建堆，但是这样时间复杂度是nlogn, 可以采用从n/2 开始down，这样初始堆时间复杂度变为O(n)
1.

输入一个长度为 n的整数数列，从小到大输出前 m小的数。

输入格式
第一行包含整数 n和 m。

第二行包含 n个整数，表示整数数列。

输出格式
共一行，包含 m个整数，表示整数数列中前 m小的数。

数据范围
1≤m≤n≤105，
1≤数列中元素≤109
输入样例：
5 3
4 5 1 3 2
输出样例：
1 2 3

在这里插入图片描述

在这里插入图片描述
另外的up操作：

维护一个集合，初始时集合为空，支持如下几种操作：

I x，插入一个数 x；
PM，输出当前集合中的最小值；
DM，删除当前集合中的最小值（数据保证此时的最小值唯一）；
D k，删除第 k个插入的数；
C k x，修改第 k个插入的数，将其变为 x；
现在要进行 N次操作，对于所有第 2个操作，输出当前集合的最小值。

输入格式
第一行包含整数 N。

接下来 N行，每行包含一个操作指令，操作指令为 I x，PM，DM，D k 或 C k x 中的一种。

输出格式
对于每个输出指令 PM，输出一个结果，表示当前集合中的最小值。

每个结果占一行。

数据范围
1≤N≤105

−109≤x≤109

数据保证合法。

输入样例：
8
I -10
PM
I -10
D 1
C 2 8
I 6
PM
DM
输出样例：
-10
6

说明：
/*
1、理解hp与ph数组，以及为什么需要它们

堆h[i]只能存放数据，不能存放是第几个数字，所以需要ph[k] = i来指明，第k个数字在h[]中对应的i是多少
在执行交换操作的时候，可以直接交换数字,swap(h[a],h[b])
但是对于ph[k_1] = a和ph[k_2] = b来说，a和b是它们存放的值，不能通过值来找下标，也就是找不k_1,k_2是多少
于是引入hp[a] = k_2，hp[b] = k_2，则可以实现反向的操作

2、形象理解heap_swap中的次序是任意的
h[]：房间号无直接实际意义，里边住着犯人
ph[]：花名册，狱警所有，写明了几号犯人住在哪个房间号里，用于抓某些人
（但是狱警无权过问每个号里住的是谁）
hp[]：住户册，监狱所有，写明了哪个房间号里住的是几号，用于管理监狱
（但是监狱没必要知道哪个犯人住在哪里）
heap_swap：已知两个犯人住的地方，交换它们住的地方，并且让狱警和管理处都知道这件事情
swap(h[a], h[b])：两个人换地方住
swap(hp[a], hp[b])：监狱管理处翻房间号，把里边存放的犯人号交换
swap(ph[hp[a]], ph[hp[b]])：狱警：先申请查住户册，看这两个地方住的谁，再在花名册下写下来，这两个人位置换了
h[a] = 10, h[b] = 20 swap: h[a] = 20,h [b] = 10
hp[a] = 1 ,hp[b] = 2 swap:hp[a] = 2 ,hp[b] = 1
ph[1] = a ,ph[2] = b swap:ph[1] = b ,ph[2] = a
//这种不变形也很像线代中：代表交换的初等矩阵，进行逆运算之后，仍然是该初等矩阵

#include <iostream>
#include <cstdio>

using namespace std;

const int N = 100010;

int h[N], hp[N], ph[N];
int n, m, s;

void heap_swap(int a, int b)
{
    swap(ph[hp[a]], ph[hp[b]]);
    swap(hp[a], hp[b]);
    swap(h[a], h[b]);
}

void down(int u)
{
    int t = u;
    if (u * 2 <= s && h[t] > h[2 * u]) t = 2 * u;
    if (u * 2 + 1 <= s && h[t] > h[2 * u + 1]) t = 2 * u + 1;
    if (t != u) heap_swap(t, u), down(t); 
}

void up(int u)
{
    while (u / 2 && h[u] < h[u / 2])
    {
        heap_swap(u, u / 2);
        u /= 2;
    }
}

int main()
{
    scanf("%d", &n);

    while (n -- )
    {
        string op;
        int k, x;
        cin >> op;

        if (op == "I")
        {
            scanf("%d", &x);
            s ++, m ++ ;
            hp[s] = m, ph[m] = s;
            h[s] = x;
            up(s);
        }
        else if (op == "PM") printf("%d\n", h[1]);
        else if (op == "DM")
        {
            heap_swap(1, s);
            s -- ;
            down(1);
        }
        else if (op == "D")
        {
            scanf("%d", &k);
            k = ph[k];
            heap_swap(k, s);
            s -- ;
            down(k), up(k);
        }
        else if (op == "C")
        {
            scanf("%d %d", &k, &x);
            k = ph[k];
            h[k] = x;
            down(k), up(k);
        }
    }
}