基础算法模板-CSDN博客

单链表：

// 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];
        // 匹配成功后的逻辑
    }
}