单链表

带注释版：

#include <iostream>
using namespace std;
const int N = 100010;
class List{
    int head,e[N],ne[N],idx;
    void init(){ // 初始化，在使用前一定要调用
        head = -1,idx = 0;
    }
    void add_to_head(int x){ // 往链表头插入一个数x
        e[idx] = x,ne[idx] = head,head = idx ++;
    }
    void add(int k,int x){ // 在第k个插入的数后插入一个数
        e[idx] = x,ne[idx] = ne[k],ne[k] = idx ++;
    }
    void remove(int k){ // 删除第k个插入的数后面的数
        ne[k] = ne[ne[k]];
    }
    int find(int x){ // 查找值为x的节点，返回编号，如果没找到返回-1
        for(int i = head;i != -1;i = ne[i]){
            if(e[i] == x) return i;
        }
        return -1;
    }
};

无注释版：

#include <iostream>
using namespace std;
const int N = 100010;
class List{
    int head,e[N],ne[N],idx;
    void init(){
        head = -1,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 find(int x){
        for(int i = head;i != -1;i = ne[i]){
            if(e[i] == x) return k;
        }
        return -1;
    }
};

双链表

带注释版：

class List{
    int e[N],l[N],r[N],idx;
    void init(){ // 初始化
        r[0] = 1,l[1] = 0;
        idx = 2;
    }
    void add(int k,int x){ // 往k插入一个数x
        e[idx] = x;
        r[idx] = r[k];
        l[idx] = k;
        l[r[k]] = idx;
        r[k] = idx ++;
    }
    void remove(int k){ // 删除第k个插入的数
        l[r[k]] = l[k];
        r[l[k]] = r[k];
    }
};

补充：

双链表常用操作：

1. 在最左侧插入一个数

   写法：
   add(0,x);

2. 在最右侧插入一个数

   写法：
   add(l[1],x);

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

   写法：
   remove(k + 1);

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

   写法：
   add(l[k + 1],x);

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

   写法：
   add(k + 1,x);

无注释版本：

class List{
    int e[N],l[N],r[N],idx;
    void init(){
        r[0] = 1,l[1] = 0;
        idx = 2;
    }
    void add(int k,int x){
        e[idx] = x;
        r[idx] = r[k];
        l[idx] = k;
        l[r[k]] = idx;
        r[k] = idx ++;
    }
    void remove(int k){
        l[r[k]] = l[k];
        r[l[k]] = r[k];
    }
};