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

本文链接：https://blog.csdn.net/weixin_43831376/article/details/141276893

今日内容

leetcode. 24 两两交换链表中的节点
leetcode. 19 删除链表的倒数第N个节点
面试题 02.07. 链表相交
leetcode. 142 环形链表Ⅱ

今天的难度直接上了一个等级，虽然之前做过这些题，知道解题思路，但再次写代码时依然会时不时卡住。

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

文章链接：代码随想录 (programmercarl.com)

题目链接：24. 两两交换链表中的节点 - 力扣（LeetCode）

本题用虚拟头节点就非常方便了，就可以不再对原先的头节点用另外的逻辑去处理了。

另外处理此题时最好画个简单示意图，这么多的指针操作，不画图还真容易被绕进去。

本题的步骤如下图所示：

代码如下，代码中的步骤和上图步骤有小小差异，但没什么大问题：

/**
 * 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(0, head);
        ListNode p = dummyHead;
        while (p.next != null && p.next.next != null){
            ListNode temp = p.next.next.next;
            ListNode temp2 = p.next;
            p.next.next.next = temp2; // 步骤2
            p.next = temp2.next; // 步骤1
            temp2.next = temp; // 步骤3
            p = p.next.next; // 移动指针，进行下一轮调换
        }
        return dummyHead.next;
    }
}

时间复杂度：O(n)
空间复杂度：O(1)

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

文章链接：代码随想录 (programmercarl.com)

题目链接：19. 删除链表的倒数第 N 个结点 - 力扣（LeetCode）

本题可以先遍历长度后，再遍历到倒数第N个节点前，把该节点移除。

但这样太慢了，本身链表就不适合查询，这两次遍历够喝一壶的了。

所以本题可以引入双指针进行解决，将效率大大提高，这也是双指针的一大优势，可以将效率大大提升。

本题的双指针思想是：设置两个指针，一个快指针fast，一个慢指针slow。快指针先走N步，之后两个指针一起移动，直到快指针指向了链表最后一个元素（即 fast.next == null ）。此时慢指针slow指向的刚好是要移除节点的前一个节点，如图所示：

图中展示的是当 fast == null 时两指针停止移动，我的代码中是当 fast.next == null 时两指针停止移动，没什么大问题。

代码如下：

/**
 * 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 dummyHead = new ListNode(0, head);
        ListNode fast = dummyHead;
        ListNode slow = dummyHead;
        for (int i = 0; i < n; i++){
            fast = fast.next;
        }
        while (fast.next != null){
            fast = fast.next;
            slow = slow.next;
        }
        slow.next = slow.next.next;
        return dummyHead.next;
    }
}

时间复杂度：O(n)
空间复杂度：O(1)

面试题 02.07. 链表相交

文章链接：代码随想录 (programmercarl.com)

题目链接：面试题 02.07. 链表相交 - 力扣（LeetCode）

本题并不是依靠某种算法才好解决的题目，而是需要对题意进行分析，分析出来后就很好处理的题目。【像是废话】

首先题目给我们两个不等长的链表，它需要我们找到这两个链表相交的位置，如果没有相交就返回null。然后再看题目中对相交的定义，从图上看是相交点后的所有元素都相同。

那么我们可以分析出链表相交时有如下两个特征：

相交点元素一致
相交点后长度一致

所以为了找到相交点，首先就对其两个链表的尾部，之后再进行比较。

进行比较时要注意以比较短的链表为准。比如上图，A链表较短，所以B链表进行比较时要从b2节点开始。

代码如下：

/**
 * 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 lenA = 0;
        int lenB = 0;

        ListNode pA = headA;
        ListNode pB = headB;
        if (headA == null || headB == null){return null;}
        
        // 获取链表长度
        while (pA.next != null){
            lenA++;
            pA = pA.next;
        }
        
        while (pB.next != null){
            lenB++;
            pB = pB.next;
        }

        // 总是把 A 链表当作最长的进行处理
        if (lenB > lenA){
            int temp = lenA;
            lenA = lenB;
            lenB = temp;
            ListNode tempNode = headA;
            headA = headB;
            headB = tempNode;
        }

        ListNode p = headA;
        ListNode p2 = headB;

        // 对齐链表
        for (int i = 0; i < lenA - lenB; i++){
            p = p.next;
        }

        while (p != null){
            if (p == p2){return p;}
            p = p.next;
            p2 = p2.next;    
        }
        return null;
    }
}

时间复杂度：O(n + m)
空间复杂度：O(1)

Leetcode. 142 环形链表Ⅱ

文章链接：代码随想录 (programmercarl.com)

题目链接：142. 环形链表 II - 力扣（LeetCode）

本题需要一些数学分析才知道如何解决。

本题分为了两个子问题：

链表是否有环？
有环的话，环的起点在哪里？

一个个解决。首先如何判断链表是否有环？

我们可以通过快慢指针来判断。假设有一个快指针fast，它的步长为2；有一个慢指针slow，步长为1。那么如果链表有环的话，二者一定会在环里相遇。

为什么呢？我们就拿操场举例吧。

一般操场一圈为800m：

此时A先跑了200m，B刚上起跑线。A要往前追600m才能追上B。
B跑了100m，此时A又跑了200m。A要往前追500m才能追上B。
B跑了100m，此时A又跑了200m。A要往前追400m才能追上B。
.........

我们发现，A其实一直在慢慢逼近B，到某一时刻，A肯定能追上B。快慢指针判断环的原因就在于此。

解决了是否有环的判断，现在就需要找出环的起点。

整个有环链表可以用下图描述：

根据图片，可以得出如下等式关系：

fast = x + n * (y + z) + y // 表示快慢指针相遇前，快指针走过的节点数。其中 n 为走过的环圈数，(y + z) 是环中的节点数

slow = x + y // 表示快慢指针相遇前，慢指针走过的节点数。

// 由于快指针步长比慢指针快2倍，所以可以得出

fast = 2 * slow

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

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

=> x = (n - 1)*(y + z) + z

为何肯定慢指针不会绕很多圈

可以发现，快指针的等式中有个衡量走过圈数的参数 n，但是慢指针却没有。为何能肯定慢指针肯定走不了一圈呢？

我们这样想：同时从起点出发，慢指针走一圈，快指针可以走两圈。也就是说慢指针的那一圈里必定会和快指针碰见的。

同时出发都必定会碰上，更不用说快指针实际上是要比慢指针更早出发的情况了。

其中，n 肯定大于等于1。当 n = 1时可以发现，x 就等于 z。这也就说明，在头节点处和慢指针处同时出发步长为1的指针，当二者相遇时，相遇处就是环的入口。

这样经过分析后，两个问题都迎刃而解了。下面编写代码：

/**
 * 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 p = head;
                
                // 找到环入口
                while (p != slow){
                    p = p.next;
                    slow = slow.next;
                }
                return p;
            }  
        }
        return null;
    }
}