链表与邻接链表操作详解-CSDN博客

本文详细介绍了链表中的单链表和双链表数据结构，包括它们的操作如插入、删除等，并探讨了单调栈的概念。此外，还讨论了KMP字符串匹配算法的应用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

文章目录

链表和邻接链表
栈与队列
- 830 单调栈
kmp
- 831 kmp字符串

链表和邻接链表

数据模拟的速度会快很多，每次 new 一个新的节点，速度非常慢。

单链表

其中的领接表用的最多，主要是用来存储图和数。
在这里插入图片描述
每个点都存储了 value 和 next
e[N], ne[N] 当前的数值和next指针空节点的位置是-1

826 单链表

实现一个单链表，链表初始为空，支持三种操作：

向链表头插入一个数；
删除第 k 个插入的数后面的数；
在第 k 个插入的数后插入一个数。
现在要对该链表进行 M 次操作，进行完所有操作后，从头到尾输出整个链表。

注意:题目中第 k 个插入的数并不是指当前链表的第 k 个数。例如操作过程中一共插入了 n 个数，则按照插入的时间顺序，这 n 个数依次为：第 1 个插入的数，第 2 个插入的数，…第 n 个插入的数。

输入格式
第一行包含整数 M，表示操作次数。

接下来 M 行，每行包含一个操作命令，操作命令可能为以下几种：

H x，表示向链表头插入一个数 x。
D k，表示删除第 k 个插入的数后面的数（当 k 为 0 时，表示删除头结点）。
I k x，表示在第 k 个插入的数后面插入一个数 x（此操作中 k 均大于 0）。
输出格式
共一行，将整个链表从头到尾输出。

数据范围
1≤M≤100000
所有操作保证合法。

输入样例：

输出样例：

6 4 6 5

#include <iostream>

using namespace std;

const int N = 100010;

// head 是头结点的下标
// e[i] 是节点 i 的值
// ne[i] 表示节点 i 的 next 指针是多少
// idx 表示最新用到了哪个位置,一直只会增加 
int head, e[N], ne[N], idx;

void init() {
    idx = 0;
    head = -1;
}

// 在头部加入节点
void add_to_head(int x) {
    e[idx] = x;
    ne[idx] = head;
    head = idx;
    idx ++ ;
}

// x 这个点插入到下标为 k 的后面
void add(int k, int x) {
    e[idx] = x;
    ne[idx] = ne[k];
    ne[k] = idx;
    idx ++ ;
}

// 删除下标为 k 的后面的点
void remove(int k) {
    ne[k] = ne[ne[k]]; // 删除了就不管了，空间不用释放
}

int main() 
{
    int m;
    cin >> m;
    
    init();
    
    while (m -- ) {
        int k, x;
        char op;
        
        cin >> op;
        if (op == 'H') {
            cin >> x;
            add_to_head(x);
        } else if (op == 'D') {
            cin >> k;
            if (!k) {
                head = ne[head]; // 一定要做特判
            } else {
                remove(k - 1);
            }
        } else {
            cin >> k >> x;
            add(k - 1, x);
        }
    }
    
    for (int i = head; i != -1; i = ne[i]) cout << e[i] << ' ';
    cout << endl;
    
    return 0;
}

双链表

核心
0 作为 head， 1 作为 tail
int l[N], r[N];

827 双链表

实现一个双链表，双链表初始为空，支持 5 种操作：

在最左侧插入一个数；
在最右侧插入一个数；
将第 k 个插入的数删除；
在第 k 个插入的数左侧插入一个数；
在第 k 个插入的数右侧插入一个数
现在要对该链表进行 M 次操作，进行完所有操作后，从左到右输出整个链表。

输入格式
第一行包含整数 M，表示操作次数。

接下来 M 行，每行包含一个操作命令，操作命令可能为以下几种：

L x，表示在链表的最左端插入数 x。
R x，表示在链表的最右端插入数 x。
D k，表示将第 k 个插入的数删除。
IL k x，表示在第 k 个插入的数左侧插入一个数。
IR k x，表示在第 k 个插入的数右侧插入一个数。
输出格式
共一行，将整个链表从左到右输出。

数据范围
1≤M≤100000
所有操作保证合法。

输入样例：

10
R 7
D 1
L 3
IL 2 10
D 3
IL 2 7
L 8
R 9
IL 4 7
IR 2 2

输出样例：

8 7 7 3 2 9

初始状态
在这里插入图片描述

#include <iostream>

using namespace std;

const int N = 100010;

int m;
// idx 是最新的数值下标位置
// e[N] 是当前位置的数值是多少
// l[N] 是某个节点左边的位置
// r[N] 是某个节点右边的位置
int l[N], r[N], e[N], idx;

// 默认 0 是头的位置, 1 是尾的位置
void init() {
    r[0] = 1;
    l[1] = 0;
    idx = 2; // idx 从2开始
}

// 在 k 后面加上节点 x
void add(int k, int x) {
    e[idx] = x;
    l[idx] = k;
    r[idx] = r[k];
    l[r[k]] = idx; // 先左后右边，保证 k 的有效性
    r[k] = idx;
    idx ++ ;
}

// 删除第 k 个点
void remove(int k) {
    r[l[k]] = r[k];
    l[r[k]] = l[k]
}

栈与队列

栈就是先进后出
队列就是先进先出

模拟栈

#include <iostream>

using namespace N = 100010;

// stk[N] 栈
// tt 栈顶, 已经有数据
int stk[N], tt;

// 插入
stk[++ t] = x; 

// 弹出
tt -- ;

// 判断栈是否为空
if (tt > 0) not empty
else empty

// 栈顶
stk[tt];

队列

// **************** 队列

// q[N] 队列
// hh 队头
// tt 队尾，tt 位置上是原有的数据
// 队尾插入，队头弹出
int q[N], hh, tt = -1;

// 插入
q[++ tt] = x;

// 弹出
hh ++ ;

// 判断空
if (hh << tt) not empty
else empty

// 取出队头元素
q[hh]

单调栈
找到每个数左边满足某个条件的最近的数

830 单调栈

给定一个长度为 N 的整数数列，输出每个数左边第一个比它小的数，如果不存在则输出 −1。

输入格式
第一行包含整数 N，表示数列长度。

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

输出格式
共一行，包含 N 个整数，其中第 i 个数表示第 i 个数的左边第一个比它小的数，如果不存在则输出 −1。

数据范围
1≤N≤105
1≤数列中元素≤109
输入样例：
5

3 4 2 7 5

输出样例：

-1 3 -1 2 2

#include <iostream>

using namespace std;

const int N = 100010;

int n;
int stk[N], hh, tt;

int main() 
{
    cin >> n;
    while (n -- ) {
        int x;
        cin >> x;
        
        while (tt && stk[tt] >= x) tt -- ;
        if (tt) cout << stk[tt] <<' ';
        else cout << "-1 ";
        
        stk[++ tt] = x;
    }
    
    return 0;
}

这里的 tt 初始数值不能是 -1

kmp

831 kmp字符串

给定一个模式串 S，以及一个模板串 P，所有字符串中只包含大小写英文字母以及阿拉伯数字。

模板串 P 在模式串 S 中多次作为子串出现。

求出模板串 P 在模式串 S 中所有出现的位置的起始下标。

输入格式
第一行输入整数 N，表示字符串 P 的长度。

第二行输入字符串 P。

第三行输入整数 M，表示字符串 S 的长度。

第四行输入字符串 S。

输出格式
共一行，输出所有出现位置的起始下标（下标从 0 开始计数），整数之间用空格隔开。

数据范围
1≤N≤105
1≤M≤106
输入样例：

3
aba
5
ababa

输出样例：

0 2

S[N], p[M]

for (int i = 1; i <= n; i ++ ) {
    
    bool flag = true;
    for (int j = 1; j <= m; j ++ ) {
        if (s[i] != p[j]) {
            flag = false;
            break;
        }
    }
}

在这里插入图片描述

在这里插入图片描述
主串的某一个子串等于模式串的某一个前缀

#include <iostream>

using namespace std;

const int N = 10010, M = 100010;

int n, m;
char p[N], s[M];
int ne[N];

int main() 
{
    cin >> n >> p + 1 >> m >> s + 1;
    
    // 求 next 数组
    // ne[0] ne[1] 自动全局设置为 0, 因此第 3 个字母不匹配才会有回退的选择
    for (int i = 2, j = 0; i <= n; 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 <= m; i ++ ) {
        while (j && s[i] != p[j + 1]) j = ne[j];
        if (s[i] == p[j + 1]) j ++ ;
        if (j == n) {
            // 匹配成功
            printf("%d ", i - n);
            j = ne[j];
        }
    }
}