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

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

题目

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

示例：

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

提示：

• 链表中结点的数目在范围 [0, 100] 内

• 0 <= Node.val <= 100

思路

使用虚拟头结点的方式（就不需要分类是不是头结点的情况了）

奇数结点最后不做处理，偶数结点刚好两两交换完

• 交换相邻两个元素

  • 初始时，cur 指向虚拟头结点

    • 

  • 操作后，链表如图

    • 

  • 整体情况

    • 

  • cur 指针一定要指向翻转两个结点的前一个结点，

代码实现

• dummyhead->next = head

• cur = dummyhead

• while 遍历：

  • 循环结束条件
    • 如果结点数为偶数，cur->next = NULL 结束
    • 如果结点数为奇数，cur->next->next = NULL 结束
    • 直接写while(cur->next != NULL && cur->next->next != NULL)
      • 注意顺序，如果 cur->next 为空，又先判断 && 后面的，会发生空指针异常
  • temp = cur->next（保留结点 1，服务于步骤二）
  • temp1 = cur->next->next->next（保留结点 3，服务于步骤三）
  • cur->next = cur->next->next（步骤一）
  • cur->next（此时是结点 2）->next = temp（步骤二）
  • temp->next = temp1（步骤三）
  • cur - cur->next->next（移动 cur 指针）

• return dummyhead->next（返回头结点）

class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        ListNode* dummyHead = new ListNode(0);
        dummyHead->next = head;
        ListNode* cur = dummyHead;
        while(cur->next != nullptr && cur->next->next != nullptr){
            ListNode* tmp = cur->next;
            ListNode* tmp1 = cur->next->next->next;

            cur->next = cur->next->next;//cur 的下一个指向结点2
            cur->next->next = tmp;//此时 cur 指向结点2，结点2 指向 tmp（结点1） 
            tmp->next = tmp1;//结点1 指向结点3（tmp1）

            cur = cur->next->next;
        }
        return dummyHead->next;
    }
};

• 时间复杂度：O(n)

• 空间复杂度：O(1)

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

题目

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

示例：

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

提示：

• 链表中结点的数目为 sz

• 1 <= sz <= 30

• 0 <= Node.val <= 100

• 1 <= n <= sz

思路

同样是用虚拟头结点的方式，不需要特殊判断

定义快慢两个指针，快指针先移动 n+1 步，慢指针再跟着快指针同时移动。

n+1 原因：要让慢指针先指向倒数第 n 个结点的上一个结点，才能对倒数第 n 个结点进行删除操作

当快指针指向 NULL 的时候，慢指针指向的就是倒数第 n+1 个结点

代码实现

1. new dummyhead

2. 快指针 fast、慢指针 slow 指向 dummyhead

3. n+1

4. while，走 n 步同时快指针不为空时，fast = fast->next;

5. while 快指针不为空，快指针往后走，慢指针也往后走

6. slow->next = slow->next->next

7. return dummyhead->next

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* dummyHead = new ListNode(0);
        dummyHead->next = head;
        ListNode* fast = dummyHead;
        ListNode* slow = dummyHead;
        n++;
        while(n-- && fast != NULL){
            fast = fast->next;
        }
        while(fast != NULL){
            fast = fast->next;
            slow = slow->next;
        }
        slow->next = slow->next->next;
        return dummyHead->next;
    }
};

面试题 02.07. 链表相交

题目

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

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

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

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

示例：

输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3
输出：Intersected at '8'
解释：相交节点的值为 8 （注意，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,0,1,8,4,5]。
在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。

思路

求两个链表交点结点的指针，注意：交点不是数值相等，而是指针相等

假设结点元素数值相等，则结点指针相等

如图链表，curA 指向链表 A 头结点，curB 指向链表 B 的头结点

求出两链表长度，再求出长度差值，如何让 curA 移动到与 curB 末尾对齐的位置

比较 curA 和 curB 是否相同，若不同，同时向后移动 curA 和 curB，如果遇到 curA==curB，则找到交点

否则循环退出返回空指针

代码实现

1. new 指针 cur A 指向 headA，指针 curB 指向 headB
2. 初始化 lenA, lenB 为 0
3. while分别遍历 AB，求长度
4. 重新：cur A 指向 headA，指针 curB 指向 headB
5. 让 curA 为最长链表的头，lenA 为其长度
   1. 如果 lenB > lenA， swap len 和 cur
6. 求长度差 gap
7. while gap–，让 curA 和 curB 在同一起点
8. while curA != NULL 遍历 curA 和 curB，遇到相同则返回
9. return NULL

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){
            swap(lenA, lenB);
            swap(curA, curB);
        }
        int gap = lenA - lenB;
        while(gap--){
            curA = curA->next;
        }
        while(curA != NULL){
            if(curA == curB){
                return curA;
            }
            curA = curA->next;
            curB = curB->next;
        }
        return NULL;
    }
};

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

• 空间复杂度：O(1)

142.环形链表II

题目

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

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

不允许修改 链表。

示例：

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

提示：

• 链表中节点的数目范围在范围 [0, 10(4)] 内

• -10(5) <= Node.val <= 10(5)

• pos 的值为 -1 或者链表中的一个有效索引

思路

1. 判断链表是否有环

2. 找到环的入口

判断链表是否有环

双指针，快慢指针相遇就有环

快指针从起点除非，每次走两个结点；慢指针从起点出发，每次都一个结点

如果快慢指针相遇，说明链表有环

在环内，相当于快指针每次以一个结点的速度靠近慢指针，所以只要有环，就一定会相遇

找到环的入口

从头结点到入口设 x，入口到相遇结点设为 y，相遇结点再回到入口设为 z

$$slow=x+y$$

$$$fast=x+y+n(y+z)$$代表快指针可能已经在循环里走了 n 圈

因为快指针每次走两个结点，慢指针每次走一个结点

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

$$x+y=n(y+z)$$

$$x=n(y+z)-y$$

n 至少大于等于 1，因为快指针一定是在环里追了一圈才追到慢指针： $$x=(n-1)(y+z)+z$$

如果 n=1：

$$x=z$$

说明快指针在相遇结点，慢指针在头结点，最后在入口结点相遇

所以得到两指针相遇处时，记录位置 index1，再让index2 从头开始走，相遇的时候就是入口

代码实现

1. 定义快、慢指针指向 head
2. while 当快指针不为空，快指针的指向不为空（因为快指针一次走两个结点，所以要快一点）
   1. 快指针一次跳两步，慢指针一次一步
   2. 如果快慢指针相遇了，说明找到了环
      1. 定义 index1 = fast
      2. 定义 index2 = head
      3. while index1!=index2，index1 和 2 一直往后走
      4. return index
3. return NULL

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* index1 = fast;
                ListNode* index2 = head;
                while(index1!=index2){
                    index1 = index1->next;
                    index2 = index2->next;
                }
                return index1;
            }
        }
        return NULL;
    }
};

链表总结

链表其实想清楚了难度还好，但是写代码实现的过程中总会有一些细小的点会遗漏。

理论

明确链表的结构

移除链表元素

指针一定指向要移除元素的上一个结点，才能移除

设计链表

这一部分要细心，很容易有细节遗漏。

添加链表结点的时候，一定要知道操作结点的前一个结点的指针，才能进行一个插入结点的操作

而且要先更新如图 F->D 再 C->F

反转链表

双指针遍历，不断往回指

两两交换链表中结点

注意结点单双数区别，

cur 要指向翻转两个结点的前一个结点

删除到处第 N 个元素

快慢指针遍历，快的先走 N 步，到快的指向 NULL，慢的指的就是倒数第 N 个

但因为是删除操作，所以慢指针最后要指向倒数 N 个的前一个

链表相交

分别求长度，尾部并齐后开始遍历是否相等

环形链表

判断是否有环：双指针，快的走两步，慢的走一步，最终相遇就有环

找到环的入口：找到相遇位置，定义两个新的指针，一个指向相遇位置，一个指向 head，继续遍历，最后相遇位置是入口。