数据结构1——链表

单链表

这里主要讲用数组模拟链表的数据结构。首先思考一个问题，为什么不用结构体和指针来模拟呢？这样看上去不是结构更清晰吗？

struct Node
{
    int val;
    Node *next;
};

Node1 = new Node();   // 非常慢

主要原因是：如果用结构体的话，每创建一个新节点，都要用new函数，这个操作是非常慢的。在笔试里面，Node的数量都是$10^5$级别的，基本上new完了，就超时了。

用数组模拟单链表需要用到两个数组，两个数组通过相同的下标关联起来

1. e[N]：存放value值
2. ne[N]: 存放下个节点的下标值

显然用数据模拟单链表显得不是很直观，不同的信息存放在不同的数组中，通过共同的下标 i来关联。 而用结构体来做单链表的话，所有信息都在node[i]中，很直观地用node[i].xxx就可以得到想要的信息。但用数组模拟单链表胜在效率高，速度快，时间空间开销都低。

单链表支持的操作

单链表支持的一般操作如下所示，建议对着代码自己画图理解：

#include <iostream>
using namespace std;

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

// 初始化
void init(){
    head = -1;  // 头节点指向空节点 -1
    idx = 0;    // 真正的第一个节点从0开始
}

// 将x插到头节点
// 一般在链表的头部插入，因为末尾在哪不好找
void add_to_head(int x){
    e[idx] = x;
    ne[idx] = head;
    head = idx;
    idx ++;
}

// 将x插到下标是k的点后面
// 链表只能向后看，若想插入到k前面则只能从头遍历链表
void add_to_k(int k, int x){
    e[idx] = x;
    ne[idx] = ne[k];
    ne[k] = idx;
    idx ++;
}

// 将头结点删除，需要保证头结点存在
void remove_head() {
    head = ne[head];
}

// 将下标是k的点后面的点删掉
void remove_after_k(int k){
    ne[k] = ne[ne[k]];
}

int main(){
    return 0;
}

下图中，圆圈表示链表中的一个节点，下方的蓝色数字表示节点的编号，每个节点的编号都是唯一且互不相同的，就如node[i]的i；上方的绿数字是该节点存的值，例如节点1上存的值是5，相当于node[i].value=5。

几点注意的：

• 用数组模拟链表是个静态链表。从删除操作来看，删除掉的节点的数据并没有真正被删掉，空间并没有释放出来。实际工程的时候，需要考虑这个问题，要用动态链表。但做题的时候，快是关键！

• 链表只能往后看，给一个节点，可以在$O(1)$时间内知道下一个节点的位置，因为我们除了value，还存了这个节点的下一个节点的编号是多少，即node[i].next = ne[i]，这里ne[i]的值是某一个节点的编号。但在单链表中无法知道某个节点的上一个节点在哪里。要想查找一个节点，只能从head开始遍历链表，复杂度$O(n)$。

• 从空链表开始（$\varnothing$的下标位置是-1），第1个插入的点的位置是0，第k个插入的点的位置是k-1。当然，你完全可以令第一个插入的点的位置为任意值，只要不和空间点的下标混在一起就行。

双链表

和单链表基本一样。只不过多开辟一个数组来存该节点前面的节点的下标。这样我们就有了左右两个视野。

1. e[N]：存放value值
2. r[N]: 存放右边节点的下标值
3. l[N]: 存放左边节点的下标值

#include <iostream>
using namespace std;

const int N = 100010;

int e[N], l[N], r[N], idx;

// 初始化
void init(){
    // 0表示左端点，1表示右端点
    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;
}

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

int main(){
    return 0;
}

几点注意的：

• 双链表就不定义head和$\varnothing$ 了，直接用下标0表示head，下标1表示tail。第一个插入的点的idx=2.
• 在第k个点的左边插入x就等于add(l[k], x)，因此所有操作只要写右侧的做法就行了。

编程注意事项

（1）用数组模拟单链表双链表时，都用到idx这个变量。idx就是某个节点的编号，多个数组通过同一个idx关联起来。为了保证每个节点的编号是唯一的，我们每插入一个节点就idx ++。就算中间我们执行了一些删除操作，我们也不会idx--。就像前面说的，用数组模拟的是一个静态链表，删除操作不会真的删除这个节点，释放对应空间，而是把这个节点的前后连接方式给改了，使得我们从head开始，无法访问到这个节点，这个节点被绕过去了，就相当于被删除了。

（2） e[N]是啥？我们上面的例子中e[]都只是代表这个节点的某个int类型的属性值。我举个例子，对于结构体：

struct Person{
  double height;
  double weight;
  int age;
  Person *next;
} node[N]

我们将每一个人看为链表中的一个节点，每个人带有身高、体重、年龄三个属性。用数组模拟这个单链表的话：

double height[N], weight[N];
int age[N];
ne[N];
int idx;

我们想看节点i的属性值，我们就去访问height[i], weight[i], age[i].