单链表：
// head存储链表头，e[]存储节点的值，ne[]存储节点的next指针，idx表示当前用到了哪个节点
int head, e[N], ne[N], idx;
// 初始化
void init()
{
head = -1;
idx = 0;
}
// 在链表头插入一个数a
void insert(int a)
{
e[idx] = a, ne[idx] = head, head = idx ++ ;
}
// 将头结点删除，需要保证头结点存在
void remove()
{
head = ne[head];
}
附上一道例题，便于理解：
## 题目：
实现一个单链表，链表初始为空，支持三种操作：
(1) 向链表头插入一个数；
(2) 删除第k个插入的数后面的数；
(3) 在第k个插入的数后插入一个数
现在要对该链表进行M次操作，进行完所有操作后，从头到尾输出整个链表。
注意:题目中第k个插入的数并不是指当前链表的第k个数。例如操作过程中一共插入了n个数，则按照插入的时间顺序，这n个数依次为：第1个插入的数，第2个插入的数，…第n个插入的数。
输入格式
第一行包含整数M，表示操作次数。
接下来M行，每行包含一个操作命令，操作命令可能为以下几种：
(1) “H x”，表示向链表头插入一个数x。
(2) “D k”，表示删除第k个输入的数后面的数（当k为0时，表示删除头结点）。
(3) “I k x”，表示在第k个输入的数后面插入一个数x（此操作中k均大于0）。
输出格式
共一行，将整个链表从头到尾输出。
数据范围
1≤M≤1000001≤M≤100000
所有操作保证合法。
#include<iostream>
#include<bits/stdc++.h>
using namespace std;
const int N = 1e6+10;
int idx , head , n[N] , ne[N];
// head存储链表头，e[]存储节点的值，ne[]存储节点的next指针，idx表示当前用到了哪个节点
int a;
void add_head(int x)
{
n[idx] = x;
ne[idx] = head;
head = idx++;
}
void add(int k , int x)
{
n[idx] = x;
ne[idx] = ne[k];
ne[k] = idx++;
}
void remove(int k)
{
ne[k]=ne[ne[k]];
}
int main()
{
head = -1;
idx = 0;
cin >> a;
while(a--)
{
string op;
int k , x;
cin >> op;
if(op == "D")
{
cin >> k;
if(!k)
head = ne[head];
remove(k-1);
}
else if(op=="H")
{
cin >> x;
add_head(x);
}
else if(op=="I")
{
int k , x;
cin >> k >> x;
add(k-1,x);
}
}
for(int i = head;i!=-1;i=ne[i])
cout << n[i] << " ";
return 0;
}
双链表：
// 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];
}
单调栈：
举个例子：
给定一个长度为N的整数数列，输出每个数左边第一个比它小的数，如果不存在则输出-1。
输入：
5
3 4 2 7 5
输出：
-1 3 -1 2 2
类似此题便可用单调栈来做
常见模型：找出每个数左边离它最近的比它大/小的数
代码：
#include<iostream>
#include<vector>
#include<stack>
#include<bits/stdc++.h>
using namespace std;
const int N 1e6+10;
int a[N];
stack<int>s;
int main()
{
int n;
cin >> n;
for (int i = 0; i < n; ++i)
{
int k;
cin >> k;
while (!s.empty() && k <= s.top())
s.pop();
a[i] = s.empty() ? -1 : s.top();
s.push(k);
}
for(int i=0;i<n;i++)
cout << a[i] << " ";
cout << endl;
return 0;
}
单调队列：
举个例子：
有一个大小为k的滑动窗口，它从数组的最左边移动到最右边。
您只能在窗口中看到k个数字。
每次滑动窗口向右移动一个位置。您的任务是确定滑动窗口位于每个位置时，窗口中的最大值和最小值。
输入格式
输入包含两行。
第一行包含两个整数n和k，分别代表数组长度和滑动窗口的长度。
第二行有n个整数，代表数组的具体数值。
同行数据之间用空格隔开。
输出格式
输出包含两个。
第一行输出，从左至右，每个位置滑动窗口中的最小值。
第二行输出，从左至右，每个位置滑动窗口中的最大值。
输入：
8 3
1 3 -1 -3 5 3 6 7
输出：
-1 -3 -3 -3 3 3
3 3 5 5 6 7
类似此题的均可用单调队列来解答
代码：
#include <bits/stdc++.h>
using namespace std;
const int N=1e6+10;
int a[N],n,m,f,i,j,s_min[N],s_max[N];
deque<int> min_val,max_val;
int main()
{
ios::sync_with_stdio(false);
cin>>n>>m;
for(int i=1;i<=n;i++)
cin>>a[i];
min_val.push_front(1);
max_val.push_front(1);
s_min[1]=1;
s_max[1]=1;
m--;
for(int i=2;i<=n;i++)
{
while (min_val.size() && min_val.front()+m<i)//如果队头已经不满足条件,在当前候选区间了
min_val.pop_front();
while (max_val.size() && max_val.front()+m<i)//如果队头已经不满足条件,在当前候选区间了
max_val.pop_front();
while (min_val.size() && a[min_val.back()]>=a[i])//生存能力弱,弹出
min_val.pop_back();
while (max_val.size() && a[max_val.back()]<=a[i])//生存能力弱,弹出
max_val.pop_back();
//if (a[i]<=min_val.front()) 生存能力,不只是看值的大小,还有位置问题
min_val.push_back(i);
//if (a[i]>=max_val.front()) 生存能力,不只是看值的小小,还有位置问题
max_val.push_back(i);
s_min[i]=min_val.front();
s_max[i]=max_val.front();
}
for(int i=m+1;i<=n;i++)
cout<<a[s_min[i]]<<" ";
cout<<endl;
for(int i=m+1;i<=n;i++)
cout<<a[s_max[i]]<<" ";
return 0;
}
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];
// 匹配成功后的逻辑
}
}
