链表与邻链表
0.传统的链表创建方式在运算速度上非常慢
struct ListNode{
int val;
struct ListNode* next;
};
new struct ListNode();//new一次很慢,因为new是动态分配
1.数组模拟单链表
数组模拟链表,也成为静态链表
链表的实现方式:
一开始用head指针存储链表头节点,head之后就是空指针
之后让head之后的指针指向新节点,以此类推,直到最后一个节点,再让下一个节点指向空指针
定义e[n]为该节点的值,ne[n]为该节点的next指针
e[0] = 3,ne[0] = 1(指节点1)
e[1] = 5,ne[1] = 2(指节点2)
…
e[3] = 9,ne[3] = -1(空节点)
如何在头节点插入一个节点(算法题常用)
链表需要数形结合
1.将所想要插入的值的next指针指向0节点
2.将head的next指针指向该值
3.存储该值
代码实现
void add_to_head(int &x)//把一个值插入到头节点
{
ne[idx] = head;//将该值的指针指向head所指的next节点
head = idx;//将head指向next节点的指针删掉,改成指向该值的指针
e[idx] = x;//存储该值
idx++;//该点已使用过,所以将idx改为下一节点下标
}
如何在任意位置插入一个值
1.首先需要直到该位置的上一节点k
2.与头节点插入类似,先让该值的next变为k的next指针
3.让k的next指针指向该节点
4.存储该值
实现代码
void add(int& k, int& x)//一般插入节点,将x插入到k节点之后
{
ne[idx] = ne[k];//将该值的next改为k的next
ne[k] = idx;//k的next指向该值
e[idx] = x;//存储x
idx++;
}
如何删除一个节点
链表节点的删除本质上是跳过该节点
实现代码
void remove(int& k)//删除某节点后面的点
{
ne[k] = ne[ne[k]];//ne[ne[k]]的意思就是该节点的next的next
}
总实现代码
#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
using namespace std;
const int N = 100010;
int head, e[N], ne[N];//head头节点,e节点值,ne指next指针
int idx;//存储当前用到哪个节点,下标
void Init()//初始化链表
{
head = -1;
idx = 0;
}
void add_to_head(int &x)//把一个值插入到头节点
{
ne[idx] = head;//将该值的指针指向head所指的next节点
head = idx;//将head指向next节点的指针删掉,改成指向该值的指针
e[idx] = x;//存储改值
idx++;//该点已使用过,所以将idx改为下一节点下标
}
void add(int& k, int& x)//一般插入节点,将x插入到k节点之后
{
ne[idx] = ne[k];//将该值的next改为k的next
ne[k] = idx;//k的next指向该值
e[idx] = x;//存储x
idx++;
}
void remove(int& k)//删除某节点后面的点
{
ne[k] = ne[ne[k]];//ne[ne[k]]的意思就是该节点的next的next
}
int main()
{
Init();
}
例题
题目描述
实现一个单链表,链表初始为空,支持三种操作:
向链表头插入一个数;
删除第 k个插入的数后面的数;
在第 k个插入的数后插入一个数。
现在要对该链表进行 M次操作,进行完所有操作后,从头到尾输出整个链表。
注意:题目中第 k个插入的数并不是指当前链表的第 k 个数。例如操作过程中一共插入了 n 个数,则按照插入的时间顺序,这 n 个数依次为:第 1 个插入的数,第 2 个插入的数,…第 n 个插入的数。
输入格式
第一行包含整数 M,表示操作次数。
接下来 M行,每行包含一个操作命令,操作命令可能为以下几种:
H x,表示向链表头插入一个数 x。
D k,表示删除第 k个插入的数后面的数(当 k 为 0时,表示删除头结点)。
I k x,表示在第 k个插入的数后面插入一个数 x(此操作中 k 均大于 0)。
输出格式
共一行,将整个链表从头到尾输出。
数据范围
1≤M≤10000
题解
#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
using namespace std;
const int N = 10010;
int idx, e[N], ne[N];
int head;
void Init()
{
head = -1;
idx = 0;
}
void add_to_head(int x)
{
e[idx] = x;
ne[idx] = head;
head = idx;
idx++;
}
void add(int k, int x)
{
e[idx] = x;
ne[idx] = ne[k];
ne[k] = idx;
idx++;
}
void remove(int k)
{
ne[k] = ne[ne[k]];
}
int main()
{
int m;
cin >> m;
Init();
while (m--)
{
char ch;
int k, x;
cin >> ch;
if (ch == 'H')
{
cin >> x;
add_to_head(x);
}
else if (ch == 'D')
{
cin >> k;
if (!k) head = ne[head];
else remove(k-1);
}
else
{
cin >> k >> x;
add(k-1, x);
}
}
for (int i = head;i != -1;i = ne[i])
{
cout << e[i] << ' ';
}
return 0;
}
//10
//H 9
//I 1 1
//D 1
//D 0
//H 6
//I 3 6
//I 4 5
//I 4 5
//I 3 4
//D 6
邻接表:
将每个单链表连接起来,就是邻接表
邻接表的应用:
存储树和图
2.数组模拟双链表
双链表有两个方向,一个指向前,另一个指向后,而单链表只能指向后
因此也可以看出单链表插入时只能插入在往后的方向
需要的数组有e[n],l[n],r[n]和下标idx
e[n]表示该点的值
l[n]表示该点左边节点的指针
r[n]表示右边节点的指针,与单链表next同理
idx表示第几次操作数
head默认为0,tail默认为1
对于插入节点和删除节点的操作与单链表相类似
插入节点
1.存储要插入节点的值(可以放在任意位置)
2.改变k的右节点和插入值的左节点,让k和idx连接
3.改变k原先右节点的左节点和插入值的右节点,让k原先的右节点和插入值连接
4.最后操作数+1
实现代码
void addr(int k,int &x)//在k节点的右边插入一个点
{
e[idx] = x;
r[idx] = r[k];
l[idx] = k;
l[r[k]] = idx;//这两步
r[k] = idx;//顺序不能变
idx++;
}
如果想要在k的左边插入一个节点,可以理解为在k的左节点的后面插入一个点,也就是add( l [ k ] , x )
删除节点
让该节点的左节点所指的next直接指向该节点的右节点
让该节点的右节点所指的last直接指向该节点的左节点
实现代码
void remove(int k)//删除第k个节点
{
r[l[k]] = r[k];
l[r[k]] = l[k];
}
总实现代码
#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
using namespace std;
const int N = 10010;
int e[N], l[N], r[N], idx;
void Init()
{
r[0] = 1, l[1] = 0;//r[0] = 1表示右端点即tail,l[1] = 0表示左端点即head
idx = 2;
}
void add(int k,int &x)//在k节点的右边插入一个点
{
e[idx] = x;
r[idx] = r[k];
l[idx] = k;
l[r[k]] = idx;//这两步
r[k] = idx;//顺序不能变
idx++;
}
void remove(int k)//删除第k个节点
{
r[l[k]] = r[k];
l[r[k]] = l[k];
}
int main()
{
Init();
}