双链表（采用数组模拟实现）

题目如下：

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

1. 在最左侧插入一个数；
2. 在最右侧插入一个数；
3. 将第 𝑘 个插入的数删除；
4. 在第 𝑘 个插入的数左侧插入一个数；
5. 在第 𝑘 个插入的数右侧插入一个数

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

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

输入格式

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

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

1. L x，表示在链表的最左端插入数 𝑥。
2. R x，表示在链表的最右端插入数 𝑥。
3. D k，表示将第 𝑘 个插入的数删除。
4. IL k x，表示在第 𝑘 个插入的数左侧插入一个数。
5. IR k x，表示在第 𝑘 个插入的数右侧插入一个数。

输出格式

共一行，将整个链表从左到右输出。

配合代码说

1.定义部分

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

和单链表一样，还是先定义e[i]，用来存储下标为 i 的结点的值。

定义 l[i] ，可以理解为一个函数，返回下标为 i 的结点的左边的结点的下标。

定义 r[i] ，理解为一个函数，返回下标为 i 的结点的右边结点的下标。

定义 idx ，代表当前操作的结点的下标，如现在想要插入一个结点， idx 就代表这个结点的下标（也可以理解为结点本身）

2.初始化

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

画图：

3.在下标为k的结点的后面加一个值为x的结点

void add(int k,int x){
    e[idx] =x;
    l[idx] = k;//记忆的小窍门：在单链表和双链表中，如果想要下标为k的结点的前一个结点（左边结点的下标）的下标，那么就用l[k]来表示下标k结点的前一个结点（左边结点）的下标，而不是用k-1
               //同样的，如果想要下标为k结点的后一个结点（右边结点）的下标
               //用r[k]来表示，而不是k+1
    r[idx] = r[k];//插入结点时，优先建立要插入的结点的l[idx]和r[idx]
                  //不然可能会导致r[k]发生改变，往后运用r[k]时，使用的就不是正确的数值 
    l[r[k]] =idx;
    r[k] = idx;
    idx++;
}

上图

4.移除下标为k的结点 

void Remove(int k){
    r[l[k]] = r[k];
    l[r[k]] = l[k];
}

 上图

5.main函数部分

int main()
{
    cin.tie(0);
    ios::sync_with_stdio(false);//头两行代码可以让你的cin和scanf一样快，居家旅行必备
    init();
    
    int m;
    cin >> m;
    
    while(m--){
        string a;
        cin >> a;
        
        if (a == "L"){
            int x;
            cin >> x;
            add(0,x);//在最左端插入一个结点，就是在下标为0结点的后面插入一个结点
        }
        
        if (a == "R"){
            int x;
            cin >> x;
            add(l[1],x);//在最右端插入一个结点，就是在下标为1结点的前一个结点的后面插入一个节点
        }
        
        if (a == "D"){
            int k;
            cin >> k;
            Remove(k+1);//这里要k+1，是因为题目中说的第k个元素，对应在链表中，其下标就是k+1
                        //因为下标0和1分别用来存储形式上的头和尾，idx只能从2开始算，因此是k+1
        }
        
        if (a == "IL"){
            int k,x;
            cin >> k >> x;
            add(l[k+1],x);
        }
        
        if (a == "IR"){
            int k,x;
            cin >> k >> x;
            add(k+1,x);
        }
    }
    for (int i = r[0];i != 1;i =r[i])
    cout << e[i] << " ";
    
    return 0;
}

1.定义的函数add(int k ,int x)

这个函数的含义是在下标为 k 的结点后（右边）插入一个数 x

如果要求在下标为 k 的结点的左边插入一个数，那么就可以用 add(l[k],x)

（就是在下标 k 结点的左边结点的右边插入一个数 x ）

2.在最左侧插入一个数和在最右侧插入一个数

if (a == "L"){
            int x;
            cin >> x;
            add(0,x);//在最左端插入一个结点，就是在下标为0结点的后面插入一个结点
        }

 在最左端插入一个结点，就是在下标为0结点的后面插入一个结点。

双向链表中，下标为0和1是形式上的头和尾，不是任何结点，在链表为空时，这两就已经存在了。

3.第 k 个插入的数在链表中对应的下标是 k+1

 if (a == "D"){
            int k;
            cin >> k;
            Remove(k+1);//这里要k+1，是因为题目中说的第k个元素，对应在链表中，其下标就是k+1
                        //因为下标0和1分别用来存储形式上的头和尾，idx只能从2开始算，因此是k+1
        }

 这里要k+1，是因为题目中说的第k个元素，对应在链表中，其下标就是k+1。

因为在双链表中下标0和1分别用来存储形式上的头和尾，后续插入的结点的下标只能从2开始算，如第一个插入的结点，它的下标就是2。

4.初始时 idx = 2

因为在双链表中，下标为 0 和下标为 1 的结点分别代表双链表形式上的头结点和尾结点其中不包含任何信息，就和单链表形式上的尾结点的下标是 -1 是一样的道理。

因为 idx 是要即将进行操作的结点的下标，而下标 0 和 1 都已经在链表中存在了，所以 idx 的初始值要从 2 开始。

5.在最右端插入一个数 add(l[1],x)

 

 6.双链表的遍历for (int i = l[0];i != 1;i = r[i])