数据结构 链表

链表

以下链表均由数组模拟

单链表

基本操作:(对k结点)

1. 这里删除节点不是真删除而是让k节点的指向下一个节点的下一个节点
2. 在k的右侧增加节点:增加节点要先把新节点i指向k节点的下一个节点,再把k节点指向i节点,反过来就找不到k节点
3. 用数组模拟开两个数组,e和ne,记一个序号idx(代表已经真实使用的点数,删除点不改idx),该序号用来区分不同的点
   1. e[i]代表第i个节点的值,i为序号,是我们认为规定的
   2. ne[i]代表第i个节点的下一个节点的序号
4. 本例中头节点用head变量表示,head的值是头节点的序号,对应的e[head]就是头节点的值,这里head仅仅是记录头节点在哪的变量,所以head不是一个空结点,向头部插入不是向头的右侧插入而是直接改头,没有使用时head=-1,头插一个点时e[head]就存在了,e[head]存值

代码:

/*
实现一个单链表，链表初始为空，支持三种操作：向链表头插入一个数；删除第 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
所有操作保证合法。
输入样例：
10
H 9
I 1 1
D 1
D 0
H 6
I 3 6
I 4 5
I 4 5
I 3 4
D 6
输出样例：
6 4 6 5
*/
#include <iostream>
using namespace std;
const int N = 1e6+10;
int head,idx,e[N],ne[N];//e[i]是序号为i点值,ne[i]表示i的下一个点的序号,一定区分清楚
//idx !序号,从0开始
void init()
{
    head = -1;//-1相当于序号,序号为-1的点就是头
    idx = 0;//idx从0开始
}
//把点插入头节点
void add_to_head(int x){
    e[idx] = x;//第idx个点的值为x
    ne[idx] = head;//向头部插入不是向头的右侧插入而是直接改头
    head = idx ++;//跟新头节点序号为idx,idx++表示这步用了一个点,++
}
//在k(序号)后面一个插入
void add(int k,int x){
    e[idx] = x;//新点(idx)赋值
    ne[idx] = ne[k];//序号为idx的下一个点为序号为k的下一个点
    ne[k] = idx++;//k的下一个点序号为idx
}
//删除k(序号)数
void remove (int k){
    ne[k] = ne[ne[k]];//k的下一个点的序号变为k的下一个的下一个点的序号,删除了k的下一个点
}
int main()
{
    init();
    int n;scanf("%d",&n);
    char a;
    int o1,o2;
    while(n--){
        
        //!scanf("%c",&a); 这样过不了题,这里在下一次会读入空格! 用cin保险
        //或者用op[2] scanf("%s",op);
        cin>>a;
        if(a == 'H'){
            scanf("%d",&o1);
            add_to_head(o1);
        }else if (a == 'D'){
            scanf("%d",&o1);
            if(!o1){//特判 o1为0删除头结点
                head = ne[head];//删除头节点是删除头结点本身,所以直接等于ne[head]
            }else {
                remove (o1-1);//删除第o1个点,o1从1开始,我们idx从0开始,所以o1-1 下面同
            }
        }else{
            scanf("%d %d",&o1,&o2);
            add(o1-1,o2);
        }
    }
    for(int i = head;i != -1;i = ne[i]){
        printf("%d ",e[i]);
    }
    return 0;
}

双链表

基本操作和单链表差不多,l[i]代表i结点左侧的结点,r[i]代表i结点右侧的结点,
**初始化:**注意双链表初始化时就有两个结点
代码:

/*
 * @Author: ACCXavier
 * @Date: 2021-04-11 21:11:48
 * @LastEditTime: 2021-04-14 23:46:25
 * Bilibili https://space.bilibili.com/7469540
 * @keywords:  双链表
 实现一个双链表，双链表初始为空，支持 5 种操作：
在最左侧插入一个数；
在最右侧插入一个数；
将第 k 个插入的数删除；
在第 k 个插入的数左侧插入一个数；
在第 k 个插入的数右侧插入一个数
现在要对该链表进行 M 次操作，进行完所有操作后，从左到右输出整个链表。

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

输入格式
第一行包含整数 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 = 1e6 + 10;  //!
int idx, e[N], r[N], l[N];
void add(int k, int x)  // k右侧插入
{
    e[idx] = x;
    r[idx] = r[k];//idx右侧是k右侧的点
    l[idx] = k;//idx左侧是k左侧的点
    //下面两个顺序不能颠倒
    l[r[k]] = idx;//r[k]代表k右侧点的序号 k右侧点的左侧点的序号改为idx
    r[k] = idx++;//k右侧点改为idx 上一步用了r[k]所以这两部顺序不能颠倒
    //为了实现在k左侧插入可以在k的左边的点执行该函数
}
void remove(int k) {
    //这两个顺序无所谓
    r[l[k]] = r[k];
    l[r[k]] = l[k];
}
void init() {
    r[0] = 1;  //头节点
    l[1] = 0;  //尾节点
    idx = 2;   //用了两个点
}
int main() {
    init();  // 不要忘记执行init();
    ios::sync_with_stdio(false);
    cin.tie(0);
    int n;
    cin >> n;
    string a;  // 2
    int x, k;
    while (n--) {
        cin >> a;
        if (a == "L") {
            cin >> x;
            add(0, x);//此处0是左端点,插入在左端点的右侧也就是第一个点的左侧,最左侧
        } else if (a == "R") {
            cin >> x;
            add(l[1], x);  // 3
        } else if (a == "D") {
            cin >> k;       //!
            remove(k + 1);  // k+1是因为已经用了两个点
        } else if (a == "IL") {
            cin >> k >> x;
            add(l[k + 1], x);//第k个点左侧的位置
        } else {
            cin >> k >> x;
            add(k + 1, x);
        }
    }
    for (int i = r[0]; i != 1; i = r[i]) {//i从r[0]开始,r[0]包括,r[0]是第一个点,0是左端点
        cout << e[i] << ' ';
    }

    return 0;
}

栈和队列

栈

用stk[N]表示栈 ,tt表示栈顶 tt一开始为0
插入stk[++tt] = x
弹出tt –
tt>0时不空,0号点没用

队列

队头队尾,队头可弹出,队尾可插入
q[N]表示队列,hh = 0,tt = -1 tt为队尾(tail)
插入q[++tt] = x;
弹出 hh++
hh<=tt不空,0号点用了

单调栈

一个满足栈内元素单调的栈,可以用来找一个序列中每个数两侧离自己最近的比自己小的或比自己大的数
具体习题:

给定一个长度为 N 的整数数列，输出每个数左边第一个比它小的数，如果不存在则输出-1。 
输入格式 
第一行包含整数 N，表示数列长度。 
第二行包含 N个整数，表示整数数列。 
输出格式 
共一行，包含 N 个整数，其中第 i 个数表示第 i 个数的左边第一个比它小的数，如果不存在则输出 -1。 
数据范围 1≤N≤105 1≤数列中元素≤109
输入样例：
5
3 4 2 7 5
输出样例：
-1 3 -1 2 2

分析:
暴力做法时两重循环,枚举每个数左侧的所有数看哪一个是比自己小的第一个数
对于插入a[k]=i而言,可以发现如果存在一个在k左侧的数大于i则永远不会当答案.而如果序列中k左侧的所有的数都小于i则i左侧第一个元素k-1就是答案,因为它离得最近且比自己小,那么我们可以维护一个单调递增的序列,每次插入值i就把大于i的值清掉,答案就是i左侧的值,清空值是从右向左逐个比较弹出,可以用栈.
那么按照这个思路,第一个数先插入栈,栈顶元素就是第一个数,从第二个数i开始插入时,若栈顶大于自己则弹出,直到弹到小于i为止,输出栈顶就是答案,然后把i插入,以此类推

/*
 * @Author: ACCXavier
 * @Date: 2021-04-11 22:23:02
 * @LastEditTime: 2021-04-14 23:52:40
 * Bilibili hhhps://space.bilibili.com/7469540
 * @keywords: 单调栈

 */
#include <iostream>
using namespace std;
const int N = 1e5+10;
int stk[N],hh;
int main() { 
    int n; 
    scanf("%d",&n);
    int x;
    for(int i = 0; i < n; ++ i){
        scanf("%d",&x);
        //$if(i&&x<stk[hh]) i不行 
        while(hh&&x<=stk[hh]){//!while问题 不存在一个数能够大于右侧的数而在序列内 !!!但是x可以小于左侧的数字,所以用while 这里必须<=是因为序列必须严格单调(左侧小于A的数字 题目要求),所以输入数字A等于栈顶时也要去掉,不去掉就会输出A值
            hh--;//弹出栈顶元素
            //stk[hh] = x;
        }
        if(hh)printf("%d ",stk[hh]);//如果栈顶存在,也就是左侧小于x的值存在,那么输出
        else printf("-1 ");
        stk[++hh] = x;//插入值
        
    }

    
    return 0; 
}

单调队列/滑动窗口

单调队列和单调栈类似,队列内元素单调,一个经典应用就是滑动窗口,从一个例题入手解析.
例题:

给定一个大小为 n≤106 的数组。
有一个大小为 k 的滑动窗口，它从数组的最左边移动到最右边。你只能在窗口中看到 k 个数字。每次滑动窗口向右移动一个位置。
以下是一个例子：
该数组为 [1 3 -1 -3 5 3 6 7]，k 为 3。
窗口位置	最小值	最大值
[1 3 -1] -3 5 3 6 7	-1	3
1 [3 -1 -3] 5 3 6 7	-3	3
1 3 [-1 -3 5] 3 6 7	-3	5
1 3 -1 [-3 5 3] 6 7	-3	5
1 3 -1 -3 [5 3 6] 7	3	6
1 3 -1 -3 5 [3 6 7]	3	7
你的任务是确定滑动窗口位于每个位置时，窗口中的最大值和最小值。
输入格式
输入包含两行。
第一行包含两个整数 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

分析:
暴力做法两重循环,n为数据范围,k为窗口大小,遍历n个元素每次向左看k个元素找最小值
可以发现第一个"被看"的数是最小值,之后看的值只要大于当前窗口中的最小值就不会作为答案,但是不像单调队列,由于窗口在不断向右滑动,当当前的最小值离开窗口后,第二小的值就会作为答案,所以不能仅仅只维护最小值.
但是同样的有对于插入a[k]=i而言,可以发现如果存在一个在k左侧的数的数值j大于i则永远不会当答案.因为i比j小,且i要比j来的晚,之后滑窗向右移动的过程中只要j存在i就存在,j不存在的时候i也会存在,所以j不可能当答案了,那么j就可以删了
按照这个思路我们维护一个单调递增队列,队列存元素下标,队列存元素下标,队列存元素下标
那么队头就是**最小值的下标,**每次向队尾插入元素k的下标i,如果队尾元素值p>i的值 (或>=)则弹出,一直弹到p<=i(或小于)为止,插入k(下标)即可(p=i没关系,最小值可以重复),每次取队头元素对应数据中的值输出,注意看队头元素下标在的位置,超出滑窗则弹出队头
代码:

#include <iostream>
using namespace std;
const int N = 1e6+10;
int a[N],q[N],hh,tt=-1;//队列里面存滑窗内部元素的下标
int main()
{
    int n,k;
    scanf("%d %d",&n,&k);
    for(int i =0; i  < n; ++ i){
        scanf("%d",a+i);
    }
    for(int i = 0 ;i < n ; ++ i){
        if(hh <= tt && i - k + 1 > q[hh])hh++;//i-k+1是滑窗左侧下标,q[hh]是队头元素在数据中的位置
        while(hh <= tt && a[q[tt]] >= a[i])tt --;//队尾元素大于要插入的元素弹出队尾
        //下面两句不能颠倒 因为i有可能是最小值
        q[++tt] = i;//!这个地方是i 存的是下标
        if(i >= k-1) printf("%d ",a[q[hh]]);//我们的队列是一个一个值进去的,比如k=3时,i从0~2经过三次,队列里面才有最小值的下标,所以要i>=k-1时输出
    }
    puts("");
    hh=0,tt=-1;
    //反过来 维护单调递降队列
    for(int i = 0 ;i < n ; ++ i){
        if(hh <= tt && i - k + 1 > q[hh])hh++;//i-k+1是是滑窗左侧下标
        while(hh <= tt && a[q[tt]] <= a[i])tt --;
        //下面两句不能颠倒 因为i有可能是最值
        q[++tt] = i;
        if(i >= k-1) printf("%d ",a[q[hh]]);
    }
    return 0;
}