数据结构（一）

一 链表：

• 单链表(用数组模拟）

    用数组模拟链表相比于通过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数组均为最大前缀和最后一个元素下标