代码随想录算法训练营第四天：链表的深度探索

今天的第一道题目是：

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

力扣题目链接(opens new window)

给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。

你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。

​​

#算法公开课

《代码随想录》算法视频公开课 ****(opens new window)****​ ：​帮你把链表细节学清楚！ | LeetCode：24. 两两交换链表中的节点 ****(opens new window)****​ ，相信结合视频再看本篇题解，更有助于大家对本题的理解。

关于本题其实就是改变next指针指向，和翻转链表异曲同工，这里要注意指向的顺序，避免指针被要不然每次针对头结点（没有前一个指针指向头结点），还要单独处理。覆盖，建议本题依旧使用虚拟头结点，这样会方便很多，

要不然每次针对头结点（没有前一个指针指向头结点），还要单独处理。

交换相邻两个元素了，此时一定要画图，不画图，操作多个指针很容易乱，而且要操作的先后顺序

初始时，cur指向虚拟头结点，然后进行如下三步：

​​

操作之后，链表如下：

​​

看这个可能就更直观一些了：

​​

其实就是，因为我们要交换，所以从头来将，先让cur指向交换后的下一节点，也就是2，然后2要指向下一节点，也就是1，最后让1指向3，交换完毕，指针移动两位，继续操作，

class Solution {
public:
    ListNode* swapPairs(ListNode* head){
        ListNode* dummyHead = new ListNode(-1);
        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->next->next = tmp;
            cur->next->next->next = tmp1;//最后一个next是指针，前面指的是节点；
            //这里保存两个临时变量是为了防止cur->next->next->next被覆盖
            cur = cur->next->next;
        }
        ListNode* result = dummyHead ->next;
        delete dummyHead;
        return result;
    }
};

其他语言版本

#C:

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
//递归版本
struct ListNode* swapPairs(struct ListNode* head){
    //递归结束条件：头节点不存在或头节点的下一个节点不存在。此时不需要交换，直接返回head
    if(!head || !head->next)
        return head;
    //创建一个节点指针类型保存头结点下一个节点
    struct ListNode *newHead = head->next;
    //更改头结点+2位节点后的值，并将头结点的next指针指向这个更改过的list
    head->next = swapPairs(newHead->next);
    //将新的头结点的next指针指向老的头节点
    newHead->next = head;
    return newHead;
}

//迭代版本
struct ListNode* swapPairs(struct ListNode* head){
    //使用双指针避免使用中间变量
    typedef struct ListNode ListNode;
    ListNode *fakehead = (ListNode *)malloc(sizeof(ListNode));
    fakehead->next = head;
    ListNode* right = fakehead->next;
    ListNode* left = fakehead;
    while(left && right && right->next ){
        left->next = right->next;
        right->next = left->next->next;
        left->next->next = right;
        left = right;
        right = left->next;
    }
    return fakehead->next;
}

下一题是删除链表相关的题目：

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

力扣题目链接(opens new window)

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

进阶：你能尝试使用一趟扫描实现吗？

示例 1：

​​

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

输入：head = [1], n = 1 输出：[] 示例 3：

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

#算法公开课

《代码随想录》算法视频公开课 ****(opens new window)****​ ：：​链表遍历学清楚！ | LeetCode：19.删除链表倒数第N个节点 ****(opens new window)****​ ，相信结合视频再看本篇题解，更有助于大家对链表的理解。

对于这道题是一道经典的双指针应用，题目的解法思路是，设立两个指针，一个为快指针，一个为慢指针，

如果要删除倒数第n个节点，让fast移动n+1步，然后让fast和slow同时移动，直到fast指向链表末尾。删掉slow所指向的节点就可以了。

如图：

​​

• fast首先走n + 1步 ，为什么是n+1呢，因为只有这样同时移动的时候slow才能指向删除节点的上一个节点（方便做删除操作），如图： ​
• fast和slow同时移动，直到fast指向末尾，如题： ​
• 删除slow指向的下一个节点，如图： ​

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

C：

/**c语言单链表的定义
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* removeNthFromEnd(struct ListNode* head, int n) {
    //定义虚拟头节点dummy 并初始化使其指向head
    struct ListNode* dummy = malloc(sizeof(struct ListNode));
    dummy->val = 0;
    dummy->next = head;
    //定义 fast slow 双指针
    struct ListNode* fast = head;
    struct ListNode* slow = dummy;

    for (int i = 0; i < n; ++i) {
        fast = fast->next;
    }
    while (fast) {
        fast = fast->next;
        slow = slow->next;
    }
    slow->next = slow->next->next;//删除倒数第n个节点
    head = dummy->next;
    free(dummy);//删除虚拟节点dummy
    return head;
}

第三题是一道面试题：

面试题 02.07. 链表相交

同：160.链表相交

力扣题目链接(opens new window)

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

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

​​

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

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

示例 1：

​​

示例 2：

​​

示例 3：

​​

对于这道题，我首先想到的就是先遍历一个链表，将值存入哈希表中，再遍历另一个链表去哈希表中查找，如果有对应的值，那么就是相交节点（大香蕉，一根大香蕉，你的感觉真的很奇妙~飘呀飘，摇啊摇……）

方法一：哈希集合

思路和算法

判断两个链表是否相交，可以使用哈希集合存储链表节点。

首先遍历链表 headA\textit{headA} headA，并将链表 headA\textit{headA} headA 中的每个节点加入哈希集合中。然后遍历链表 headB\textit{headB} headB，对于遍历到的每个节点，判断该节点是否在哈希集合中：

• 如果当前节点不在哈希集合中，则继续遍历下一个节点；
• 如果当前节点在哈希集合中，则后面的节点都在哈希集合中，即从当前节点开始的所有节点都在两个链表的相交部分，因此在链表 headB\textit{headB} headB 中遍历到的第一个在哈希集合中的节点就是两个链表相交的节点，返回该节点。

如果链表 headB\textit{headB} headB 中的所有节点都不在哈希集合中，则两个链表不相交，返回 null\text{null} null。

class Solution{
public:
    ListNode *getIntersectionNode(ListNode *headA,ListNode * head){
        unordered_set<ListNode *> visited;
        ListNode *temp = headA;
        while (temp != nullptr){
            visited.insert(temp);
            temp = temp->next;
        }
        temp = headB;
        while(temp != nullptr){
            if (visited.count(temp)){
                return temp;
            }
            temp = temp->next;
        }
        return nullptr;
    }
};

这里carl的双指针思路很巧妙：

思路

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

为了方便举例，假设节点元素数值相等，则节点指针相等。

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

​​

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

​​

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

否则循环退出返回空指针。

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 (lenA < lenB)
            swap(lenA,lenB);
            swap(curA,curB);// 让curA为最长链表的头，lenA为其长度
    }
    int gap = len A -len B;
    while (gap--){
        curA = curA->next;
    }
    while (curA != NULL){
        if (curA == curB){
            return curA;
        }
        curA = curA->next;
        curB = curB->next;
    }
    return NULL;
}

这里双指针还有一种写法，比较难以理解，我来讲解一下我的想法：

因为链表长度有两种情况，如果链表长度相同。我们直接遍历两个链表，找到相同节点或者指向null，返回得到的结果即可；那么当链表长度不相同又怎么理解呢，上述方法是将短链表位移到与长链表相同长度，其实还有一种想法，让两个链表相加形成一条长链表，这样链表长度就统一了，那么如果两个链表有相同的节点，那么后面的节点必定相同，指针分别从长链表和短链表同时出发，遍历完自身链表后遍历对方链表，此时路程一样，相遇到的相交节点也应在同时同刻，若没有相同节点就同时到达尾结点返回null:

如链表A+链表B=链表C1

链表B+链表A=链表C2

A -> a1 a2 c1 c2 c3​

B -> b1 b2 b3 c1 c2 c3​

C1 -> a1 a2 c1 c2 c3 b1 b2 b3 c1 c2 c3​

C2 -> b1 b2 b3 c1 c2 c3 a1 a2 c1 c2 c3​

此时C1和C2的长度一定相同。 而C1和C2的结尾就一定是相交的链表。

leetcode官方讲解是这样的：

思路和算法

使用双指针的方法，可以将空间复杂度降至 O(1)O(1) O ( 1 ) 。

只有当链表 headA\textit{headA} headA 和 headB\textit{headB} headB 都不为空时，两个链表才可能相交。因此首先判断链表 headA\textit{headA} headA 和 headB\textit{headB} headB 是否为空，如果其中至少有一个链表为空，则两个链表一定不相交，返回 null\text{null} null。

当链表 headA\textit{headA} headA 和 headB\textit{headB} headB 都不为空时，创建两个指针 pA\textit{pA} pA 和 pB\textit{pB} pB，初始时分别指向两个链表的头节点 headA\textit{headA} headA 和 headB\textit{headB} headB，然后将两个指针依次遍历两个链表的每个节点。具体做法如下：

• 每步操作需要同时更新指针 pA\textit{pA} pA 和 pB\textit{pB} pB。
• 如果指针 pA\textit{pA} pA 不为空，则将指针 pA\textit{pA} pA 移到下一个节点；如果指针 pB\textit{pB} pB 不为空，则将指针 pB\textit{pB} pB 移到下一个节点。
• 如果指针 pA\textit{pA} pA 为空，则将指针 pA\textit{pA} pA 移到链表 headB\textit{headB} headB 的头节点；如果指针 pB\textit{pB} pB 为空，则将指针 pB\textit{pB} pB 移到链表 headA\textit{headA} headA 的头节点。
• 当指针 pA\textit{pA} pA 和 pB\textit{pB} pB 指向同一个节点或者都为空时，返回它们指向的节点或者 null\text{null} null。

证明

下面提供双指针方法的正确性证明。考虑两种情况，第一种情况是两个链表相交，第二种情况是两个链表不相交。

情况一：两个链表相交

链表 headA\textit{headA} headA 和 headB\textit{headB} headB 的长度分别是 mmm 和 nnn。假设链表 headA\textit{headA} headA 的不相交部分有 aaa 个节点，链表 headB\textit{headB} headB 的不相交部分有 bbb 个节点，两个链表相交的部分有 ccc 个节点，则有 a+c=ma+c=ma + c = m，b+c=nb+c=nb + c = n。

• 如果 a=ba=ba = b，则两个指针会同时到达两个链表相交的节点，此时返回相交的节点；
• 如果 a≠ba \ne ba=b，则指针 pA\textit{pA} pA 会遍历完链表 headA\textit{headA} headA，指针 pB\textit{pB} pB 会遍历完链表 headB\textit{headB} headB，两个指针不会同时到达链表的尾节点，然后指针 pA\textit{pA} pA 移到链表 headB\textit{headB} headB 的头节点，指针 pB\textit{pB} pB 移到链表 headA\textit{headA} headA 的头节点，然后两个指针继续移动，在指针 pA\textit{pA} pA 移动了 a+c+ba+c+ba + c + b 次、指针 pB\textit{pB} pB 移动了 b+c+ab+c+ab + c + a 次之后，两个指针会同时到达两个链表相交的节点，该节点也是两个指针第一次同时指向的节点，此时返回相交的节点。

情况二：两个链表不相交

链表 headA\textit{headA} headA 和 headB\textit{headB} headB 的长度分别是 mmm 和 nnn。考虑当 m=nm=nm = n 和 m≠nm \ne nm=n 时，两个指针分别会如何移动：

• 如果 m=nm=nm = n，则两个指针会同时到达两个链表的尾节点，然后同时变成空值 null\text{null} null，此时返回 null\text{null} null；
• 如果 m≠nm \ne nm=n，则由于两个链表没有公共节点，两个指针也不会同时到达两个链表的尾节点，因此两个指针都会遍历完两个链表，在指针 pA\textit{pA} pA 移动了 m+nm+nm + n 次、指针 pB\textit{pB} pB 移动了 n+mn+mn + m 次之后，两个指针会同时变成空值 null\text{null} null，此时返回 null\text{null} null。

class Solution{
public:
    ListNode *getIntersectionNode(ListNode *headA,ListNode *headB){
        if (headA == nullptr || headB == nullptr){
            return nullptr;
        }
        ListNode *pA = headA,*pB = headB;
        while (pA != pB){
            pA = pA == nullptr ? headB : pA->next;
            pB = pB == nullptr ? headA : pB->next;
        }
        return PA;
    }
};

这样思路虽然有点绕，但是代码简洁性时间复杂度都提升了！！！

‍

‍

最后一题是找环形链表：

142.环形链表II

力扣题目链接(opens new window)

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

为了表示给定链表中的环，使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。

说明：不允许修改给定的链表。

​​

#算法公开课

《代码随想录》算法视频公开课 ****(opens new window)****​ ：​把环形链表讲清楚！| LeetCode:142.环形链表II ****(opens new window)****​ ，相信结合视频在看本篇题解，更有助于大家对链表的理解。

这道题是比较考验数学逻辑的

思路

这道题目，不仅考察对链表的操作，而且还需要一些数学运算。

主要考察两知识点：

• 判断链表是否环

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

  
  ​​

#判断链表是否有环

方法1:
首先从头节点开始，依次遍历单链表中的每- -个节点。每遍历一个新节点，就从头检查新节点之前的所有节点，用新节点和此节点之前所有节点依次做比较。如果发现新节点和之前的某个节点相同，则说明该节点被遍历过两次，链表有环;如果之前的所有节点中不存在与新节点相同的节点，就继续遍历下一个新节点，继续重复刚才的操作。

​
​

就像图中这样，当遍历链表节点7时，从头访问节点5和节点3，发现已遍历的节点中并不存在节点7，则继续往下遍历。当第2次遍历到节点2时，从头访问曾经遍历过的节点，发现已经遍历过节点2，说明链表有环。
假设链表的节点数量为n，则该解法的时间复杂度是0(n2)。由于并没有创建额外的存储空间，所以空间复杂度是0(1)。

方法2:
首先创建一个以节点ID为Key的HashSet集合，用来存储曾经遍历过的节点。然后同样从头节点开始，依次遍历单链表中的每一个节点。每遍历一个新节点，都用新节点和HashSet集合中存储的节点进行比较，如果发现HashSet中存在与之相同的节点ID，则说明链表有环，如HashSet中不存在与新节点相同的节点ID,就把这个新节点ID存入
HashSet中，之后进入下一节点，继续重复刚才的操作。
​
​

遍历过5、3、7、2、6、8、1。

​​

当再一.次遍历节点2时，查找HashSet, 发现节点已存在。

​

由此可知，链表有环。
这个方法在流程。上和方法1类似，本质的区别是使用了HashSet作为额外的缓存。
假设链表的节点数量为n，则该解法的时间复杂度是0(n)。由于使用了额外的存储空间，所以算法的空间复杂度同样是0(n)。

这里其实还可以用到双指针的方法，

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

为什么fast 走两个节点，slow走一个节点，有环的话，一定会在环内相遇呢，而不是永远的错开呢

首先第一点：fast指针一定先进入环中，如果fast指针和slow指针相遇的话，一定是在环中相遇，这是毋庸置疑的。

那么来看一下，为什么fast指针和slow指针一定会相遇呢？

可以画一个环，然后让 fast指针在任意一个节点开始追赶slow指针。

会发现最终都是这种情况， 如下图：

​​

fast和slow各自再走一步， fast和slow就相遇了

这是因为fast是走两步，slow是走一步，其实相对于slow来说，fast是一个节点一个节点的靠近slow的，所以fast一定可以和slow重合。

动画如下：

​​

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

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

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

​​

那么相遇时： slow指针走过的节点数为: x + y​， fast指针走过的节点数：x + y + n (y + z)​，n为fast指针在环内走了n圈才遇到slow指针， （y+z）为 一圈内节点的个数A。

因为fast指针是一步走两个节点，slow指针一步走一个节点， 所以 fast指针走过的节点数 = slow指针走过的节点数 * 2：

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

两边消掉一个（x+y）: x + y = n (y + z)​

因为要找环形的入口，那么要求的是x，因为x表示 头结点到 环形入口节点的的距离。

所以要求x ，将x单独放在左面：x = n (y + z) - y​ ,

再从n(y+z)中提出一个 （y+z）来，整理公式之后为如下公式：x = (n - 1) (y + z) + z​ 注意这里n一定是大于等于1的，因为 fast指针至少要多走一圈才能相遇slow指针。

这个公式说明什么呢？

先拿n为1的情况来举例，意味着fast指针在环形里转了一圈之后，就遇到了 slow指针了。

当 n为1的时候，公式就化解为 x = z​，

这就意味着，从头结点出发一个指针，从相遇节点 也出发一个指针，这两个指针每次只走一个节点， 那么当这两个指针相遇的时候就是 环形入口的节点。

也就是在相遇节点处，定义一个指针index1，在头结点处定一个指针index2。

让index1和index2同时移动，每次移动一个节点， 那么他们相遇的地方就是 环形入口的节点。

动画如下：

​​

那么 n如果大于1是什么情况呢，就是fast指针在环形转n圈之后才遇到 slow指针。

其实这种情况和n为1的时候 效果是一样的，一样可以通过这个方法找到 环形的入口节点，只不过，index1 指针在环里 多转了(n-1)圈，然后再遇到index2，相遇点依然是环形的入口节点。

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

补充

在推理过程中，大家可能有一个疑问就是：为什么第一次在环中相遇，slow的 步数 是 x+y 而不是 x + 若干环的长度 + y 呢？

即文章链表：环找到了，那入口呢？ ​**(opens new window)** 中如下的地方：

​​

首先slow进环的时候，fast一定是先进环来了。

如果slow进环入口，fast也在环入口，那么把这个环展开成直线，就是如下图的样子：

​​

可以看出如果slow 和 fast同时在环入口开始走，一定会在环入口3相遇，slow走了一圈，fast走了两圈。

重点来了，slow进环的时候，fast一定是在环的任意一个位置，如图：

​​

那么fast指针走到环入口3的时候，已经走了k + n 个节点，slow相应的应该走了(k + n) / 2 个节点。

因为k是小于n的（图中可以看出），所以(k + n) / 2 一定小于n。

也就是说slow一定没有走到环入口3，而fast已经到环入口3了。

这说明什么呢？

在slow开始走的那一环已经和fast相遇了。

那有同学又说了，为什么fast不能跳过去呢？ 在刚刚已经说过一次了，fast相对于slow是一次移动一个节点，所以不可能跳过去。

好了，这次把为什么第一次在环中相遇，slow的 步数 是 x+y 而不是 x + 若干环的长度 + y ，用数学推理了一下，算是对链表：环找到了，那入口呢？ ​**(opens new window)** 的补充。

C：

ListNode *detectCycle(ListNode *head) {
    ListNode *fast = head, *slow = head;
    while (fast && fast->next) {
        // 这里判断两个指针是否相等，所以移位操作放在前面
        slow = slow->next;
        fast = fast->next->next;
        if (slow == fast) { // 相交，开始找环形入口：分别从头部和从交点出发，找到相遇的点就是环形入口
            ListNode *f = fast, *h = head;
            while (f != h) f = f->next, h = h->next;
            return h;
        }
    }
    return NULL;
}

总结

​​

考察链表的操作其实就是考察指针的操作，是面试中的常见类型。

链表篇中开头介绍链表理论知识 ​**(opens new window)** ，然后分别通过经典题目介绍了如下知识点：

1. 关于链表，你该了解这些！(opens new window)
2. 虚拟头结点的技巧(opens new window)
3. 链表的增删改查(opens new window)
4. 反转一个链表(opens new window)
5. 删除倒数第N个节点(opens new window)
6. 链表相交(opens new window)
7. 有否环形，以及环的入口

‍😊