一 链表:
- 单链表(用数组模拟)
用数组模拟链表相比于通过new方式增添链表新节点的传统方式来说速度更快。
设置数组 e[ ] 来记录节点的值, ne[ ] 来记录此节点的next指针, 设置变量idx 来记录此节点是第几个插入的节点,每插入一个元素更新一次idx,设置变量head来表示指向头节点的指针。
利用上述变量来进行链表的基础操作:
1. 在表头插入 一个元素
void headInsert(int x)
{
e[idx] = x;
ne[idx] = head;
head = idx;
idx ++;
}
2. 删除表头元素
void headRemove()
{
head = ne[head];
}
3. 在第k个插入的元素后面插入一个元素
void insert(int k, int x)
{
e[idx] = x;
ne[idx] = ne[k - 1];
ne[k - 1] = idx;
idx ++;
}
4. 删除第k个插入的元素后面的元素
void remove(int k)
{
ne[k - 1] = ne[ne[k - 1]];
}
-
双链表
e[ ]表示节点的值,l[ ]表示节点的左指针,r[ ]表示节点的右指针,idx表示当前用到了哪个节点
双链表的基本操作:
1. 初始化( 2个端点,此时的idx ==2 )
void init()
{
l[1] = 0, r[0] = 1;
idx = 2;
}
2. 在节点k的右侧插入一个节点(在左侧插入可通过改变参数实现)
void rightInsert(int k, int x)
{
e[idx] = x;
l[r[k]] = idx;
r[idx] = r[k], l[idx] = k;
r[k] = idx;
idx ++;
}
3. 删除节点k
void remove(int k)
{
r[l[k]] = r[k];
l[r[k]] = l[k];
}
4. 在链表最左端插入元素(用L标记最左端元素,同理最右端元素可类比)
void Linsert(int x)
{
r[idx] = L;
l[L] = idx;
L = idx;
}
一个典型例题:acwing 827 双链表
代码
#include <iostream>
using namespace std;
const int N = 100010;
int m;
int e[N], l[N], r[N], idx;
// 在节点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];
}
int main()
{
cin >> m;
// 0是左端点,1是右端点
r[0] = 1, l[1] = 0;
idx = 2;
while (m -- )
{
string op;
cin >> op;
int k, x;
if (op == "L")
{
cin >> x;
insert(0, x);
}
else if (op == "R")
{
cin >> x;
insert(l[1], x);
}
else if (op == "D")
{
cin >> k;
remove(k + 1);
}
else if (op == "IL")
{
cin >> k >> x;
insert(l[k + 1], x);
}
else
{
cin >> k >> x;
insert(k + 1, x);
}
}
for (int i = r[0]; i != 1; i = r[i]) cout << e[i] << ' ';
cout << endl;
return 0;
}
此题的核心在于初始化时设置了两个虚拟节点0和1,并将idx设为3,则以后的插入节点就在0和1之间进行,此题只写了一个插入函数,其中参数k可根据题意进行自己改变,使其完成特定位置的插入。
二 栈和队列
- 栈
用skt[ ]数组表示栈, tt 表示栈顶元素所在位置
int skt[N], tt = 0;
// 进栈操作
skt[++ tt] = x;
// 出栈操作
tt --;
//判断栈是否为空
if (tt == 0) // 则为空
单调栈(序列单调排序):
模板:
常见模型: 找到序列中一个数左边小于它的最近的一个数
int tt = 0;
for (int i = 1; i <= n; i ++ )
{
while (tt && check(stk[tt], i)) tt -- ;
stk[ ++ tt] = i;
}
一个例题:acwing 830 单调栈
分析:
先通过暴力做法写出基本思路,但这种做法基本都超时,然后根据题目的性质,进行化简,减小时间复杂度。以此题为例,当序列为逆序时,时间复杂度会很大,即对一个子序列进行检查时,若最右边元素不能满足题意,则其左边所有元素都不能满足题意,所以对其左边元素的遍历就是时间的浪费,所以当元素下标与其值的大小顺序相反时,则前面的数对整个序列没有用。可用到单调栈的数据结构进行计算,代码如下:
#include <iostream>
using namespace std;
const int N = 100010;
int a[N], hh;
int n;
int main()
{
cin >> n;
int x;
for (int i = 1; i <= n ;i ++ )
{
cin >> x;
while(a[hh] >= x && hh > 0) hh --;
if (hh == 0) cout << -1 << ' ';
else cout << a[hh] << " ";
a[++ hh] = x;
}
return 0;
}
- 队列
先进先出,从队尾插入,从对头弹出
//hh 表示对头, tt表示队尾
int q[N], hh = 0, tt = -1;
// 从队尾插入元素
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)
{
}
单调队列:
模板代码:
//队列的头和尾
int hh = 0, tt = -1;
//a[]存储数组元素,q[]模拟队列
int a[N], q[N];
for (int i = 1; i <= n; i ++ )
{
if (i - k >= q[hh] && hh <= tt)) hh ++; // 判断队头是否滑出窗口以外
while (a[q[tt]] >= a[i] && hh <= tt) tt --; // 将当前元素与队列元素比较,直至找到比当前元素小的元素为止
q[++ tt] = i; // 插入当前元素
if (i - k >= 0) cout << a[q[hh]]; //维持队列头元素始终最小
典型类型 找到滑动窗口中的最大值/最小值
一个典型例题:acwing 154 滑动窗口
用单调队列相比普通队列来说不用将队列遍历而是直接取对头元素,即将时间复杂度有O(nk) 变为O(n)
- kmp算法
算法用来查找字串在原字符串中的所有位置
暴力做法是对原串的每一个字符都将子串进行遍历,若查找成功返回位置。此种算法的时间复杂度很大,容易超时(两层for循环)。而kmp算法 只有一层for循环,当字串和原串匹配时,两者都往后移动,当出现不匹配时,字串返回其最大前缀和的最后一位的下标继续进行匹配,若当下标变为0时说明主串与子串不能匹配,则继续移动主串和子串下标,直至主串遍历完毕。
模板:
// 匹配
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算法最核心的地方在于next数组(next[i]存取的是下标i的最大前缀和的最后一位的下标j)的获取。
求模式串的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;
}
j 从 0开始,最后所存储的ne数组均为最大前缀和最后一个元素下标