第七章：单链表与双链表（数组模拟）_用数组模拟链表是什么结构

数组模拟与结构体模拟的区别

我们在数据结构一章中介绍了用结构体的方式去模拟动态的单双链表，但是在堆区开辟新结点的时候，会浪费很多时间，对于我们当前的算法题中的时间限制是很不利的。因此，我们下面所讲解的单双链表的模拟是利用的静态数组的模式。还有一个特点就是：代码量少！
当然，大家可以先去看一看笔者所写的结构体模拟链表的文章，便于后续的理解：
动态单链表
动态双链表

一、数组模拟单链表：

1、链表的逻辑结构：

2、数组模拟链表的物理结构：

大体的思路就是：
我们开辟一个数组将其作为数据域，再开辟一个数组作为指针域。其中每个节点的指针域和数据域通过下标联系起来。每一个节点的指针域都是记录的下一个节点的下标，所以利用数组模拟的话，我们是利用下标去模拟物理地址的。

我们发现上面还有一个idx变量，这个变量存储的是数组中下一次插入新节点的位置。

但是我们发现两个问题：
第一个问题是第一个节点的下标无人记录，所以我们创建一个整型数据head来存储第一个节点的下标。
第二个问题就是最后一个节点的指针域记录的应该是空指针，因此我们需要用-1来模拟空指针。

有了上述的逻辑后，我们就可以实现下面的增删改查等函数操作：

3、接口函数实现：

（1）实现前的准备：

const int N=1e5+10;
int head,idx,e[N],ne[N];
1
2

head记录第一个节点的位置，idx记录下一次插入新节点的位置，e[N]为数据域数组，ne[N]为指针域数组。

（2）初始化：

void init()
{
	head=-1;//指向空指针
	idx=0;//指向0
}
1
2
3
4
5

（3）头插：

void push_front(int x)
{
	e[idx]=x;
	ne[idx]=head;
	head=idx++;
}
1
2
3
4
5
6

（4）插入：

在位置k的右侧插入。

void insert(int k,int x)
{
	e[idx]=x;
	ne[idx]=ne[k];
	ne[k]=idx++;
}
1
2
3
4
5
6

（5）删除：

void remove(int k)
{
	ne[k]=ne[ne[k]];
}
1
2
3
4

4、例题：

#include<iostream>
using namespace std;
const int N=1e5+10;
int e[N],ne[N],head,idx;

void init()
{
    head=-1,idx=0;
}
void push_front(int x)
{
    e[idx]=x;
    ne[idx]=head;
    head=idx++;
}
void insert(int k,int x)
{
    e[idx]=x;
    ne[idx]=ne[k];
    ne[k]=idx++;
}
void remove(int k)
{
    ne[k]=ne[ne[k]];
}
int main()
{
    init();
    int m,k,x;
    cin>>m;
    while(m--)
    {
        char op;
        cin>>op;
        if(op=='H')
        {
            scanf("%d",&x);
            push_front(x);
        }
        else if(op=='D')
        {
            scanf("%d",&k);
            if(!k)head=ne[head];
            else remove(k-1);
        }
        else 
        {
            scanf("%d%d",&k,&x);
            insert(k-1,x);
        }
    }
    for(int i=head;i!=-1;i=ne[i])printf("%d ",e[i]);
    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

二、数组模拟双链表：

1、双链表的逻辑结构：

2、数组模拟双链表的物理结构：

我们规定两个边界，一个是左边界，一个是右边界，这样的话，我们就能保证两个边界中间的所有节点的左指针域和右指针域都存储着有效数据。同时还容易在遍历链表的时候找到链表的边界。

上述图片为初始化的状态：
左节点的右指针域记录的是右边界的下标：1
右节点的左指针域记录的是左边界的下标：0

我们真正的第一个节点是从下标为2的数组元素开始的。

3、接口函数实现：

（1）前期准备：

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

（2）插入：

void insert(int a,int x)
{
	e[idx]=x;
	l[idx]=a;
	r[idx]=r[a];
	l[r[a]]=idx;
	r[a]=idx++;
}
1
2
3
4
5
6
7
8

（3）删除：

void remove(int a)
{
	l[r[a]]=l[a];
	r[l[a]]=r[a];
}
1
2
3
4
5

4、例题：

#include<iostream>
using namespace std;

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

void insert(int k,int x)
{
    e[idx]=x;
    l[idx]=k;
    r[idx]=r[k];
    l[r[k]]=idx;
    r[k]=idx++;
}

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

int main()
{
    l[1]=0;
    r[0]=1;
    idx=2;
    int m;
    scanf("%d",&m);
    while(m--)
    {
        string op;
        cin>>op;
        if(op=="L")
        {
            int k;
            scanf("%d",&k);
            insert(0,k);
        }
        else if(op=="R")
        {
            int x;
            scanf("%d",&x);
            insert(l[1],x);
        }
        else if(op=="D")
        {
            int k;
            scanf("%d",&k);
            remove(k+1);
        }
        else if(op=="IL")
        {
            int k,x;
            scanf("%d %d",&k,&x);
            insert(l[k+1],x);                                                                                
        }
        else
        {
            int k,x;
            scanf("%d %d",&k,&x);
            insert(k+1,x);
        }
    }
    for(int i=r[0];i!=1;i=r[i])printf("%d ",e[i]);
    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