代码随想录训练营打卡DAY 4 | 交换节点+删除节点+链表相交+环形链表

代码随想录训练营打卡DAY 4 | 交换节点+删除节点+链表相交+环形链表

两两交换链表中的节点

24.两两交换链表中的节点（leetcode链接）

题目描述

给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。
示例1：

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

题解

思路：用pre和p指向待交换的两个节点，为避免断链，需要保存prep的前驱，用prep保存。
由于用pre和p指向了需要交换的节点，故在交换后，pre和p指向下一节点的过程的需要判空，即循环退出的条件。

本题做法思路简单，但是笔者的处理不够好，一般情况循环退出条件应当在循环条件处写，而不是在循环体内。（见参考文档[1]）

核心代码【C++】：

ListNode* swapPairs(ListNode* head) {
    if(!head || !head->next) return head;
    // 虚头节点
    ListNode * dummyHead = new ListNode(0,head);
    // prep, pre, p 为连续的三个指针，pre与p待交换
    ListNode * prep = dummyHead;
    ListNode * pre = dummyHead->next;
    ListNode * p = pre->next;
    while (1)
    {
        // 交换pre, p
        pre->next = p->next;
        p->next = pre;
        prep->next = p;
        // prep, pre, p指向下一对需要交换的节点
        prep = pre;
        pre = prep->next;
        if(!pre) break;
        p = pre->next;
        if(!p) break;
    }
    head = dummyHead->next;
    delete dummyHead;
    return head;
}

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

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

19.删除链表的倒数第N个节点（leetcode链接）

题目描述

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

示例1：

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

提示：

• 链表中结点的数目为 sz
• 1 <= sz <= 30
• 0 <= Node.val <= 100
• 1 <= n <= sz

题解

思路：本题可使用快慢指针，快指针比慢指针快n个单位。这里为什么不是n-1个单位？为了删除倒数第n个单位，需要知道该节点的前驱，所以需要多“1”。

根据提示，我们知道不需要考虑删除的节点不存在的情况。本题如果使用虚头节点，则若删除的节点是第一个节点处理方式也和其他节点一致。但笔者没有使用虚头节点，如需见参考文档[2]。

核心代码【C++】：

ListNode* removeNthFromEnd(ListNode* head, int n) {
    // 利用快慢指针，一趟遍历完成节点的删除
    ListNode * quick = head;
    ListNode * slow = head;
    // 循环后quick比slow快n-1个单位
    for(int i = 0; i < n - 1; i++){
        // 根据提示知道删除的节点一定存在，故这里不用判空
        quick = quick->next;
    }
    // 如果使用虚头节点处理会方便一些，这里没有用虚头节点所以如果刚好删除的是第一个节点就直接返回
    if(quick->next) quick = quick->next;// quick比slow快n个单位
    else return head->next; //这里没有delete节点（偷个懒

    while (quick->next)
    {
        slow = slow->next;
        quick = quick->next;
    }
    quick = slow->next;
    slow->next = quick->next;
    delete quick;
    return head;
}

时间复杂度：O(k)，这里k为链表长度
空间复杂度：O(1)

链表相交

160.链表相交（leetcode链接）

题解

思路：将两个链表链尾对齐，可以看出，节点相同的点至少要从短链的第一个节点开始。只要两个链表都从短链起始节点开始遍历（链尾对齐），直到第一个地址相同的节点即相交节点。

注意要求返回的是节点地址（指针）相同而不是值相同的点。

核心代码【C++】：

ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
    ListNode * A = headA;
    ListNode * B = headB;
    int countA = 0, countB = 0;
    while(A){
        countA++;
        A = A->next;
    }
    while (B)
    {
        countB++;
        B = B->next;
    }
    // 保证B是长链
    if(countA > countB){
        countA = countA - countB;
        A = headB;
        B = headA;
    }
    else{
        countA = countB - countA;
        A = headA;
        B = headB;
    }
    for(int i = 0; i < countA; i++){
        B = B->next;
    }
    while (A != B)
    {
        A = A->next;
        B = B->next;
    }
    return A;
}

时间复杂度：O(m+n)，m和n为两个链表的长度
空间复杂度：O(1)

环形链表

142.环形链表II（leetcode链接）

题目描述

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

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。

不允许修改 链表。

示例1：

输入：head = [3,2,0,-4], pos = 1
输出：返回索引为 1 的链表节点
解释：链表中有一个环，其尾部连接到第二个节点。

题解

思路：很明显使用快慢指针，fast一次移动2个单位，slow一次移动一个单位。

若存在环，为什么fast一定会追上slow而不会跳过呢？
答：fast每次追slow一个单位，所以在环内不会错过慢指针

推导数学关系：（祥见参考文档[4]）
$fast=x+y+N\ast (y+z)$
$slow=x+y$ （slow为什么不用 + k*(y+z)？ 答：slow进入环的第一圈就一定会被fast追上）
由$fast=2\ast slow$ 得：$x=(N-1)\ast (y+z)+z$，考虑 $x=z$ 即可知道公式的意义

核心代码【C++】：

ListNode *detectCycle(ListNode *head) {
    // 快慢指针，fast一次移动2个单位，slow一次移动一个单位
    // 重点：fast每次追slow一个单位，所以在环内不会错过慢指针
    // fast = x + y + N * (y+z)
    // slow = x + y (这里为什么不用 + k*(y+z)是重点)
    // 由fast = 2 * slow得：x = (N-1)*(y+z) + z, 考虑x = z即可知道公式的意义
    ListNode * fast = head;
    ListNode * slow = head;
    while (fast && fast->next)
    {
        fast = fast->next->next;
        slow = slow->next;
        if(slow == fast){
            slow = head;
            while(slow != fast){
                slow = slow->next;
                fast = fast->next;
            }
            return fast;
        }
    }
    return NULL;
}

时间复杂度：O(n)，快慢指针相遇前，slow走的长度<n，快慢指针相遇后，从头节点到环的入口长度<n，故整体<2n。
空间复杂度：O(1)

参考文档

1. 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
2. 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
3. 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
   .%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
4. 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
5. https://programmercarl.com/0142.%E7%8E%AF%E5%BD%A2%E9%93%BE%E8%A1%A8II.html