详解leetcode 24.两两交换链表中的节点、19.删除链表的倒数第N个节点、160.链表相交、142.环形链表 | 代码随想录day4

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

1.问题描述

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

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

2.思路分析

（1）使用虚拟头节点

原因同上几篇文章一样，为了确保原头节点的更改方法和链表中的节点方法一样，简化代码。

（2）可移动的指针每次都要指向要改变的指针的前两位

例如： dH------> 1-----> 2 ------> 3 ------> 4 -------> 5

可移动指针 cur ，初始指向 dH ，现在我们要改变 1 指向 2 的方向，使 2 指向 1 ，1 指向 3 ， 如果使 cur 直接指向 1 ，则 无法完成 2------>1 的操作，所以 cur 必须指向 2.

（3）要提前保存 1 ， 3 的位置

如果先令 cur 指向 2 ，那么在进行 2------>1 的操作时，会找不到1 的位置，因为 cur->next 已经不指向1 了。

（4）while 中的条件  cur -> next && cur->next->next  顺序不可颠倒

在进行重复更改指针指向时，我们要确保不访问空指针，所以要保证上述条件成立，如果其中一个不成立都该立即退出循环，因为此时可能就会越界访问了。

顺序不可颠倒。因为如果 先写 2 再写 1， 如果 1 就是空指针的话，先访问 2 那势必就是越界访问了。

（5）2 的位置

在执行完 cur->next = cur->next->next; 之后，2 的位置就变成了 cur->next。所以他的下一个位置应该是 cur->next->next;

3.代码 

class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        //创建并初始化虚拟头节点
        ListNode* dummyHead = new ListNode(0);
        dummyHead->next = head;

        ListNode* cur = dummyHead;   //需要移动的指针

        while (cur->next && cur->next->next ) {
        ListNode* temp1 = cur->next, * temp2 = cur->next->next->next;   //临时保存第一个和第三个节点
        cur->next = cur->next->next;
        cur->next->next = temp1;
        temp1->next = temp2;
        cur = cur->next->next;
        }
        return dummyHead->next;
       
    }
};

二.删除链表的倒数第n个节点

1.问题描述

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

2.思路分析

利用快慢指针，找到要删除节点的前一个结点，进行删除即可

3.代码+注意事项

附代码：

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* dummyHead = new ListNode(0);
        dummyHead->next = head;
        ListNode* fast = dummyHead, * slow = dummyHead;

        n++;          ///或者这里不写
        while (n--) {
            fast = fast->next;  //先让快指针走 n+1 
        }

        while (fast) {    ///这里写成 while (fast->next)
            fast = fast->next;
            slow = slow->next;
        }

        ListNode* temp = slow->next;
        slow->next = slow->next->next;
        delete temp;
        return dummyHead->next;

    }
};

注意：

（1）快慢指针最初都指向虚拟头节点。是先让快指针走，之后再一起往后移一位。

（2）快指针要先走 n+1 步，然后在一起移动。因为我们要找的是 要删除节点的前一个结点，如果让快指针先走 n 步，最后慢指针所指向的位置就是要删除的结点，这样是没办法找到其前一个节点的，也就无法进行删除操作。

（3）当快慢指针一起走时，当快指针指向最后一个位置，然后快慢指针还要继续往下走，即慢指针还要向后移，（因为指针并不知道这是最后一位）。

（4）或者，如果不想让快指针先走 n+1 的话（不好记），就让他走 n 步 就好了，只不过判断条件改变。

先前是当 fast ！= null 时，快慢指针同时移

这里只要改成 fast-> next != null ，就好了，即让 fast 指向链表最后一个结点停止即可。

三.链表相交

1.问题描述

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

2.思路分析

简单来说，就是求两个链表交点结点的指针。这里的相交不是仅指数值相等，而是指针相等，就包括 数值相等 + 地址相等。

• 问：[4,1,8,4,5]和[5,0,1,8,4,5]的相交节点为什么不是1啊？

• 答：该题交点不是数值相等，而是指针相等！注意是指针哦！

• 假设指针P1指向[4,1,8,4,5]里的1，地址是001。

• 假设指针P2指向[5,0,1,8,4,5]里的1，地址是002。

虽然两个指针指向的节点值相同，但是地址不同，所以这并不是同一个节点，也就不是题目的交点。

而题目后给的 skipA 和 skipB 其实就是系统规定的，从这两个位置分别开始时，两链表后续节点的地址位置相等。

所以。先求出两个链表的长度，求出差值 x ，让长链表先移动 x 个单位和短链表对齐，之后就相当于，A链表（假设为长链表）从skipA开始移动，B链表（假设为短链表）从 skipB 开始移动，后续两链表的地址都一样，只要数值一样就是结点相等就是相交了。

附代码：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        ListNode* curA = headA, * curB = headB;
        int lenA = 0, lenB = 0;
        //先求两链表的长度
        while (curA) {
            lenA++;
            curA = curA->next;
        }
        while (curB) {
            lenB++;
            curB = curB->next;
        }

        //设定 A 链表永远为长链表
        curA = headA;
        curB = headB;
        if (lenB > lenA) {
            swap(lenA, lenB);
            swap(curA, curB);
        }
        int cal = lenA - lenB;

        //让 A 先移动 cal 位
        while (cal--) {
            curA = curA->next;
        }
        
        //开始逐个比较
        while (curA) {
            if (curA == curB) {
                return curA;
            }
            curA = curA->next;
            curB = curB->next;
        }
        return NULL;
    }
};

注意：

在交换 A 、B 链表时，一定要确保 curA 、curB 指向的是两个链表的头节点，否则无法完整交换，后面的使 A 链表先移动 cal 位时也会出错。

四.环形链表

1.问题描述

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

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

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

2.思路分析

（1）判断是否有环

定义 快慢指针，快指针一次移动 2 个单位，慢指针一次移动 1 个单位，如果有环，快慢指针一定会相遇。

为什么一定会相遇而不是错开呢？

因为如果有环，一定是快指针先进入环中，慢指针后进入，进入环中 ，快指针还是以 2 个单位移动，慢指针还是以 1 个单位移动 ，那么根据相对速度来说，慢指针相对于快指针是静止的，而快指针是相对于慢指针以 1 个单位移动的，也就是说，快指针在环内，以 1 个单位的速度逐渐靠近慢指针，而慢指针是不动的，所以 有环必定相遇。

（2）环的入口

假设从头结点到环形入口节点 的节点数为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，相遇点依然是环形的入口节点。

3.代码

class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        ListNode* fast = head, * slow = head;
        while (fast && fast->next) {
            fast = fast->next->next;
            slow = slow->next;
            if (fast == slow) {
                ListNode* index1 = head, * index2 = fast;
                while (index1 != index2) {
                index1 = index1->next;
                index2 = index2->next;
                }
                return index1;
            }
        }
        return NULL;
        
    }
};

---

因为开学，拖了3天才写完的day4。

继续努力下去吧！收获还是蛮多的！