代码随想录算法训练营第四天 24.两两交换链表中的节点、19.删除链表的倒数第N个节点、面试题 02.07. 链表相交、142.环形链表II

24. 两两交换链表中的节点

题目链接：24. 两两交换链表中的节点

视频教程

文字教程

思路

• 重点：一定要画图，涉及需要定义几个指针和操作的先后顺序

本题的要使用虚拟头节点，保证所有节点的操作相同

代码实现

/**
 * 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) {
        ListNode dummyHead = new ListNode();
        dummyHead.next = head;
        ListNode cur = dummyHead.next; // 两两一组中的第一个
        ListNode pre = dummyHead; // 两两一组的前一个
        ListNode tmp;
        while (cur != null && cur.next != null) {
            tmp = cur.next.next;
            // 改变三个节点的next 一定一定注意前后顺序
            cur.next.next = cur; // 步骤一
            pre.next = cur.next; // 步骤二
            cur.next = tmp; // 步骤三
            
            pre = cur; // 因为顺序两两交换, cur成为这一组中最右边的节点
            cur = tmp; // 成为下一组的第一个
        }
        return dummyHead.next;
    }
}

---

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

题目链接：19.删除链表的倒数第N个节点

视频教程

文字教程

思路

双指针的经典应用，如果要让倒数第n个节点，让 fast 先移动n+1步，然后再让fast和slow同时移动，直到fast指向链表的末尾，删掉slow后面的指针即可。

分为如下几步：

• 使用虚拟头节点，保证所有节点的操作方式相同。

• 定义 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) { // n 代表两个节点的距离
        ListNode dummyHead = new ListNode();
        dummyHead.next = head;
        ListNode cur = dummyHead;
        ListNode pre = dummyHead; // 被删除节点的前一个节点
        for (int i = 0;i < n + 1;i++) { // 使两个指针距离为 n+1
            cur = cur.next;
        }
        while (cur != null) { // 利用双指针找到被删除节点的前一位
            cur = cur.next;
            pre = pre.next;
        }
        pre.next = pre.next.next; // 删除第N个节点
        return dummyHead.next;
    }
}

---

面试题 02.07. 链表相交

题目链接：面试题 02.07. 链表相交

文字教程

思路

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

为了方便举例，假设节点元素数值相等，则节点指针相等，步骤如下：

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

  

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

  

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

代码实现

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) { // 如果相交，那么两个链的最后部分肯定相同
        int sizeA = 0;
        int sizeB = 0;
        ListNode curA = headA;
        ListNode curB = headB;
        while (curA != null) { // 求链表A的长度
            curA = curA.next; 
            sizeA++;
        }
        while (curB != null) { // 求链表B的长度
            curB = curB.next;
            sizeB++;
        }
        curA = headA; // 将curA重置到headA
        curB = headB; // 将curB重置到headB
        // 将两个链表的末尾对齐，使curA和curB处于同一位置
        if (sizeA > sizeB) {
            for (int i = 0;i < sizeA - sizeB;i++) {
                curA = curA.next;
            }
        } else {
            for (int i = 0;i < sizeB - sizeA;i++) {
                curB = curB.next;
            }
        }
        // A链B链同时遍历寻找指针指向地址相同的节点
        for (int i = 0;i < Math.min(sizeA, sizeB);i++) {
            if (curA == curB) { // 地址相同
                return curA;
            }
            curA = curA.next;
            curB = curB.next;
        }
        return null;
    }
}

---

142.环形链表Ⅱ

题目链接：142.环形链表II

视频教程

文字教程

思路

这道题不仅考虑是否有环，还涉及一些数学运算。

主要考察两个知识点：

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

判断链表是否有环

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

因为 slow 进入环入口的那一刻，fast 相遇 slow 就变成了相对位移为 1 的追及问题，所以一定可以相遇。

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

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

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

那么相遇时：slow指针走过的节点数为 x + y ，fast指针走过的节点数为 x + y + n(y + z) ，n 为fast指针在环内走了 n 圈才遇到 slow指针，并且 n >= 1 。

这里 fast 转的圈数一定 >=1，slow 一圈也没转。（可以仔细思考一下，当成追及问题就很容易明白）

因为 fast 的速度为 2，slow 速度为 1，所以fast指针走过的节点数 = slow指针走过的节点数 * 2

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

因为要找到环的入口，所以我们需要找到 x

将 x 单独放到左边：x = (n - 1)(y + z) + z

这个公式意味着：

从头节点出发一个指针，从相遇节点也出发一个指针，这两个指针速度都为 1，那么当这两个指针第一次相遇的时候就是环形入口的节点。

动画如下：

那么当 n > 1 是什么情况呢，就是index2指针在环形圈内转了n圈之后才遇到slow指针。

代码实现

/**
 * 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 进入环后 fast 与 slow 的相对位移为 1
            slow = slow.next; // 前进一个节点
            if (fast == slow) { // 利用双指针判断有环，下面开始寻找环开始的位置，利用 x = z
                ListNode index1 = fast; // index1 从相遇点开始
                ListNode index2 = head; // index2 从头节点开始
                while (index1 != index2) { // index1和index2相遇的节点就是环开始的节点
                    index1 = index1.next;
                    index2 = index2.next;
                }
                return index1;
            }
        }
        return null; // 没有环
    }
}