基础-链表队列和KMP（数组模拟）

目录

总结

单链表

代码

双链表

单调栈

单调队列/滑动窗口

---

为什么是数组模拟？

结构体搭建的动态结构，需要new，但这个操作非常慢，写笔试不会用的。

单链表：用来存储图和树（邻接表）

双链表：用来优化某些问题

总结

单调栈、单调队列与双指针算法的思路类似，即先通过暴力算法写出来，然后观察规律（是不有单调性），双指针算法通过一个while限定减少循环的次数；单调栈、单调队列则直接在接口出拿最大最小值，两者适用的场合都非常单一，即单调栈解决距离某个数最近的比他大/小的问题，单调队列求解滑动窗口的最值；

单链表

存储方式：一个数组存数值，一个数组存索引

代码

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 1e5+10;
/**
 * head表示头节点的下标
 * e[i]表示结点i的值
 * ne[i]表示结点i的next指针是多少
 * idx存储当前已经用到了哪个结点
 * 
 * */

int e[N],ne[N],head,idx;

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

void add_to_head(int x){
    e[idx]=x;
    ne[idx] =head;
    head=idx;
    idx++;
}

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

void de(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);
        }
        
        if(op=='D'){
            
            cin>>k;
            if(k==0) head=ne[head];
            else de(k-1);
        }
        
        if(op=='I'){
            cin>>k>>x;
            add(k-1,x);
        }
        
    }
    
    for(int i=head;i!=-1;i=ne[i]) cout << e[i]<<" ";
    
}

双链表

#include<iostream>

using namespace std;

const int N=100010;
int l[N],r[N],e[N],idx;

void init()
{
    r[0]=1;
    l[1]=0;
    idx=2;
}

//在下标为k的节点右边插入新节点
void insert(int k,int x)
{
    e[idx]=x;//赋值
    r[idx]=r[k];//新插入点的右节点为下标为k的右节点
    l[idx]=k;//新插入点的左节点为k
    l[r[k]]=idx;//下标为k的节点的右节点的左节点为idx
    r[k]=idx;//下标为k节点的右节点更新为idx
    idx++;
}

//删除下标为k的节点
void remove(int k)
{
    r[l[k]]=r[k];
    l[r[k]]=l[k];
}

int main()
{
    int m;
    scanf("%d",&m);
    init();
    while(m--)
    {
        string op;
        cin>>op;
        int k,x;
        if(op=="L")
        {
            int x;
            scanf("%d",&x);
            insert(0,x);
        }
        else if(op=="R")
        {
            int x;
            scanf("%d",&x);
            insert(l[1],x);
        }
        else if(op=="D")
        {
            int k;
            scanf("%d",&k);
            remove(k+1);
        }
        else if(op=="IL")
        {
            int k,x;
            scanf("%d %d",&k,&x);
            insert(l[k+1],x);
        }
        else
        {
            int k,x;
            scanf("%d %d",&k,&x);
            insert(k+1,x);
        }
    }
    for(int i=r[0];i!=1;i=r[i]) printf("%d ",e[i]);
    return 0;
}

单调栈

#include <iostream>
using namespace std;
const int N = 100010;
int stk[N], tt;

int main()
{
    int n;
    cin >> n;
    while (n -- )
    {
        int x;
        scanf("%d", &x);
        while (tt && stk[tt] >= x) tt -- ;//如果栈顶元素大于当前待入栈元素，则出栈
        if (!tt) printf("-1 ");//如果栈空，则没有比该元素小的值。
        else printf("%d ", stk[tt]);//栈顶元素就是左侧第一个比它小的元素。
        stk[ ++ tt] = x;
    }
    return 0;
}

单调队列/滑动窗口

#include <iostream>
#include <cstring>
#include <algorithm>
#include <deque>
using namespace std;

const int N = 1000010;
int a[N];
int main()
{
    int n, k;
    cin >> n >> k;
    for (int i = 1; i <= n; i ++ ) cin >> a[i];//读入数据
    deque<int> q;
    for(int i = 1; i <= n; i++)
    {
        while(q.size() && q.back() > a[i]) //新进入窗口的值小于队尾元素，则队尾出队列
            q.pop_back();
        q.push_back(a[i]);//将新进入的元素入队
        if(i - k >= 1 && q.front() == a[i - k])//若队头是否滑出了窗口，队头出队 
            q.pop_front();
        if(i >= k)//当窗口形成，输出队头对应的值
            cout << q.front() <<" ";
    }
    q.clear();
    cout << endl;

    //最大值亦然
    for(int i = 1; i <= n; i++)
    {
        while(q.size() && q.back() < a[i]) q.pop_back();
        q.push_back(a[i]);
        if(i - k >= 1 && a[i - k] == q.front()) q.pop_front(); 
        if(i >= k) cout << q.front() << " ";

    }
}