数组模拟链表

一、数组模拟单链表

也称静态链表（邻接表：n个链表，主要应用：存储图和树）单链表只能存储当前节点的值和指向下一节点的指针，无法存储上一节点

1、初始化

void init(){
    head = -1;//head表示头节点的下标，-1表示不存在，当前链表为空
    index = 0;//第一个节点从0开始
}
1
2
3
4

2、将一个新的节点x插入到头节点

void add_to_head(int x){
    value[index] = x;//1.把新节点的值存下来
    next[index] = head;//2.新节点的下一节点指向head指向的下一节点
    head = index;//3.将head指向index
    index++;//4.index指向下一个指针
}
1
2
3
4
5
6

3、将一个新的节点x插入下标是k的点后面

void add(int k, int x){
    value[index] = x;//1.先存值
    next[index] = next[k];//2.新节点的下一节点指向 k 指向的下一节点
    next[k] = index;//3.k指向的下一节点指向新节点
    index++;//4.index指向下一个指针
}
1
2
3
4
5
6

4、将下标是k的点后面的点删掉

void remove(int x){
    next[k] = next[next[k]];//直接将其指向下下个节点，在算法竞赛中一般需要考虑删除的那个节点该如何处理
}
1
2
3

5、例题
原题链接

【代码】

#include <iostream>
using namespace std;
const int N = 100010;

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

//初始化
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 m;
    cin >> m;
    
    init();
    
    while (m--){
        int k, x;
        char op;
        
        cin >> op;
        //插到头节点
        if (op == 'H'){
            cin >> x;
            add_to_head(x);
        }
        //删除第k-1个点，下标是k
        else if (op == 'D'){
            cin >> k;
            //如果下标是0，那么头节点要指向后一个节点，就是原节点指向的下一节点
            if (!k) 
                head = ne[head];
            remove(k - 1);
        }
        //插到第k - 1个点的后面，下标是k
        else {
            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

---

二、数组模拟双链表

（主要用来优化某些问题）有两个指针，一个指向前，一个指向后。

1、初始化

void init(){
    //0表示head左端点，1表示tail右端点
    r[0] = 1;//r表示下一节点
    l[1] = 0;//l表示上一节点
    index = 2;//0和1已经被占用过了，所以idx从2开始
}
1
2
3
4
5
6

2、将一个新的节点 x 插入下标是 k 的点的右边

​ 如果要插在 k 的左边，就把 k 改为 l[k]

void add(int k, int x){
    value[index] = x;//先赋值
    r[index] = r[k];//x指向的右节点为k的右节点
    l[index] = k;//x指向的左节点为k
    l[r[k]] = index;//k的右节点向左指向x
    r[k] = index;//k向右指向x
}
1
2
3
4
5
6
7

3、删除第 k 个点

void remove(int k){
    r[l[k]] = r[k];//它的左节点所指向的右节点，越过它，指向它的右节点
    l[r[k]] = l[k];//它的右节点所指向的左节点，越过它，指向它的左节点
}
1
2
3
4

4、例题
原题链接

【代码】

#include <iostream>
#include <cstring>
using namespace std;
const int N = 100010;

int m;
int e[N];//存储每个节点的值
int l[N];//存储该节点指向的左节点
int r[N];//存储该节点指向的右节点
int idx;//存储当前用到了哪个点

//初始化
void init(){
    r[0] = 1, l[1] = 0;
    idx = 2;
}

//在下标是 k 的点的右边，插入 x
void add(int k, int x){
    e[idx] = x;
    r[idx] = r[k];
    l[idx] = k;
    l[r[k]] = idx;
    r[k] = idx;
    idx++;
}

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

int main(){
    cin >> m;
    
    init();
    
    while(m--){
        string op;
        cin >> op;
        
        int k, x;
        //在链表的最左端插入x
        if (op == "L"){
            cin >> x;
            add(0, x);
        }
        //在链表的最右端插入x
        else if (op == "R"){
            cin >> x;
            add(l[1], x);
        }
        //将第k个插入的数删除
        else if (op == "D"){
            cin >> k;
            remove(k + 1);
        }
        //在第k个插入的数的左侧插入一个数
        else if (op == "IL"){
            cin >> k >> x;
            add(l[k + 1], x);
        }
        //在第k个插入的数的右侧插入一个数
        else if (op == "IR"){
            cin >> k >> x;
            add(k + 1, x);
        }
    }
    
    for (int i = r[0]; i != 1; i = r[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
76

---