02 链表-常见题型及思路总结
【Day 3】 -【代码随想录训练营20期】打卡
链表总结
链表理论基础
链表的类型
单链表：只有一个指针域，并且只指向下一个节点。
双链表：有两个指针域并指向前一个节点和后一个节点。
循环链表：链表末端指针域指向头节点。
链表的储存
不像数组一样是连续的，而是非连续的，彼此之间通过指针来指向。
链表的初始化
public class ListNode {
// 结点的值
int val;
// 下一个结点
ListNode next;
// 节点的构造函数(无参)
public ListNode() {
}
// 节点的构造函数(有一个参数)
public ListNode(int val) {
this.val = val;
}
// 节点的构造函数(有两个参数)
public ListNode(int val, ListNode next) {
this.val = val;
this.next = next;
}
}链表的创建
public class MyLinkedList {
public ListNode head;//先声明一个链表的头
public void creatList(){
//创建两个节点
ListNode listNode1 = new ListNode(a);
ListNode listNode2 = new ListNode(b);
//头节点指向listNode1
this.head = listNode1;
//头节点连上下一个节点
listNode1.next = listNode2;
}
}链表的增加和删除
若是头尾，时间复杂度O(1)，若中间某个点，则是O(n)。
增加和删除：改变插入位置前后节点指针的指向，单链表只用改一个指针。
性能分析
203. 移除链表元素
给你一个链表的头节点
head和一个整数val，请你删除链表中所有满足Node.val == val的节点，并返回 新的头节点 。
思路：
这是典型的删除链表题型，注意需要返回新的头节点。可能存在删除的节点就是头节点的情况，因此设置一个虚拟头节点是方便的。
虚拟头节点
public ListNode removeElements(ListNode head, int val) {
if (head == null) {
return head;
}
// 因为删除可能涉及到头节点，所以设置dummy节点，统一操作
// -1 和 head 分别表示 val 和 next
ListNode dummy = new ListNode(-1, head);
// 前节点设置为虚拟节点，后节点设置为头节点
ListNode pre = dummy;
ListNode cur = head;
// 后节点不为空的情况下
while (cur != null) {
//如果后节点的值就是val，那么跳过该节点
if (cur.val == val) {
pre.next = cur.next;
} else {
//如果不是val，那么前节点后移
pre = cur;
}
//后节点后移
cur = cur.next;
}
//返回的不是虚拟头节点，而是其后节点，也就是真正的头节点
return dummy.next;
}不添加虚拟头节点
public ListNode removeElements(ListNode head, int val) {
//考虑到头节点val相等的情况，头节点后移
while (head != null && head.val == val) {
head = head.next;
}
// 已经为null，提前退出
if (head == null) {
return head;
}
// 已确定当前head.val != val
ListNode pre = head;
ListNode cur = head.next;
while (cur != null) {
if (cur.val == val) {
pre.next = cur.next;
} else {
pre = cur;
}
cur = cur.next;
}
return head;
}707. 设计链表
你可以选择使用单链表或者双链表，设计并实现自己的链表。
单链表中的节点应该具备两个属性：
val和next。val是当前节点的值，next是指向下一个节点的指针/引用。如果是双向链表，则还需要属性
prev以指示链表中的上一个节点。假设链表中的所有节点下标从 0 开始。实现
MyLinkedList类：
MyLinkedList()初始化MyLinkedList对象。int get(int index)获取链表中下标为index的节点的值。如果下标无效，则返回-1。void addAtHead(int val)将一个值为val的节点插入到链表中第一个元素之前。在插入完成后，新节点会成为链表的第一个节点。void addAtTail(int val)将一个值为val的节点追加到链表中作为链表的最后一个元素。void addAtIndex(int index, int val)将一个值为val的节点插入到链表中下标为index的节点之前。如果index等于链表的长度，那么该节点会被追加到链表的末尾。如果index比长度更大，该节点将 不会插入 到链表中。void deleteAtIndex(int index)如果下标有效，则删除链表中下标为index的节点。
思路：
这题就是讲链表操作的，比较复杂但是不难的，按部就班来就行。
单链表
//单链表
class ListNode {
int val;//链表的val值
ListNode next;//next代表下一个节点
//这里提供了两个构造器
ListNode(){}
ListNode(int val) {
this.val=val;
}
}
class MyLinkedList {
//size是存储链表元素的个数
int size;
//虚拟头结点
ListNode head;
//初始化链表
public MyLinkedList() {
size = 0;
head = new ListNode(0);
}
//获取第index个节点的数值，注意index是从0开始的，第0个节点就是头结点
public int get(int index) {
//如果index非法，返回-1
if (index < 0 || index >= size) {
return -1;
}
ListNode currentNode = head;
//包含一个虚拟头节点，所以查找第 index+1 个节点
for (int i = 0; i <= index; i++) {
currentNode = currentNode.next;
}
return currentNode.val;
}
//在链表最前面插入一个节点，等价于在第0个元素前添加
public void addAtHead(int val) {
//该方法在后面有定义
addAtIndex(0, val);
}
//在链表的最后插入一个节点，等价于在(末尾+1)个元素前添加
public void addAtTail(int val) {
addAtIndex(size, val);
}
// 在第 index 个节点之前插入一个新节点，例如index为0，那么新插入的节点为链表的新头节点。
// 如果 index 等于链表的长度，则说明是新插入的节点为链表的尾结点
// 如果 index 大于链表的长度，则返回空
public void addAtIndex(int index, int val) {
if (index > size) {
return;
}
if (index < 0) {
index = 0;
}
size++;
//找到要插入节点的前驱
ListNode pred = head;
for (int i = 0; i < index; i++) {
pred = pred.next;
}
//定义一个新节点储存，准备插进去
ListNode toAdd = new ListNode(val);
//该新节点指向原先pre的下一个节点
toAdd.next = pred.next;
//pre指向该新节点
pred.next = toAdd;
}
//删除第index个节点，关键在于直接跳过next指向next.next
public void deleteAtIndex(int index) {
if (index < 0 || index >= size) {
return;
}
size--;
if (index == 0) {
head = head.next;
return;
}
ListNode pred = head;
for (int i = 0; i < index ; i++) {
pred = pred.next;
}
pred.next = pred.next.next;
}
}双向链表
//双链表
class ListNode{
int val;
ListNode next,prev;
ListNode() {};
ListNode(int val){
this.val = val;
}
}
class MyLinkedList {
//记录链表中元素的数量
int size;
//记录链表的虚拟头结点和尾结点
ListNode head,tail;
public MyLinkedList() {
//初始化操作
this.size = 0;
this.head = new ListNode(0);
this.tail = new ListNode(0);
//这一步非常关键，否则在加入头结点的操作中会出现null.next的错误！！！
head.next=tail;
tail.prev=head;
}
public int get(int index) {
//判断index是否有效
if(index<0 || index>=size){
return -1;
}
ListNode cur = this.head;
//判断是哪一边遍历时间更短
if(index >= size / 2){
//tail开始
cur = tail;
for(int i=0; i< size-index; i++){
cur = cur.prev;
}
}else{
for(int i=0; i<= index; i++){
cur = cur.next;
}
}
return cur.val;
}
public void addAtHead(int val) {
//等价于在第0个元素前添加
addAtIndex(0,val);
}
public void addAtTail(int val) {
//等价于在最后一个元素(null)前添加
addAtIndex(size,val);
}
public void addAtIndex(int index, int val) {
//index大于链表长度
if(index>size){
return;
}
//index小于0
if(index<0){
index = 0;
}
size++;
//找到前驱
ListNode pre = this.head;
for(int i=0; i=size){
return;
}
//删除操作
size--;
ListNode pre = this.head;
for(int i=0; i 206. 反转链表
给你单链表的头节点
head，请你反转链表，并返回反转后的链表。
思路：
1. 反转单链表，需要用到一个temp节点来作为中转，类似于数组排序中的temp值，不过要复杂一点。
2. 用双指针法来完成前后两个节点的指向。
双指针法
1. 定义prev前指针（左边）指向空，cur后指针（右边）指向头指针，临时节点用于中转。
2. 执行单链表的断指针前，一定要用临时节点储存.next。
3. 断指针并反转，cur.next指向pre
4. 接下来就是pre和cur的右移，分别通过 pre = cur 和 cur = temp 实现。
5. 注意，是先移动后翻转，因此while的临界点是 cur != null。同时翻转后的头节点为prev。
class Solution {
public ListNode reverseList(ListNode head) {
//定义前指针节点
ListNode prev = null;
//定义后指针节点
ListNode cur = head;
//定义临时节点用于中转
ListNode temp = null;
while (cur != null) {
temp = cur.next;// 临时节点保存下一个节点
cur.next = prev;//cur断开指针，连上前指针节点
prev = cur;//前指针右移
cur = temp;//cur指针右移
}
return prev;
}
}时间复杂度：O(n)
空间复杂度：O(1)
递归解法
递归有亿点抽象。。。搞不懂很正常，来让我们看看。
递归的使用条件：首先反转链表的操作是可以递归的，因为每一次反转的操作都一样，同时上一步的操作会影响下一步的操作。
第一步，定义递归函数，怎么确定其传入参数呢？一般是满足几个条件：
1. 该参数随着每次操作改变。
2. 该参数同时是每次操作的输入值和输出值。
在本题中，pre cur 和 temp的值都会改变，但 temp 只是临时储存相当于备胎而已无关紧要的，因此只用pre和cur。
第二步，确定递归的终止条件，这个条件一般是由传入参数来决定的，通常与传入参数的变化趋势一致，在本题中 cur 不断减小，最终就是cur == null。
第三步，实现递归的业务层，这里描述了具体的操作。在本题中，即为完成前后节点的指针反转。本来还要实现 pre 和 cur 的右移，但在下一个递归调用中通过传参巧妙绕开了这部分代码。
class Solution {
public ListNode reverseList(ListNode head) {
return reverse(null, head);
}
//这里定义了一个递归函数，将传入参数是pre和cur，也就是说每次递归的变量都是pre和cur
private ListNode reverse(ListNode prev, ListNode cur) {
//递归的终止条件
if (cur == null) {
return prev;
}
//每次递归的业务层：进行指针反转
ListNode temp = null;
temp = cur.next;// 先保存下一个节点
cur.next = prev;// 反转
//每次递归的传输层：更新prev、cur位置
// 相当于：prev = cur; cur = temp;
return reverse(cur, temp);
}
}024. 两两交换链表中的节点
给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。
思路：
1. 可以通过模拟或归纳来解。
2. 注意边界，当前节点为null或当前节点的next为null时停止。
模拟法
1. 要定义虚拟头节点，不然返回不了头节点，因为没有指针指向它。
2. 注意边界是怎么定义的。
class Solution {
public ListNode swapPairs(ListNode head) {
ListNode dumyhead = new ListNode(-1); // 设置一个虚拟头结点
dumyhead.next = head; // 将虚拟头结点指向head，这样方面后面做删除操作
ListNode cur = dumyhead;
ListNode temp; // 临时节点，保存两个节点后面的节点
ListNode firstnode; // 临时节点，保存两个节点之中的第一个节点
ListNode secondnode; // 临时节点，保存两个节点之中的第二个节点
while (cur.next != null && cur.next.next != null) {
temp = cur.next.next.next;
firstnode = cur.next;
secondnode = cur.next.next;
cur.next = secondnode; // 步骤一
secondnode.next = firstnode; // 步骤二
firstnode.next = temp; // 步骤三
cur = firstnode; // cur移动，准备下一轮交换
}
return dumyhead.next;
}
}递归法
1. 注意传入参数是每次执行交换的链表头节点，也就是说返回的也是每次的头节点。
2. 终止条件是下次执行的第一个节点为空或第二个节点为空。
3. 由于每次都返回
class Solution {
public ListNode swapPairs(ListNode head) {
if (head == null || head.next == null)
return head;
//定义三个节点来执行储存
ListNode node1 = head;
ListNode node2 = head.next;
ListNode node3 = node2.next;
node1.next = swapPairs(node3); // 1 指向递归返回的链表头，先执行这个避免空指针
node2.next = node1; // 2 指向 1
return node2; // 返回交换后的链表头节点
}
}
019. 删除链表的倒数第 N 个结点
给你一个单链表，删除链表的倒数第
n个结点，并且返回链表的头结点。提示：
- 链表中结点的数目为
sz1 <= sz <= 300 <= Node.val <= 1001 <= n <= sz
思路：
1. 模拟：该题不难，主要是要考虑到不同情况的边界问题，先用纸将思路写出来，罗列好各种情况再动手写代码。如 n = 1, n = sz 的情况。
2. 该题可以使用快慢指针，一次遍历就可以找到目标节点。由于不知道链表的长度，我们无法直接从后往前数，因此可以利用快慢指针的区间来进行距离的测量！让快指针在n+1处开始，慢指针在1处开始，当快指针移动到末端时，慢指针就是倒数第n个！
模拟法
class Solution {
public ListNode removeNthFromEnd(ListNode head, int n) {
int count = 1;
ListNode cur = head;
ListNode pre;
//考虑空链表的情况
if(cur == null){
return head;
}
//先得到链表长度
while(cur.next != null){
cur = cur.next;
++count;
}
//考虑删除最后一个节点的情况
if(count == n){
cur = head.next;
head.next = null;
return cur;
}
//当删除的是中间节点时
cur = head;
//先遍历找到节点，然后执行删除操作
while(count > n){
if(count == n + 1){
pre = cur;
cur = cur.next;
pre.next = cur.next;
cur.next = null;
return head;
}
cur = cur.next;
--count;
}
return head；
}
}快慢指针
public ListNode removeNthFromEnd(ListNode head, int n){
ListNode dummyNode = new ListNode(0);
dummyNode.next = head;
ListNode fastIndex = dummyNode;
ListNode slowIndex = dummyNode;
//只要快慢指针相差 n 个结点即可
for (int i = 0; i < n ; i++){
fastIndex = fastIndex.next;
}
while (fastIndex.next != null){
fastIndex = fastIndex.next;
slowIndex = slowIndex.next;
}
//此时 slowIndex 的位置就是待删除元素的前一个位置。
//具体情况可自己画一个链表长度为 3 的图来模拟代码来理解
slowIndex.next = slowIndex.next.next;
return dummyNode.next;
}02.07. 链表相交
给你两个单链表的头节点
headA和headB，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回null。题目数据 保证 整个链式结构中不存在环。
注意，函数返回结果后，链表必须 保持其原始结构 。
图示两个链表在节点
c1开始相交：
思路：
该题可以暴力解，也就是用两个while循环来分别将两个链表的节点都比较一下。
也可以用快慢指针的变种，先确定两个链表的差值，然后让长的那个链表指针先移动对应位数，再一起比较两个指针。
暴力解法
public class Solution {
public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
ListNode aIndex = headA;
ListNode bIndex = headB;
while(aIndex != null){
while(bIndex != null){
if(aIndex == bIndex){
return bIndex;
}
bIndex = bIndex.next;
}
//这里要注意重新赋值指针，让它重新回到头节点，重头遍历
bIndex = headB;
aIndex = aIndex.next;
}
return null;
}
}快慢指针
public class Solution {
public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
ListNode aIndex = headA;
ListNode bIndex = headB;
int countA = 1;
int countB = 1;
while(aIndex != null){
aIndex = aIndex.next;
++countA;
}
while(bIndex != null){
bIndex = bIndex.next;
++countB;
}
int max = countA > countB ? countA : countB;
int min = countA < countB ? countA : countB;
//这里注意要重新赋值指针，让它们回到头节点
aIndex = headA;
bIndex = headB;
for(int i = 0; i < max - min; i++){
if(max == countA){
aIndex = aIndex.next;
}else{
bIndex = bIndex.next;
}
}
while(aIndex != null){
if(aIndex == bIndex){
return aIndex;
}
aIndex = aIndex.next;
bIndex = bIndex.next;
}
return null;
}
}142. 环形链表 II
给定一个链表的头节点
head，返回链表开始入环的第一个节点。 如果链表无环，则返回null。如果链表中有某个节点，可以通过连续跟踪
next指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数pos来表示链表尾连接到链表中的位置（索引从 0 开始）。如果pos是-1，则在该链表中没有环。注意：pos不作为参数进行传递，仅仅是为了标识链表的实际情况。不允许修改 链表。
输入：head = [3,2,0,-4], pos = 1 输出：返回索引为 1 的链表节点 解释：链表中有一个环，其尾部连接到第二个节点。
思路：
暴力+快慢指针解法：直接循环10000次，每次fast进1，如果空就无环，如果有环就每循环10000次，slow进一步，直到它们相交。
数学归纳+快慢指针解法：注意循环次数太大了，会造成资源的浪费，那么有什么办法可以判断有没有环呢？有的，可以设置快慢双指针，快指针移动两步，慢指针移动一步，当快指针赶上慢指针时，就有环。如果有环，那么此时快指针和head指针到相交点的距离是一样的（ x = z ），因为当快指针多跑的距离（n个环）正好就是慢指针的移动距离。
暴力+快慢指针解法
public class Solution {
public ListNode detectCycle(ListNode head) {
if(head == null){
return null;
}
ListNode slowIndex = head;
ListNode fastIndex = head.next;
ListNode guideIndex = fastIndex;
int count = 1;
if(fastIndex == null){
return null;
}
while(true){
while(guideIndex != fastIndex){
if(fastIndex == null){
return null;
}
if(fastIndex == slowIndex){
return fastIndex;
}
if(count % 2 == 1 ? false : true){
guideIndex = guideIndex.next;
}
fastIndex = fastIndex.next;
++count;
}
fastIndex = fastIndex.next;
if(fastIndex == guideIndex){
return fastIndex;
}
slowIndex = slowIndex.next;
}
}
}数学归纳+快慢指针解法
public class Solution {
public ListNode detectCycle(ListNode head) {
ListNode slow = head;
ListNode fast = head;
while (fast != null && fast.next != null) {
slow = slow.next;
fast = fast.next.next;
if (slow == fast) {// 有环
ListNode index1 = fast;
ListNode index2 = head;
// 两个指针，从头结点和相遇结点，各走一步，直到相遇，相遇点即为环入口
while (index1 != index2) {
index1 = index1.next;
index2 = index2.next;
}
return index1;
}
}
return null;
}
}