数据结构-单链表和双链表（数组

为什么要学习链表

数组是一种支持随机访问，但不支持在任意位置插入或者删除元素的数据结构，与之相对应，链表支持子在任意位置插入或者删除，但只能按顺序依次访问其中的元素

用什么方式建立链表

现有两种方式建立链表-结构体和数组模拟，本次只用数组模拟（数组其实更快）

单链表（画个图来理解）

数组模拟：e[n]表示节点i的值，ne[n]表示节点i的下一个点下标，head=-1表示头节点的下标，引入idx=0表示存储现在当前已经用到了哪个点

https://www.acwing.com/problem/content/828/

例题：模板单链表

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

1. 向链表头插入一个数；

2. 删除第 k 个插入的数后面的数；

3. 在第 k个插入的数后插入一个数。

现在要对该链表进行 M 次操作，进行完所有操作后，从头到尾输出整个链表。

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

输入格式

第一行包含整数 M，表示操作次数。

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

1. H x，表示向链表头插入一个数 x。

2. D k，表示删除第 k 个插入的数后面的数（当 k 为 0 时，表示删除头结点）。

3. 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

分析：题中一共有三个操作

1. 向链表头插入x

2. 删除第k个数后面的数

3. 在第k个数后面插入x

一步步试试

1. • 向链表头插入x

void add_to_head(int x){
    e[idx]=x;//存下当前的值
    ne[idx]=head;//将元素x指针指向head原本指向的
    head=idx;//head现在表示指向第一个元素
    idx++;
}

2. • 删除第k个数后面的数

void remove(int k){
    ne[k]=ne[ne[k]];//让k的指针指向k的一下个的下一个，则中间的的被挤掉
}

3.在第k个数后面插入x

//将x插入下标k的节点之后
void add(int k,int x){
    e[idx]=x;// 存下当前值
    ne[idx]=ne[k];//让元素x配套的指针，指向它要占位的元素的下一个位置
    me[idx]=idx;//让原来元素的指针指向自己
    idx++;//往后挪一位
}

AC代码

#include<iostream>
using namespace std;
const int N=1000000;
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;//将元素x的指针指向了head原本指向的
    head=idx;//head现在表示指向第一个元素了
    idx++;//下一节点 
}
void add_to(int k,int x)
{
    e[idx]=x;//存入值； 
    ne[idx]=ne[k];//让元素x配套的指针，指向它要占位的元素的下一个位置
    ne[k]=idx;//让原来元素的指针指向自己
    idx++;//下一节点 
} 
void remove(int k)
{
    ne[k]=ne[ne[k]];//让k的指针指向，k下一个人的下一个人，那中间的那位就被挤掉了
}
int main()
{
    int m;
    cin>>m;
    init();
    while(m--){
        char op;
        int x,k;
        cin>>op;
        if(op=='H'){
            cin>>x;
            add_to_head(x);
        }
        else if(op=='D'){
            cin>>k;
            if(!k){
                head=ne[head];
            }
            remove(k-1);//下标是从0开始，因此0是第一个插入的点
            //因此第k个插入的点下标是k-1 
        }
        else{
            cin>>k>>x;
            add_to(k-1,x);
        }
        
    }
    for(int i =head;i!=-1;i=ne[i])
    {
        cout<<e[i]<<" ";
    }
    cout<<endl; 
}

双链表（画个图吧）

数组模拟：l[N]:i左边的数值，r[N]:i右边的数值，e[N]:节点i当前值，idx：存储当前已经用到了哪个点

例题：模板双链表

https://www.acwing.com/problem/content/829/

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

1. 在最左侧插入一个数；

2. 在最右侧插入一个数；

3. 将第 k 个插入的数删除；

4. 在第 k个插入的数左侧插入一个数；

5. 在第 k个插入的数右侧插入一个数

现在要对该链表进行 M 次操作，进行完所有操作后，从左到右输出整个链表。

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

输入格式

第一行包含整数 M，表示操作次数。

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

1. L x，表示在链表的最左端插入数 x。

2. R x，表示在链表的最右端插入数 x。

3. D k，表示将第 k 个插入的数删除。

4. IL k x，表示在第 k 个插入的数左侧插入一个数。

5. 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

分析：题目中虽然看着有5个步骤，但是本质上来说只有2个步骤，即：增加和删除

双链表增加

//在第k个元素右边插入x
void add_to_right(int k,int x){
    e[idx]=x;//存值
    r[idx]=r[k];//现在的左边指针的值就是k
    l[idx]=k;//现在的右边指针指向原来k所指向的 
    l[r[k]]=idx;//插入新的双向(左右)指针！！注意顺序不能写错，右边节点指向新的节点
    r[k]=idx;
    idx++;
}

左边插入

将k换成l[k]

解释：

l[k]表示k的左边，在l[k]的右边插入x即为在k的左边插入

端点的情况属于特殊情况

1. 在右端点插入

0和1代表头和尾所以最右边插入只要在指向1的那个点的右边插入就可以了

2. 在左端点插入

同理最左边插入就是在指向0的数的左边插入就可以了也就是可以直接在0的有右边插入

双链表删除

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

AC代码

#include<iostream>
using namespace std;
const int N=100010;
int r[N],l[N],e[N],idx;
bool cmp(int x,int y)
{
    return x>y;
}
//初始化，我们定义0为左端点，1为右端点，此时已经占了两个位置了，所以idx从2开始
void init(){
    r[0]=1;
    l[1]=0;
    idx=2;
}
//删除第k个点 
void remove(int k){
    r[l[k]]=r[k];
    l[r[k]]=l[k];
}
//在第 K 个点右边插入一个 X 
void add_to_right(int k,int x){
    e[idx]=x;
    l[idx]=k;//现在的左边指针的值就是k
    r[idx]=r[k];//现在的右边指针指向原来k所指向的 
    l[r[k]]=idx;//插入新的双向指针！！注意顺序不能写错，右边节点指向新的节点
    r[k]=idx;
    idx++ ;
}
signed main()
{
    int m;
    cin>>m;
    init();
    while(m--){
        int k,x;
        string op;//第一个问题，op应该是字符串
        cin>>op;
        if(op=="L"){
            cin>>x;
            add_to_right(0,x);//同理最左边插入就是在指向0的数的左边插入就可以了也就是可以直接在0的有右边插入
        }
        else if(op=="R"){
            cin>>x;
            add_to_right(l[1],x);//0和1代表头和尾所以最右边插入只要在指向1的那个点的右边插入就可以了
        }
        else if(op=="D"){
            cin>>k;
            remove(k+1);//一开始就有0和1下标被占了，本来第k个，下标就是k - 1，现在就是k + 1
        }
        else if(op=="IL"){
            cin>>k>>x;
            add_to_right(l[k+1],x);//当然在 K 的左边插入一个数可以再写一个
            //也可以直接调用我们这个函数，在 k 的左边插入一个数等价于在l[k]的右边插入一个数add(l[k],x)
        }
        else if(op=="IR"){
            cin>>k>>x;
            add_to_right(k+1,x);
        }
    } 
    for(int i=r[0];i!=1;i=r[i]){
        cout<<e[i]<<" ";
    }
    cout<<endl;
}

总结：

可能刚开始觉得数组的形式很复杂，多练习就能很熟悉的应用了