一. 模板

// head 存储链表头，e[] 存储节点的值，ne[] 存储节点的next指针，idx 表示当前用到了哪个节点
int head, e[N], ne[N], idx;

// 初始化
void init()
{
    head = -1;  // -1 标记空节点
    idx = 0; // 新添加值的数组下标
}

// 在链表头插入一个数a
void insert(int a)
{
    e[idx] = a, ne[idx] = head, head = idx ++ ;
}

// 将头结点删除，需要保证头结点存在
void remove()
{
    head = ne[head];
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

二. 总结

• 为什么要用数组模拟单链表？-> 数组是静态空间，用指针的话每次都要 new，会很慢.
• 解析图：
  

三. 例题

• 826. 单链表
       

AC代码:

#include 

using namespace std;

const int N = 1e6 + 10;

int head, e[N], ne[N], idx;

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

// 将 x 插入到头节点上
void add_to_head(int x)
{
    e[idx] = x;  // 开辟空间放入值
    ne[idx] = head;  // 指向 head 指向的结点
    head = idx;  // 让表头指向插入的新结点
    ++idx;  // 下一个新结点需要开辟的数组的指针往后挪
}

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

// 将 x 插入到下标为 k 的点的后面
void add(int k, int x)
{
    e[idx] = x;  // 开辟空间放入值
    ne[idx] = ne[k];  // 指向 k 指向的结点
    ne[k] = idx;  // 让 k 指向插入的新结点
    ++idx;  // 下一个新结点需要开辟的数组的指针往后挪
}

int main()
{
    int m;
    cin >> m;
    
    init ();
    
    while (m--) {
        int k, x;
        char ch;
        cin >> ch;
        
        if (ch == 'H') {
            cin >> x;
            add_to_head(x);  
            
        }
        else if (ch == 'D') {
            cin >> k;
            if (k == 0) head = ne[head];  // 删除头结点
            else remove(k - 1);  // k 代表第几个，传入的参数为对应的下标
        }
        else if (ch == 'I') {
            cin >> k >> x;
            add(k - 1, x);
        }
        
    }
    
    for (int i = head; i != -1; i = ne[i]) {  // 遍历链表
        cout << e[i] << ' ';
    }
    cout << endl;
    
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75