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

本文链接：https://blog.youkuaiyun.com/Danny_8/article/details/138684543

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

题目链接：https://leetcode.cn/problems/swap-nodes-in-pairs/
文档讲解：https://programmercarl.com/0024.%E4%B8%A4%E4%B8%A4%E4%BA%A4%E6%8D%A2%E9%93%BE%E8%A1%A8%E4%B8%AD%E7%9A%84%E8%8A%82%E7%82%B9.html
视频讲解：https://www.bilibili.com/video/BV1YT411g7br

思路

写空指针判断的时候，要先判断前一个是否为空再判断后一个是否为空。不然如果前一个指针为空，先对这个空指针的下一个结点判断，会报空指针异常。
使用虚拟头结点来对该节点的的后面两个节点进行交换。注意用两个temp分别保存数据。

代码

class Solution {
    public ListNode swapPairs(ListNode head) {
        if (head == null || head.next == null) return head; 
        if (head.next == null) return head;
        ListNode dummyHead = new ListNode(-1, head);
        ListNode cur = dummyHead;
        while (cur.next != null && cur.next.next != null) {
            ListNode temp1 = cur.next; // 保存要交换的第一个结点
            ListNode temp2 = cur.next.next.next; // 保存要交换的第二个节点的下一个结点
            cur.next = cur.next.next;
            cur.next.next = temp1;
            temp1.next = temp2;
            cur = temp1;
        }

        return dummyHead.next;
    }
}

分析：
时间复杂度：O(n)，空间复杂度：O(1)。

总结
一开始觉得要用双指针来进行交换，看了卡哥的思路之后学到了只用一个cur指向前一个结点就可以交换。

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

题目链接：https://leetcode.cn/problems/remove-nth-node-from-end-of-list/
文档讲解：https://programmercarl.com/0019.%E5%88%A0%E9%99%A4%E9%93%BE%E8%A1%A8%E7%9A%84%E5%80%92%E6%95%B0%E7%AC%ACN%E4%B8%AA%E8%8A%82%E7%82%B9.html#%E7%AE%97%E6%B3%95%E5%85%AC%E5%BC%80%E8%AF%BE
视频讲解：https://www.bilibili.com/video/BV1vW4y1U7Gf

思路

双指针（快慢指针）是删除元素的经典方法。
要删除倒数第n个数，先让fast向前走n步。为了方便操作头结点，我们设置了虚拟头结点，所以这道题的fast需要先走n+1步。然后fast和slow一起向前移动，当fast指向null时，slow指向要删除节点的前一个节点。

代码

class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode dummyHead = new ListNode(-1, head);
        ListNode fast = dummyHead;
        ListNode slow = dummyHead;
        for (int i = 0; i <= n; i++) {
            fast = fast.next;
        }
        while (fast != null) {
            fast = fast.next;
            slow = slow.next;
        }
        slow.next = slow.next.next;
        return dummyHead.next;
    }
}

分析：
时间复杂度：O(n)，空间复杂度：O(1)。

总结
之前删除数组中等于val的数用到的就是快慢指针，这里删除链表中倒数元素用的也是快慢指针。

面试题 02.07. 链表相交

题目链接：https://leetcode.cn/problems/intersection-of-two-linked-lists-lcci/
文档讲解：https://programmercarl.com/%E9%9D%A2%E8%AF%95%E9%A2%9802.07.%E9%93%BE%E8%A1%A8%E7%9B%B8%E4%BA%A4.html#%E6%80%9D%E8%B7%AF
视频讲解：无

思路

首先求出两个链表的长度，如果A没有B长，就交换。
让A的指针移动到和B长度相等的地方，开始比较。
由于是求指针相等，所以遇到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) {
            lenA++;
            curA = curA.next;
        }
        while (curB != null) {
            lenB++;
            curB = curB.next;
        }
        curA = headA;
        curB = headB;

        if (lenB > lenA){
            int tempLen = lenA;
            lenA = lenB;
            lenB = tempLen;
            ListNode tempNode = curA;
            curA = curB;
            curB = tempNode;
        }

        int gap = lenA - lenB;
        while (gap > 0) {
            curA = curA.next;
            gap--;
        }
        while (curA != null) {
            if (curA == curB) {
                return curA;
            }
            curA = curA.next;
            curB = curB.next;
        }
        return null;
    }
}

分析：
时间复杂度：O(n + m)，空间复杂度：O(1)。
关于时间复杂度：得到链表长度的两个遍历操作分别需要O(n)和O(m)的时间，其中n是headA链表的长度，m是headB链表的长度。之后的交换链表时间复杂度为O(1)。移动链表A消除长度差这一个步骤，如果headA链表更长，那么将curA向前移动gap个节点。这一步骤需要O(gap)的时间，但由于gap是n和m的差，因此这一步骤的时间复杂度可以包含在O(n+m)中。最后判断是否相等，是O（lenB）的时间，lenB<n+m，所以整体的时间复杂度是由第一次遍历两个链表决定的，即O(n+m)。

142.环形链表II

题目链接：https://leetcode.cn/problems/linked-list-cycle-ii/
文档讲解：https://programmercarl.com/0142.%E7%8E%AF%E5%BD%A2%E9%93%BE%E8%A1%A8II.html#%E7%AE%97%E6%B3%95%E5%85%AC%E5%BC%80%E8%AF%BE
视频讲解：https://www.bilibili.com/video/BV1if4y1d7ob

思路

使用快慢指针，fast一次走两格，slow一次走一格，由于fast相对于slow每次多移动一格，所以fast会先进入环转圈。如果他们能相遇，说明存在环。
明确两个指针走的步数的关系，能够得到从head到入口的长度与从相遇节点到入口的长度相等。重新定义两个指针，一个指向head，一个指向相遇结点，同时移动，相遇的地方就是入口。

代码

public class Solution {
    public ListNode detectCycle(ListNode head) {
        ListNode fast = head;
        ListNode slow = head;
        while (fast != null && fast.next != null) {
            slow = slow.next;
            fast = fast.next.next;
            if (fast == slow) {
                ListNode index1 = fast;
                ListNode index2 = head;
                while (index1 != index2) {
                    index1 = index1.next;
                    index2 = index2.next;
                }
                return index1;
            }
        }
        return null;
    }
}