目录
单链表
邻接表(n个单链表); 用于存储图和树
双链表
优化问题
单链表:
e[] 存储值
ne[]存储下一位的位置,相当于链表中的next()
head:头结点下标
idx:当前在数组中存储到的位置
实现一个单链表,链表初始为空,支持三种操作:
- 向链表头插入一个数;
- 删除第 k 个插入的数后面的数;
- 在第 k 个插入的数后插入一个数。
现在要对该链表进行 M 次操作,进行完所有操作后,从头到尾输出整个链表。
注意:题目中第 k 个插入的数并不是指当前链表的第 k 个数。例如操作过程中一共插入了 n 个数,则按照插入的时间顺序,这 n 个数依次为:第 11 个插入的数,第 22 个插入的数,…第 n 个插入的数。
输入格式
第一行包含整数 M,表示操作次数。
接下来 M 行,每行包含一个操作命令,操作命令可能为以下几种:
H x
,表示向链表头插入一个数 x。D k
,表示删除第 k 个插入的数后面的数(当 k 为 00 时,表示删除头结点)。I k x
,表示在第 k 个插入的数后面插入一个数 x(此操作中 k 均大于 00)。输出格式
共一行,将整个链表从头到尾输出。
import java.util.*;
import java.io.*;
class Main{
static int N = 100010; // 数组最大长度,加10保险
static int n,idx,head = -1; // 数组长度,存储位置,头结点
static int[] e = new int[N]; // 存值
static int[] ne = new int[N]; // 存下一个节点位置next()
public static void main(String[] args) throws IOException{
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
n = Integer.parseInt(in.readLine());
while(n-->0){
String[] str = in.readLine().split(" ");
if(str[0].equals("H")){//头插
add_to_head(Integer.parseInt(str[1]));
}
else if(str[0].equals("D")){//删除
if(Integer.parseInt(str[1])==0)
head = ne[head];
else
delete(Integer.parseInt(str[1])-1);
}
else{ // 插入到k位置
add(Integer.parseInt(str[1])-1,Integer.parseInt(str[2]));
}
}
for(int i=head;i!=-1;i=ne[i]){
System.out.print(e[i]+" ");
}
}
// 头插
public static void add_to_head(int x){
e[idx] = x;
ne[idx] = head;
head = idx;
idx++;
}
// 删除
public static void delete(int k){
ne[k] = ne[ne[k]];
}
// 插入到第k个位置
public static void add(int k,int x){
e[idx] = x;
ne[idx] = ne[k];
ne[k] = idx;
idx++;
}
}
双链表
e[] :存值
l[] :左节点位置
r[] :右节点位置
head,tail :左端点(在数组中0位置表示左端点),右端点(1位置表示右端点)
init(): r[0] = 1; l[1] = 0 ; idx = 2;
实现一个双链表,双链表初始为空,支持 55 种操作:
- 在最左侧插入一个数;
- 在最右侧插入一个数;
- 将第 k 个插入的数删除;
- 在第 k 个插入的数左侧插入一个数;
- 在第 k 个插入的数右侧插入一个数
现在要对该链表进行 M 次操作,进行完所有操作后,从左到右输出整个链表。
注意:题目中第 k 个插入的数并不是指当前链表的第 k 个数。例如操作过程中一共插入了 n 个数,则按照插入的时间顺序,这 n 个数依次为:第 11 个插入的数,第 22 个插入的数,…第 n 个插入的数。
输入格式
第一行包含整数 M,表示操作次数。
接下来 M 行,每行包含一个操作命令,操作命令可能为以下几种:
L x
,表示在链表的最左端插入数 x。R x
,表示在链表的最右端插入数 x。D k
,表示将第 k 个插入的数删除。IL k x
,表示在第 k 个插入的数左侧插入一个数。IR k x
,表示在第 k 个插入的数右侧插入一个数。输出格式
共一行,将整个链表从左到右输出。
画图理解:
import java.util.*;
class Main{
static final int N = 100010; // 给定的数据范围+10
static int n; // 链表长度
static int idx;
static int[] e = new int[N]; // 存值
static int[] l = new int[N]; // 左节点位置
static int[] r = new int[N]; // 右节点位置
public static void main(String[] args){
Scanner in = new Scanner(System.in);
n = in.nextInt();
init();
while(n-->0){
String s = in.next();
if(s.equals("R")){ //尾插
int x = in.nextInt();
add(l[1],x); // 相当于在最后一个节点的右边插入一个
}
else if(s.equals("D")){ // 删除
int k = in.nextInt();
remove(k+1);
}
else if(s.equals("L")){ // 头插
int x = in.nextInt();
add(0,x);
}
else if(s.equals("IL")){ // 在k位置节点的左边插入一个节点
int k = in.nextInt();
int x = in.nextInt();
add(l[k+1],x); // 相当于在k位置的前一个节点的右边插入一个节点
}
else{ // 在k位置的右边插入一个节点
int k = in.nextInt();
int x = in.nextInt();
add(k+1,x);
}
}
int i = r[0];
while(i!=1){
System.out.print(e[i]+" ");
i = r[i];
}
}
// 初始化
static void init(){
r[0] = 1;
l[1] = 0;
idx=2;
}
// 添加
static void add(int k,int x){
e[idx] = x;
r[idx] = r[k];
l[idx] = k;
l[r[k]] = idx;
r[k] = idx;
idx++;
}
// 删除
static void remove(int k){
r[l[k]] = r[k];
l[r[k]] = l[k];
}
}
邻接表
h[] :所有单链表的头节点
e[] : 存值
ne[] : 下一个节点的位置
初始化:h[0,1,...n] = -1
栈
先进后出
st[] :存值
top :栈顶(=-1)
进:st[++top] = x
出:top--
判断是否为空:if(top==-1) empty
栈顶:st[top]
队列
先进先出
queue[ ] :存值
ff :头(= -1) tt :尾(= -1)
进:queue[ ++tt ] = x
出:ff++
判断是否为空:if( ff == tt ) empty
队头:queue[ ff ]