第二章 数据结构

链表与邻接表

​ 用数组模拟，不使用结构体的形式。

struct Node{
  int val;
    Node *next;
};

​ 这种操作在面试的时候常用，但在笔试题中用的不多，因为这种方式在创建新的链表的时候都会调用new函数，new Node();这种操作耗费的时间多，在十万或更多的级别会超时。

数组模拟单链表（邻接表）

解析

​ 多个单链表可以组合成邻接表——常用于用于存储图和树，head->空，head->⚪->⚪->⚪->空。链表不同于顺序表，逻辑上相邻的结点在物理上不一定相邻，只用靠指针链接就可以。

e[N];//表示某个点的值是多少。
ne[N];//表示某个点的next指针是多少。
//e[N]和ne[N]是用下标关联的。

头结点		结点0		结点1		结点2		空
head	→	⚪	→	⚪	→	⚪	→	⚪
		e[0]=3		e[1]=5		e[2]=7
		ne[0]=1		ne[1]=2		ne[2]=-1

模板

/*数据解析
* head  表示头结点的下标
* e[i]  表示节点i的值
* ne[i] 表示节点i的next指针是多少
* idx   存储当前已经用到了几个点，初始化为0
*/
int head,e[N],ne[N],idx;
// 初始化
void init(){
    head=-1;
    idx=0;
}
/*操作一、将x插到头结点
* 将新的结点赋值x。
* 将新结点的指针指向head指向的结点。
* 将head指向新结点。
* idx已经使用移动到下一个。
*/
void add_to_head(int x){e[idx]=x,ne[idx]=head,head=idx++;}

/*操作二、将x插到下标是k的点后面
* 加入一个结点值。
* 将这个结点的指针指向k指向的结点。
* 将k结点的指针指向加入的结点。
* idx已经使用移动到下一个。
*/
void add(int k,int x){e[idx]=x,ne[idx]=ne[k],ne[k]=idx++;}

/*操作三、将下标是k的点后面的点删掉
* 删除只需要将k结点的指针链接到要删除结点的下一个结点，将要删除的结点忽略就可以了。
* 这样就永远也不能按照指针逻辑找到已经删除了的结点了，哪怕它实际还存在内存中。
*/
void remove(int k){ne[k]=ne[ne[k]];}

例题

826. 单链表 - AcWing题库

#include <iostream>
using namespace std;
const int N = 1e5+10;
int head=-1,e[N],ne[N],idx=0;
void add_to_head(int x){e[idx]=x,ne[idx]=head,head=idx++;}
void add(int k,int x){e[idx]=x,ne[idx]=ne[k],ne[k]=idx++;}
void remove(int k){ne[k]=ne[ne[k]];}

int main(){
    int m;
    cin>>m;
    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;i=ne[i])cout<<e[i]<<' ';
    cout<<endl;
    return 0;
}

数组模拟双链表

​ 常用于优化问题

e[N];//表示某个点的值是多少。
ne[N];//表示某个点的next指针是多少。
//e[N]和ne[N]是用下标关联的。

结点0		结点2		结点3		结点1
⚪	→ ←	⚪	→ ←	⚪	→ ←	⚪
e[0]无意义		e[2]=5		e[3]=7		e[1]无意义
l[0]无意义		l[2]=0		l[3]=2		l[1]=3
r[0]=2		r[2]=3		r[3]=1		r[1]无意义

模板

/*数据解释（使用0结点作为头结点）
* 结点形成两条方向不同的带子，以0表示左端点1表示右端点，
* 0号结点的右边是1号结点，1号结点的左边也是0号结点。两个端点只作为边界无实际意义。
* e[N] 结点的值
* l[N] 指向左边结点
* r[N] 指向右边结点
* idx
*/
int e[N],l[N],r[N],idx;

/*在节点a的右边插入一个数x
* 将新的结点赋值x。
* 将左指针指向a,将右指针指向a的右指针指向的结点。
* 将a的右指针指向结点的左指针指向新结点。
*/
void insert(int a,int x){
    e[idx]=x;
    l[idx]=a,r[idx]=r[a];
    l[r[a]]=idx,r[a]=idx++;
}

/*删除节点a
* 将a的右指针指向结点的左指针指向a的左指针指向的结点。
* 将a的左指针指向结点的右指针指向a的右指针指向的结点。
*/
void remove(int a){
    l[r[a]]=l[a];
    r[l[a]]=r[a];
}
r[0]=1,l[1]=0,idx=2;

例题

827. 双链表 - AcWing题库

#include <iostream>
using namespace std;
const int N=1e5+10;
int e[N],l[N],r[N],idx;

void insert(int a,int x){
    e[idx]=x;
    l[idx]=a,r[idx]=r[a];
    l[r[a]]=idx,r[a]=idx++;
}
void remove(int a){
    l[r[a]]=l[a];
    r[l[a]]=r[a];
}

int main(){
    r[0]=1,l[1]=0,idx=2;
    int n;
    cin>>n;
    while(n--){
        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;
}

栈与队列

栈（先进后出）

​ 栈的一个重要特性就是先进后出，

• 数组模拟栈

模板

// tt表示栈顶
int stk[N], tt = 0;
// 向栈顶插入一个数
stk[ ++ tt] = x;
// 从栈顶弹出一个数
tt -- ;
// 栈顶的值
stk[tt];
// 判断栈是否为空
if (tt > 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)
{

}

单调栈和单调队列

单调栈

​ 单调栈对应题型——给定一个序列，求序列中每一个数左（右）边，离它最近的且比它大（小）的数。

模板&例题

830. 单调栈 - AcWing题库

​ 很容易能想到的暴力做法，使用两重循环，对每一个数向左进行查找，找到的第一个比当前数小的就输出找不到就“-1”然后进行下一个循环。当然这样就很容易超时。

​ 可以使用一个栈来保存经过的数字，每次查找的时候就向前出栈找，这样可以发现一个性质，要是存在一个数据段$a_1,a_2,a_3$，其中$a_1$大于$a_2$，那么$a_2$是不需要$a_1$作为答案的而且$a_3$或之后的数也不需要$a_1$作为答案，因为要找也找比$a_1$小的$a_2$。这时候我们就可以确定$a_1$是不会作为答案出现的，所以直接出栈就好。

​ 这个的时间复杂度看似有两重循环，但是一重循环内的入栈出栈操作每个数只会出现一次，所以实际时间复杂度是$O(n)$级别的。

#include <iostream>
using namespace std;
const int N=100010;
int stk[N],tt;
int main(){
    int n;
    scanf("%d",&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;
}

单调队列

解析

模板&例题

154. 滑动窗口 - AcWing题库

​ 可以使用一个队列来维护，每次一个数入队，要是当前队列长度超过窗口，就将队首元素弹出，以此保证窗口的稳定。

​ 从数据上来看，要是直接暴力跑时间复杂度将会是$O(10^6\ast 10^6)$绝对超时，所以还要想办法优化。和单调栈一样找一个数据段$a_1,a_2,a_3$，其中$a_1<a_2<a_3$，只要队列中存在这样的情况，只要后一个数据比前一个小

#include <iostream>
using namespace std;
const int N=1e6+10;
int a[N],q[N];
int main(){
    int n,k;
    scanf("%d%d",&n,&k);
    for(int i=0;i<n;i++)scanf("%d",&a[i]);

    int hh=0,tt=-1;
    for(int i=0;i<n;i++){
        //队列是否为空、队头是否已经划出窗口（队列中存的是下标）
        if(hh<=tt&&i-k+1>q[hh])hh++;

        while(hh<=tt&&a[q[tt]]>=a[i])tt--;
        q[++tt]=i;

        if(i>=k-1)printf("%d ",a[q[hh]]);
    }

    puts("");

    hh=0,tt=-1;
    for(int i=0;i<n;i++){
        if(hh<=tt&&i-k+1>q[hh])hh++;

        while(hh<=tt&&a[q[tt]]<=a[i])tt--;
        q[++tt]=i;

        if(i>=k-1)printf("%d ",a[q[hh]]);
    }
    puts("");
    return 0;
}

kmp

鸣谢

文中出现的题目来自，主要思路和代码模板来自Acwing闫学灿大佬。
题库 - AcWing