Acwing-数据结构
ACwing《算法基础课》笔记（二）
数据结构
单链表
对于传统的链表，由于malloc申请空间的效率太低，所以在面试和其他算法考试中常常用数组来模拟链表，从而实现更高效的操作。
// head 表示头结点的下标
// e[i] 表示节点i的值
// ne[i] 表示节点i的next指针是多少
// idx 存储当前已经用到了哪个点
//i表示的其实是第i个插入的节点
如e[1]=2,则该节点存放值为2，下一个节点的下标为ne[1],假设为3，则这个结点下一个为e[3];
int head, e[N], ne[N], idx;
//以下实现均为无头结点链表
// 无头结点初始化
void init()
{
head = -1;
idx = 0;
}
//带头结点初始化,头结点存储长度，元素下标从1开始
void init()
{
head = 0;
// 头结点
e[0] = 0; // 值为链表长度
ne[0] = -1;
idx = 1; // 第1个结点的下标从1开始
}
// 在链表头插入一个数a，逻辑与传统的链表相似，即先建立新元素与后面的关系，再把前一个的ne设为当前新元素。
void insert(int a)
{
e[idx] = a, ne[idx] = head, head = idx ++ ;
}
// 将头结点删除，需要保证头结点存在
void remove()
{
head = ne[head];
}
/** 删除下标为k后面的数 */
void rem(int k) {
ne[k] = ne[ne[k]];
}
/** 在下标为k的位置后插入一个数 */
void insert(int k, int x) {
e[idx] = x;
ne[idx] = ne[k];
ne[k] = idx;
idx++;
}
/** 遍历链表 */
void print() {
for (int i = head; i != -1; i = ne[i]) cout << e[i] << " ";
}
双链表
// e[]表示节点的值，l[]表示节点的左指针，r[]表示节点的右指针，idx表示当前用到了哪个节点
int e[N], l[N], r[N], idx;
// 初始化
void init()
{
//0是左端点，1是右端点
r[0] = 1, l[1] = 0;
idx = 2;
}
// 在节点a的右边插入一个数x
void insert(int a, int x)
{
e[idx] = x;
l[idx] = a, r[idx] = r[a];
l[r[a]] = idx, r[a] = idx ++ ;
}
// 删除节点a
void remove(int a)
{
l[r[a]] = l[a];
r[l[a]] = r[a];
}
//输出,遍历时从头结点的下一个位置开始（r[0]），直到遍历到尾结点（下标为0）
void print() {
for (int i = r[0]; i != 1; i = r[i]) printf("%d ", e[i]);
}
模拟栈
int stk[N], tt = 0; // tt表示栈顶，而非栈顶下一个元素
// 向栈顶插入一个数
stk[ ++ tt] = x;//注意是++tt而非tt++
// 从栈顶弹出一个数
tt -- ;
// 栈顶的值
stk[tt];
//注意，若tt表示栈顶下一个元素，则必须：
int u =tt--;
stk[u]
//否则tt值会改变
// 判断栈是否为空
if (tt) {...} // 栈不为空
队列
普通队列
// hh 表示队头，tt表示队尾
int q[N], hh = 0, tt = -1;
//队列长度为tt+1-hh
// 向队尾插入一个数
q[ ++ tt] = x;
// 从队头弹出一个数
hh ++ ;
// 队头的值
q[hh];
// 判断队列是否为空
if (hh >tt)
{
***
}
循环队列
// hh 表示队头，tt表示队尾的后一个位置
int q[N], hh = 0, tt = 0;
// 向队尾插入一个数
q[tt ++ ] = x;
if (tt == N) tt = 0;
// 从队头弹出一个数
hh ++ ;
if (hh == N) hh = 0;
// 队头的值
q[hh];
// 判断队列是否为空
if (hh == tt){...}
说明：
- 这种实现方式与普通队列方式有点区别，在这里是先存入，后++，故tt初值为0
- 可以把入队改成q[tt] = x; tt = (tt + 1) % N;，出队改成hh = (hh + 1) % N; x = q[hh];
- 队满判断可用(tt + 1) % N == hh
- 队列长度可用(tt - hh + N) % N求出
单调栈
用途：
为每个数找出满足如下条件的数：
- 在它左边
- 距离最近
- 比它小（大）
//这里st存放的是元素，但其实也可以存下标
int tt = 0;
for (int i = 1; i <= n; i ++ )
{
while (tt && check(stk[tt], i)) tt -- ;
stk[ ++ tt] = i;
}
//时间复杂度由O(n2)降为O(n)
单调队列
用途：
找出滑动窗口中的最大值（最小值）
//这里st存放的是下标
int hh = 0, tt = -1;
for (int i = 0; i < n; i ++ )
{
while (hh <= tt && check_out(q[hh])) hh ++ ; // 判断队头是否滑出窗口
while (hh <= tt && check(q[tt], i)) tt -- ;
q[ ++ tt] = i;
}
//时间复杂度由O(nk)O(nk)降为O(n+k)
KMP
// s[]是长文本，p[]是模式串，n是s的长度，m是p的长度
// 求模式串的Next数组：
for (int i = 2, j = 0; i <= m; i ++ )
{
while (j && p[i] != p[j + 1]) j = ne[j];
if (p[i] == p[j + 1]) j ++ ;
ne[i] = j;
}
// 匹配
for (int i = 1, j = 0; i <= n; i ++ )
{
while (j && s[i] != p[j + 1]) j = ne[j];
if (s[i] == p[j + 1]) j ++ ;
if (j == m)
{
j = ne[j];
// 匹配成功后的逻辑
}
}
//注意：
//使用KMP算法时，起始下标为1
//字符串可用char数组保存，读入时用cin >> p + 1读取，表示从下标1开始写入字符串
//求next数组时，由于ne[1]初始化已经为0，故从2开始计算
//j == 0表示从头开始匹配模式串，匹配时用p[j + 1]比较
关于字符串：cin输入字符串s[n]的时候，可以用cin>>a(从a[0]开始存储，也可用cin>>a=1从a[1]开始存储等)的方式来输入，对于其他类型的数组，如int a[n]则不行。
Trie树
用途：
快速存储和查找字符串集合，又称字典树
int son[N][26], cnt[N], idx;
// 0号点既是根节点，又是空节点
//结点的存储类似行优先的原则，即son[i][]中的下标i表示每一个节点，结点内容用第二维表示
// son[][]存储树中每个节点的子节点，如son[x][0]表示结点序号x的第0个儿子
// cnt[]存储以每个节点结尾的单词数量
// 插入一个字符串
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];
}
cnt[p] ++ ;
}
// 查询字符串出现的次数
int query(char *str)
{
int p = 0;
for (int i = 0; str[i]; i ++ )
{
int u = str[i] - 'a';
if (!son[p][u]) return 0;
p = son[p][u];
}
return cnt[p];
}
说明：
- son数组的第1维表示结点编号，要大于所有存储的字符串长度的和（不是字符串长度的最大值）；第2维表示每个结点的最大分支数，一般取字符种类数（如小写字母有26个）
- cnt[i]表示以son[i]结点为末尾的字符串的个数
并查集
用途：
- 将两个集合合并
- 询问两个元素是否在一个集合当中
基本原理：
每个集合用一棵树来表示，树根编号就是集合的编号，每个结点存储其父节点，p[x]表示x的父节点。
问题1：如何判定根节点？
if(p[x]==x)
问题2：如何求x集合编号？
while(p[x]!=x) x=p[x]
问题3：如何合并两个集合？
p[x]是x的编号，p[y]是y的编号，令p[x]=y即可（也就是直接将一个集合的根节点作为另一个集合树根的根节点）
优化：
- 路径压缩：一旦找到根节点，就将所有的子节点直接指向树根
- 按值合并（略，较少用到）
朴素并查集
int p[N]; //存储每个点的祖宗节点
// 返回x的祖宗节点
int find(int x)
{
if (p[x] != x) p[x] = find(p[x]); // 路径压缩
return p[x];
}
// 初始化，假定节点编号是1~n
for (int i = 1; i <= n; i ++ ) p[i] = i;
// 合并a和b所在的两个集合：
p[find(a)] = find(b);
// 判断两个结点是否属于同一集合
if (find(a) == find(b)) {...}
维护size的并查集
int p[N], size[N]; // 变动部分
//p[]存储每个点的祖宗节点, size[]只有祖宗节点的有意义，表示祖宗节点所在集合中的点的数量
// 返回x的祖宗节点
int find(int x)
{
if (p[x] != x) p[x] = find(p[x]);
return p[x];
}
// 初始化，假定节点编号是1~n
for (int i = 1; i <= n; i ++ )
{
p[i] = i;
size[i] = 1; // 变动部分
}
// 合并a和b所在的两个集合：
int x = find(a), y = find(b);
if (x != y) {
p[x] = y;
size[y] += size[x];
}
// 判断两个结点是否属于同一集合
if (find(a) == find(b)) {...}
说明：
- size[x]存储的是以该结点为根的树的结点数
- 在合并操作中，可以不必把find(a)和find(b)存入两个变量。因为第一次调用find()时会进行路径压缩，下一次调用就是O(1)复杂度了。但要注意先修改size再合并结点，二者顺序不可颠倒，因为结点含义会改变
- 改变size时，要先判断两个集合是否为同一个
- 在两个彼此不连通的连通图加上一条边连通二者，等价于把两个集合合并
- 为了避免合并步骤中出现顺序问题，可以用两个变量表示，同时也减少了代码量
维护到祖宗节点距离的并查集
int p[N], d[N];
//p[]存储每个点的祖宗节点, d[x]存储x到p[x]的距离
// 返回x的祖宗节点
int find(int x)
{
if (p[x] != x)
{
int u = find(p[x]); // 先更新d[p[x]]
d[x] += d[p[x]]; // 再更新d[x]
p[x] = u; // 最后更新p[x]
}
return p[x];
}
// 初始化，假定节点编号是1~n
for (int i = 1; i <= n; i ++ )
{
p[i] = i;
d[i] = 0; // 自身到自身的距离是0
}
// 合并a和b所在的两个集合：
p[find(a)] = find(b);
d[find(a)] = distance; // 根据具体问题，初始化find(a)的偏移量
//注意find函数语句的先后次序，次序不对可能会导致含义错误
堆
堆是一个完全二叉树（下标从1开始），即STL中的优先队列。
且此处用一维数组存储。
用途：
//以小根堆（每一点小于等于左右两个子节点）为例：
//插入一个数：
heap[++size]=x,up(size)
//求集合里的最小值
heap[1]
//删除最小值
heap[1]=heap[size];size--;down(1)
//删除任意一个元素
heap[k]=heap[size];size--;down(k),up(k)
//修改任意一个元素
heap[k]=x;down(k),up(k)
普通模板：
// h[N]存储堆中的值, h[1]是堆顶，x的左儿子是2x, 右儿子是2x + 1
int h[N], size;}
void down(int u)
{
int t = u;
if (u * 2 <= size && h[u * 2] < h[t]) t = u * 2;
if (u * 2 + 1 <= size && h[u * 2 + 1] < h[t]) t = u * 2 + 1;
if (u != t)
{
swap(u, t);
down(t);
}
}
void up(int u)
{
while (u / 2 && h[u] < h[u / 2])
{
swap(u, u / 2);
u >>= 1;
}
}
// --------------------------------基本操作--------------------------------
// 0. 建堆
void init() {
for (int i = n / 2; i; i -- ) down(i);
}
// 1. 插入一个数
void insert(int x) {
h[++size] = x;
up[size];
}
// 2. 求最小值
int top() {
return h[1];
}
// 3. 删除最小值
void remove() {
h[1] = h[size];
size--;
down(1);
}
// 4. 删除任意位置的元素（STL没有）
void remove(int k) {
h[k] = h[size];
size--;
down(k);
up(k);
}
// 5. 修改任意位置的元素（STL没有）
void update(int k, int x) {
h[k] = x;
down(k);
up(k);
}
说明：
- 所有基本操作都可由up()和down()组合而成
- 建堆的时间可以看做是O(n)O(n)，因为只有n2n2个结点参与建堆，这些结点向下调整的次数至多为2h−1×1+2h−2×2+21×(d−2)+20×(d−1)2h−1×1+2h−2×2+21×(d−2)+20×(d−1)，由错位相减法可知结果<n<n
- 实现down时，注意t的含义是当前最小结点的下标，是变化的，而u是不变的，不要与u的含义弄混
- STL没有基本操作4和基本操作5，尽管它们实现时同时调用了down()和up()，但实际上只会执行其中一个
- 建堆是从n/2逆着遍历到1
加强模板
// h[N]存储堆中的值, h[1]是堆顶，x的左儿子是2x, 右儿子是2x + 1
// ph[k]存储第k个插入的点在堆中的位置
// hp[k]存储堆中下标是k的点是第几个插入的
int h[N], ph[N], hp[N], size, m;
// 加强swap
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 <= size && h[u * 2] < h[t]) t = u * 2;
if (u * 2 + 1 <= size && h[u * 2 + 1] < h[t]) t = u * 2 + 1;
if (u != t)
{
heap_swap(u, t); // 加强swap
down(t);
}
}
void up(int u)
{
while (u / 2 && h[u] < h[u / 2])
{
heap_swap(u, u / 2); // 加强swap
u >>= 1;
}
}
// --------------------------------基本操作--------------------------------
// 0. 建堆
void init() {
for (int i = n / 2; i; i -- ) down(i);
}
// 1. 插入一个数
void insert(int x) {
h[++size] = x;
ph[++m] = size; // m为当前插入的序号
hp[size] = m;
up[size];
}
// 2. 求最小值
int top() {
return h[1];
}
// 3. 删除最小值
void remove() {
heap_swap(1, siz); // 加强swap
size--;
down(1);
}
// 4. 删除第k次插入的元素（STL没有）
void remove(int k) {
k = ph[k];
heap_swap(k, size); // 加强swap
size--;
down(k);
up(k);
}
// 5. 修改第k次插入的元素（STL没有）
void update(int k, int x) {
k = ph[k];
h[k] = x;
down(k);
up(k);
}
说明：
- 加强模板额外存储了插入记录ph，映射插入序号和元素在堆中的位置，同时构建了ph的逆映射hp，可根据堆中的下标反推插入序号
- 所有swap改成加强版的heap_swap，因为要维护ph和hp
- 在heap_swap中，由于参数是下标，但ph数组需要提供插入序号k，因此可用数组hp的值来作为ph的下标
哈希表
常用流程：
- h(x)=x mod "质数"（这是常用哈希函数）
- 处理冲突（拉链法、开放寻址法）
模板：
// (1) 拉链法
int h[N], e[N], ne[N], idx;
//寻找大于映射的目标范围的最小质数，此处以目标范围100000为例
for(int i=100000;;i++){
bool flag=true;
for(int j=2;j*j<=i;j++){
if(i%j==0){
flag=false;
break;
}
}
if(flag){
cout<<i;
break;
}
}
// 向哈希表中插入一个数
void insert(int x)
{
int k = (x % N + N) % N;
e[idx] = x;
ne[idx] = h[k];
h[k] = idx ++ ;
}
// 在哈希表中查询某个数是否存在
bool find(int x)
{
int k = (x % N + N) % N;
for (int i = h[k]; i != -1; i = ne[i])
if (e[i] == x)
return true;
return false;
}
// (2) 开放寻址法
const int null = 0x3f3f3f3f;
int h[N];
memset(h, 0x3f, sizeof h); // 给h的每个字节初始化成0x3f，使得每个元素的值都是null
// 如果x在哈希表中，返回x的下标；如果x不在哈希表中，返回x应该插入的位置
int find(int x)
{
int t = (x % N + N) % N;
while (h[t] != null && h[t] != x)
{
t ++ ;
if (t == N) t = 0;
}
return t;
}
说明：
-
(x % N + N) % N首先把x缩放到满足abs(x) < N，由于第一次求余的结果可能是负数，因此还要再进行一次求余
-
用单链表实现拉链法
-
用质数作为长度可以使得冲突最少（数学能证明）
-
可以事先实现一个求质数的函数，算出比N大的最小质数，作为N的值
-
离散化是哈希的特例，因为离散化要求相对顺序不变，而哈希没有要求
-
哈希表的删除是通过标记实现的
-
开放寻址法手动设定null的值，其值可根据题目给出的元素数值范围设计。例如元素值的绝对值≤109，又知0x3f3f3f3f> ，但memset只能按字节赋值，而一个int有四个字节,每个字节0x3f，故可考虑0x3F3F3F3F，经检验它>109，故可使用memset(h, 0x3f, sizeof h);为数组元素赋初值null
-
补充：0x3f3f3f3f的十进制是1061109567，是级别的（和0x7fffffff一个数量级），而一般场合下的数据都是小于，所以它可以作为无穷大使用而不致出现数据大于无穷大的情形。另一方面，由于一般的数据都不会大于10^9，所以当我们把无穷大加上一个数据时，它并不会溢出（这就满足了“无穷大加一个有穷的数依然是无穷大”），事实上0x3f3f3f3f+0x3f3f3f3f=2122219134，这非常大但却没有超过32-bit int的表示范围，所以0x3f3f3f3f还满足了我们“无穷大加无穷大还是无穷大”的需求。
最后，0x3f3f3f3f还能给我们带来一个意想不到的额外好处：
如果我们想要将某个数组清零，我们通常会使用memset(a,0,sizeof(a))，方便又高效，但是当我们想将某个数组全部赋值为无穷大时，就不能使用memset函数而得自己写循环了，因为memset是按字节操作的，它能够对数组清零是因为0的每个字节都是0（一般我们只有赋值为-1和0的时候才使用它）。现在好了，如果我们将无穷大设为0x3f3f3f3f，那么奇迹就发生了，0x3f3f3f3f的每个字节都是0x3f！所以要把一段内存全部置为无穷大，我们只需要memset(a,0x3f,sizeof(a))。
字符串哈希
用途
O(1)代价计算子串的哈希值
模板：
typedef unsigned long long ULL;
ULL h[N], p[N]; // h[k]存储字符串前k个字母的哈希值, p[k]存储 P^k mod 2^64
const int P = 131; // 或13331
// 初始化
p[0] = 1;
for (int i = 1; i <= n; i ++ )
{
h[i] = h[i - 1] * P + str[i];
p[i] = p[i - 1] * P;
}
// 计算子串 str[l ~ r] 的哈希值
ULL get(int l, int r)
{
return h[r] - h[l - 1] * p[r - l + 1];
}
说明：
-
取模的数选用264264，这样可用unsigned long long类型自动进行求余运算，因为该类型溢出等价于mod264264
-
质数p可取经验值131或13331
-
sisi取s[i]的ASCII值
-
方法类似前缀和，只是这里还要额外乘上pr−l+1pr−l+1，具体过程如下图所示
STL模板
vector
// vector, 变长数组，实现：倍增的思想
size() // 返回元素个数
empty() // 返回是否为空
clear() // 清空
front() / back()
push_back() / pop_back()
begin() / end()
[]
// 支持比较运算，按字典序
遍历：
1.for(int i=0;i<a.size();i++) cout<<a[i]
2.for(auto i=a.begin();i!=a.end();i++) cout<<a[i]
3.for(auto x:a)cout<<x
pair二元组
// pair<int, int>
p.irst, 第一个元素
p.second, 第二个元素
// 支持比较运算，以first为第一关键字，以second为第二关键字（字典序）
e.g
pair<int,string> p;
p=make_pair(123,"zyh")
p={123,zyh}
pair<int ,pair<int,int>>//三元组
string字符串
// string，字符串
size() / length() // 返回字符串长度
empty()
clear()
substr(起始下标，(子串长度)) // 返回子串
c_str() // 返回字符串所在字符数组的起始地址
printf("%s",a.c_str())//用printf输出
支持+，-，+=，-=操作
queue队列
// queue, 队列
size()
empty()
push() // 向队尾插入一个元素
front() // 返回队头元素
back() // 返回队尾元素
pop() // 弹出队头元素
//无clear操作，若欲clear，则重新初始化即可：
q=queue<int>()
priority_queue优先队列
// priority_queue, 优先队列，默认是大根堆
size()
empty()
push() // 插入一个元素
top() // 返回堆顶元素
pop() // 弹出堆顶元素
// 定义成小根堆的方式：1. priority_queue<int, vector<int>, greater<int>> q;
// 2.通过插入-x变成小根堆
stack
// stack, 栈
size()
empty()
push() // 向栈顶插入一个元素
top() // 返回栈顶元素
pop() // 弹出栈顶元素
deque
// deque, 双端队列
size()
empty()
clear()
front() / back()
push_back() / pop_back()
push_front() / pop_front()
begin() / end()
[]
set, map, multiset, multimap
// set, map, multiset, multimap, 基于平衡二叉树（红黑树），动态维护有序序列
size()
empty()
clear()
begin() / end()
// ++, -- 返回前驱和后继，时间复杂度 O(logn)
// set/multiset
insert() // 插入一个数
find() // 查找一个数
count() // 返回某一个数的个数
erase()
// (1) 输入是一个数x，删除所有x O(k + logn)k是x个数
// (2) 输入一个迭代器，删除这个迭代器
lower_bound()/upper_bound()
lower_bound(x) // 返回大于等于x的最小的数的迭代器
upper_bound(x) // 返回大于x的最小的数的迭代器
// map/multimap
insert() // 插入的数是一个pair
erase() // 输入的参数是pair或者迭代器
find()
[] // 注意仅限map，而multimap不支持此操作。 时间复杂度是 O(logn)
lower_bound() / upper_bound()
哈希表
// unordered_set, unordered_map, unordered_multiset, unordered_multimap, 哈希表
// 和上面类似，增删改查的时间复杂度是 O(1)
// 不支持 lower_bound()/upper_bound()， 迭代器的++，--
bitset
// bitset, 圧位
bitset<10000> s;
// ~, &, |, ^
// >>, <<
// ==, !=
// []
count() // 返回有多少个1
any() // 判断是否至少有一个1
none() // 判断是否全为0
set() // 把所有位置成1
set(k, v) // 将第k位变成v
reset() // 把所有位变成0
flip() // 等价于~
flip(k) // 把第k位取反
说明：
- 系统为某程序分配空间所需要的时间与空间大小无关，而与申请次数有关
- 一般都有size,empty,但不是每个都有clear
【推荐】国内首个AI IDE，深度理解中文开发场景，立即下载体验Trae
【推荐】编程新体验，更懂你的AI，立即体验豆包MarsCode编程助手
【推荐】抖音旗下AI助手豆包，你的智能百科全书，全免费不限次数
【推荐】轻量又高性能的 SSH 工具 IShell：AI 加持，快人一步
· 震惊！C++程序真的从main开始吗？99%的程序员都答错了
· 单元测试从入门到精通
· 【硬核科普】Trae如何「偷看」你的代码？零基础破解AI编程运行原理
· 上周热点回顾（3.3-3.9）
· winform 绘制太阳，地球，月球 运作规律