代码随想录算法day4-优快云博客

Base Case 决定
- 如果链表为空或者只有一个节点，不需要操作，直接返回原链表。
java

复制代码
```
if(head == null || head.next == null) return head;
```
当前层处理
- 获取当前节点的下一个节点：
  java
  
  复制代码
```
ListNode next = head.next;
```
- 对于剩下的部分进行递归调用：
  java
  
  复制代码
```
ListNode newNode = swapPairs(next.next);
```
节点交换
- 将当前节点的下一个节点指向调用递归的结果：
  java
  
  复制代码
```
head.next = newNode;
```
- 将当前节点的下一个节点的下一节点指向当前节点：
  java
  
  复制代码
```
next.next = head;
```
合并结果
- 返回交换后的新的头节点：
  java
  
  复制代码
```
return next;
```

3. 递归的运行

第一次调用 swapPairs(1)
- head = 1
- next = 2
- 递归调用 swapPairs(3) 得到新链表 4 -> 3
交换节点
- 2.next = 1
- 1.next = 4 (递归返回的结果)
返回 2

合并后的链表就是 2 -> 1 -> 4 -> 3。

构思总结

递归的核心在于分步处理：每次递归只需要关心当前层（两个节点）的交换，而剩下部分交给递归处理。
每层处理的简化：通过递归处理剩下部分，当前层只需要交换两个节点即可。

利用递归这样的一种“分而治之”策略，将复杂问题分解成若干个子问题，实现了逻辑上的简洁和代码的清晰性。这种递归思路可以帮助我们轻松处理二叉树和链表等递归结构的数据结构问题。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode swapPairs(ListNode head) {
        //递归
        if (head==null||head.next==null){
            return head;//终止情况
        }
        ListNode next=head.next;
        ListNode later_nodes=swapPairs(next.next);
        //交换
        next.next=head;
        head.next=later_nodes;
        return next;
    }
}

常规方法

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;  
    }
}
// 将步骤 2,3 交换顺序，这样不用定义 temp 节点
public ListNode swapPairs(ListNode head) {
    ListNode dummy = new ListNode(0, head);
    ListNode cur = dummy;
    while (cur.next != null && cur.next.next != null) {
        ListNode node1 = cur.next;// 第 1 个节点
        ListNode node2 = cur.next.next;// 第 2 个节点
        cur.next = node2; // 步骤 1
        node1.next = node2.next;// 步骤 3
        node2.next = node1;// 步骤 2
        cur = cur.next.next;
    }
    return dummy.next;
}

19.删除链表的倒数第N个节点

力扣题目链接(opens new window)

给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。

进阶：你能尝试使用一趟扫描实现吗？

示例 1：

19.删除链表的倒数第N个节点

输入：head = [1,2,3,4,5], n = 2 输出：[1,2,3,5]

示例 2：

输入：head = [1], n = 1 输出：[]

示例 3：

输入：head = [1,2], n = 1 输出：[1]

双指针法，一遍遍历，先设定快指针比慢指针快多少跑，然后一起遍历，直到快指针到底。

双指针的经典应用，如果要删除倒数第n个节点，让fast移动n步，然后让fast和slow同时移动，直到fast指向链表末尾。删掉slow所指向的节点就可以了。

思路是这样的，但要注意一些细节。

分为如下几步：

首先这里我推荐大家使用虚拟头结点，这样方便处理删除实际头结点的逻辑，如果虚拟头结点不清楚，可以看这篇：链表：听说用虚拟头节点会方便很多？(opens new window)
定义fast指针和slow指针，初始值为虚拟头结点，如图：

fast首先走n + 1步，为什么是n+1呢，因为只有这样同时移动的时候slow才能指向删除节点的上一个节点（方便做删除操作），如图：
fast和slow同时移动，直到fast指向末尾，如题：
删除slow指向的下一个节点，如图：

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode dummy=new ListNode(0);
        dummy.next=head;
        ListNode fastIndex=dummy;
        ListNode slowIndex=dummy;
        // 只要快慢指针相差 n 个结点即可
        for (int i = 0; i < n; i++) {
            fastIndex = fastIndex.next;
        }
        while(fastIndex.next!=null){
            fastIndex = fastIndex.next;
            slowIndex = slowIndex.next;
        }

        slowIndex.next=slowIndex.next.next;
        return dummy.next;
    }
}

面试题 02.07. 链表相交

同：160.链表相交

力扣题目链接(opens new window)

给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。

图示两个链表在节点 c1 开始相交：

题目数据保证整个链式结构中不存在环。

注意，函数返回结果后，链表必须保持其原始结构。

示例 1：

示例 2：

示例 3：

#思路

一

简单来说，就是求两个链表交点节点的指针。这里同学们要注意，交点不是数值相等，而是指针相等。

为了方便举例，假设节点元素数值相等，则节点指针相等。

看如下两个链表，目前curA指向链表A的头结点，curB指向链表B的头结点：

面试题02.07.链表相交_1

我们求出两个链表的长度，并求出两个链表长度的差值，然后让curA移动到，和curB 末尾对齐的位置，如图：

面试题02.07.链表相交_2

此时我们就可以比较curA和curB是否相同，如果不相同，同时向后移动curA和curB，如果遇到curA == curB，则找到交点。

否则循环退出返回空指针。

(版本一)先行移动长链表实现同步移动
public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        ListNode curA = headA;
        ListNode curB = headB;
        int lenA = 0, lenB = 0;
        while (curA != null) { // 求链表A的长度
            lenA++;
            curA = curA.next;
        }
        while (curB != null) { // 求链表B的长度
            lenB++;
            curB = curB.next;
        }
        curA = headA;
        curB = headB;
        // 让curA为最长链表的头，lenA为其长度
        if (lenB > lenA) {
            //1. swap (lenA, lenB);
            int tmpLen = lenA;
            lenA = lenB;
            lenB = tmpLen;
            //2. swap (curA, curB);
            ListNode tmpNode = curA;
            curA = curB;
            curB = tmpNode;
        }
        // 求长度差
        int gap = lenA - lenB;
        // 让curA和curB在同一起点上（末尾位置对齐）
        while (gap-- > 0) {
            curA = curA.next;
        }
        // 遍历curA 和 curB，遇到相同则直接返回
        while (curA != null) {
            if (curA == curB) {
                return curA;
            }
            curA = curA.next;
            curB = curB.next;
        }
        return null;
    }

}

(版本二) 合并链表实现同步移动
public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
		// p1 指向 A 链表头结点，p2 指向 B 链表头结点
		ListNode p1 = headA, p2 = headB;
		while (p1 != p2) {
			// p1 走一步，如果走到 A 链表末尾，转到 B 链表
			if (p1 == null) p1 = headB;
			else            p1 = p1.next;
			// p2 走一步，如果走到 B 链表末尾，转到 A 链表
			if (p2 == null) p2 = headA;
			else            p2 = p2.next;
		}
		return p1;
    }
}

二

实际上，这种方法只会完整遍历两条链表一次，至多走两次链表的长度（m + n步）。我们可以通过分析确认，在两次遍历中指针将会碰巧遇到（如果有相交节点）。让我们更详细解释这个过程，以确保完全理解。

详细步骤分析

假设链表 A 和链表 B 的长度分别为 m 和 n，且有相交部分，设相交点为 C：

m = x + z，链表 A 长度，其中 x 为链表 A 从头节点到相交节点的长度，z 为相交部分长度。
n = y + z，链表 B 长度，其中 y 为链表 B 从头节点到相交节点的长度，z 为相交部分长度。

当用两指针方法（pA 和 pB）来遍历这两个链表时：

初始遍历

第一次遍历链表 A 和链表 B：
- pA 走完 x 之后进入公共部分 z，然后继续走到链表 A 的末尾。
- pB 走完 y 之后进入公共部分 z，然后继续走到链表 B 的末尾。

交叉遍历

指针切换：
- 当 pA 到达链表 A 的末尾时（即 null），它继续从链表 B 的头开始。
- 当 pB 到达链表 B 的末尾时（即 null），它继续从链表 A 的头开始。

完整遍历

交叉遍历步骤：
- 现在 pA 从链表 B 的头开始走 y 的距离，此时它已经走过 x + z 和 y 的距离。
- 同时，pB 从链表 A 的头开始走 x 的距离，此时它也已经走过 y + z 和 x 的距离。

相遇

相遇确认：
- 因为两者最终都会走 x + z + y 的距离，到 z 的位置时两者会相遇：

在遍历完整两个链表长度后，两个指针将会在相交点处相遇（如果存在相交点），或者在没有相交点的情况下同时到达 null 位置（指针尾部）。

运行流程示例

假设链表 A 和链表 B 有以下结构，并且有一个相交节点：

链表 A: a1 -> a2 -> c1 -> c2 -> c3
- 链表长度 m = 5（包括2个独有节点加3个共享节点）
链表 B: b1 -> b2 -> b3 -> c1 -> c2 -> c3
- 链表长度 n = 6（包括3个独有节点加3个共享节点）

初始指针指向：
- pA 指向 a1，pB 指向 b1。
首次遍历：
- pA 走完 a1, a2, c1, c2, c3 并到达 null（即指针末端）。
- pB 走完 b1, b2, b3, c1, c2, c3 并到达 null（即指针末端）。
指针切换：
- pA 从 b1 重新开始。
- pB 从 a1 重新开始。
二次遍历：
- pA 走过 b1 -> b2 -> b3，此时已经总共走过 a1->a2->c1->c2->c3 + b1->b2->b3 等于 5+3=8 步。
- pB 走过 a1 -> a2 -> c1，此时已经总共走过 b1->b2->b3->c1->c2->c3 + a1->a2 等于 6+2=8 步。

在这种交叉遍历完毕之后，由于步数已经对齐长度，两个指针确实在相交点 c1 处相遇，无需再额外遍历。

总结

通过交叉遍历机制实现一次完整的链表扫描，两个指针用各自等量的步数便可以覆盖不同链表加上公共链表路径互动方式实现：

指针有效交叉遍历：由于两个指针交换在走步数后步长相等，因为两指针一旦存在相交（相等节点），最易在共同节点步长上遇到；若无公共节点结合处，均完毕各自尾接处都指向 null 终结循环。
确保无额外循环：高效访问链表保证无重复，只需额外内存为 O(1) 时间复杂度为 O(m+n) 符合线性复杂度内遍历交点。

142.环形链表II

力扣题目链接(opens new window)

题意：给定一个链表，返回链表开始入环的第一个节点。如果链表无环，则返回 null。

为了表示给定链表中的环，使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。

说明：不允许修改给定的链表。

循环链表

#算法公开课

《代码随想录》算法视频公开课 (opens new window)：把环形链表讲清楚！| LeetCode:142.环形链表II (opens new window)，相信结合视频再看本篇题解，更有助于大家对链表的理解。

#思路

这道题目，不仅考察对链表的操作，而且还需要一些数学运算。

主要考察两知识点：

判断链表是否环
如果有环，如何找到这个环的入口

#判断链表是否有环

可以使用快慢指针法，分别定义 fast 和 slow 指针，从头结点出发，fast指针每次移动两个节点，slow指针每次移动一个节点，如果 fast 和 slow指针在途中相遇，说明这个链表有环。

为什么fast 走两个节点，slow走一个节点，有环的话，一定会在环内相遇呢，而不是永远的错开呢

首先第一点：fast指针一定先进入环中，如果fast指针和slow指针相遇的话，一定是在环中相遇，这是毋庸置疑的。

那么来看一下，为什么fast指针和slow指针一定会相遇呢？

可以画一个环，然后让 fast指针在任意一个节点开始追赶slow指针。

会发现最终都是这种情况，如下图：

142环形链表1

fast和slow各自再走一步， fast和slow就相遇了

这是因为fast是走两步，slow是走一步，其实相对于slow来说，fast是一个节点一个节点的靠近slow的，所以fast一定可以和slow重合。

动画如下：

141.环形链表

#如果有环，如何找到这个环的入口

此时已经可以判断链表是否有环了，那么接下来要找这个环的入口了。

假设从头结点到环形入口节点的节点数为x。环形入口节点到 fast指针与slow指针相遇节点节点数为y。从相遇节点再到环形入口节点节点数为 z。如图所示：

那么相遇时： slow指针走过的节点数为: x + y， fast指针走过的节点数：x + y + n (y + z)，n为fast指针在环内走了n圈才遇到slow指针，（y+z）为一圈内节点的个数A。

因为fast指针是一步走两个节点，slow指针一步走一个节点，所以 fast指针走过的节点数 = slow指针走过的节点数 * 2：

(x + y) * 2 = x + y + n (y + z)

两边消掉一个（x+y）: x + y = n (y + z)

因为要找环形的入口，那么要求的是x，因为x表示头结点到环形入口节点的的距离。

所以要求x ，将x单独放在左面：x = n (y + z) - y ,

再从n(y+z)中提出一个（y+z）来，整理公式之后为如下公式：x = (n - 1) (y + z) + z 注意这里n一定是大于等于1的，因为 fast指针至少要多走一圈才能相遇slow指针。

这个公式说明什么呢？

先拿n为1的情况来举例，意味着fast指针在环形里转了一圈之后，就遇到了 slow指针了。

当 n为1的时候，公式就化解为 x = z，

这就意味着，从头结点出发一个指针，从相遇节点也出发一个指针，这两个指针每次只走一个节点，那么当这两个指针相遇的时候就是环形入口的节点。

也就是在相遇节点处，定义一个指针index1，在头结点处定一个指针index2。

让index1和index2同时移动，每次移动一个节点，那么他们相遇的地方就是环形入口的节点。

动画如下：

142.环形链表II（求入口）

那么 n如果大于1是什么情况呢，就是fast指针在环形转n圈之后才遇到 slow指针。

其实这种情况和n为1的时候效果是一样的，一样可以通过这个方法找到环形的入口节点，只不过，index1 指针在环里多转了(n-1)圈，然后再遇到index2，相遇点依然是环形的入口节点。

/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode detectCycle(ListNode head) {
        ListNode fast=head;
        ListNode slow=head;
        while(fast!=null && fast.next!=null){//非环的末尾为判定
            fast=fast.next.next;
            slow=slow.next;
            if(fast==slow){
                ListNode ptr1=fast;
                ListNode ptr2=head;
                while(ptr1!=ptr2){
                    ptr1=ptr1.next;
                    ptr2=ptr2.next;
                }
                return ptr1;//有环会return终止
            }
        }
        return null;

    }
}

或者用哈希表