单链表
这里主要讲用数组模拟链表的数据结构。首先思考一个问题,为什么不用结构体和指针来模拟呢?这样看上去不是结构更清晰吗?
struct Node
{
int val;
Node *next;
};
Node1 = new Node(); // 非常慢
主要原因是:如果用结构体的话,每创建一个新节点,都要用new
函数,这个操作是非常慢的。在笔试里面,Node的数量都是
1
0
5
10^5
105级别的,基本上new
完了,就超时了。
用数组模拟单链表需要用到两个数组,两个数组通过相同的下标关联起来
e[N]
:存放value值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 ) O(1) O(1)时间内知道下一个节点的位置,因为我们除了
value
,还存了这个节点的下一个节点的编号是多少,即node[i].next = ne[i]
,这里ne[i]
的值是某一个节点的编号。但在单链表中无法知道某个节点的上一个节点在哪里。要想查找一个节点,只能从head开始遍历链表,复杂度 O ( n ) O(n) O(n)。 -
从空链表开始( ∅ \varnothing ∅的下标位置是-1),第1个插入的点的位置是0,第k个插入的点的位置是k-1。当然,你完全可以令第一个插入的点的位置为任意值,只要不和空间点的下标混在一起就行。
双链表
和单链表基本一样。只不过多开辟一个数组来存该节点前面的节点的下标。这样我们就有了左右两个视野。
e[N]
:存放value值r[N]
: 存放右边节点的下标值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]
.