7天带你学会数据结构---第1天(链表)

1.单链表

什么是单链表：
单链表是由各个内存结构通过一个next指针链接在一起组成，每一个内存结构都存在后继内存结构之中，链表的每个节点由数据域和指针域两部分组成。
如果想要详细了解可以看我的这篇文章：单链表及其基本操作

为什么我们要用数组模拟链表：
因为用结构体的方式去实现链表会导致速度比较慢，容易超时，而用数组模拟链表可以有效提高速度

下面我们通过一个例题去学习单链表：

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

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

#include <iostream>
#include <cstdio>
#include <algorithm>

using namespace std;

// head 表示头结点的下标
// e[i] 表示节点i的值
// ne[i] 表示节点i的next指针是多少
// idx 存储当前已经用到了哪个点
int head,idx;
int e[100010],ne[100010];

// 初始化
void init()
{
    head=-1;
    idx=0;
}

// 将x插到头结点
void add_to_head(int x)
{
    e[idx]=x;
    ne[idx]=head;
    head=idx;
    idx++;
}

// 将x插到下标是k的点后面
void add(int k,int x)
{
    e[idx]=x;
    ne[idx]=ne[k];
    ne[k]=idx;
    idx++;
}

// 将下标是k的点后面的点删掉
void remove(int k)
{
    ne[k]=ne[ne[k]];
}

int main()
{
    int n;
    cin>>n;

    init();

    while(n--)
    {
        int k,x;
        char op;
        cin>>op;
        if(op=='H')
        {
            scanf("%d",&x);
            add_to_head(x);
        }
        else if(op=='D')
        {
            scanf("%d",&k);
            if(!k) head=ne[head];
            else remove(k-1);
        }
        else
        {
            scanf("%d%d",&k,&x);
            add(k-1,x);
        }
    }
    for(int i=head;i!=-1;i=ne[i]) cout<<e[i]<<" ";
    cout<<endl;

    return 0;
}

2.双链表

什么是双链表：
使用双链表，我们可以不再拘束于单链表的单向创建、遍历等操作，在很大程度上减少了在使用中存在的问题。在双链表中，我们需要有两个指针域，一个负责存储后一个节点的地址，另一个负责存储前一个节点的地址。

下面我们通过一个例题去学习单链表：

实现一个双链表，双链表初始为空，支持 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

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <string>

using namespace std;

int m;
int e[100010],l[100010],r[100010],idx;

// 初始化，0是左端点，1是右端点
void init()
{
    r[0]=1,l[1]=0;
    idx=2;
}

// 在节点a的右边插入一个数x
void insert(int a,int x)
{
    e[idx]=x;
    r[idx]=r[a];
    l[idx]=a;
    l[r[a]]=idx;
    r[a]=idx;
    idx++;
}

// 删除节点a
void remove(int a)
{
    r[l[a]]=r[a];
    l[r[a]]=l[a];
}

int main()
{
    cin>>m;
    init();
    while(m--)
    {
        string op;
        int k,x;
        cin>>op;
        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;
}