您现在的位置是：首页 >学无止境 >代码随想录第四天|LeetCode24. 两两交换链表中的节点，LeetCode19.删除链表的倒数第N个节点,LeetCode面试题 02.07. 链表相交,LeetCode142.环形链表II网站首页学无止境

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

题目链接：24. 两两交换链表中的节点 - 力扣（LeetCode）

思路：

先定义一个虚拟头结点方便操作。

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

初始时，cur指向虚拟头结点，然后进行如下三步（比较懒直接用Carl哥图了HH）：

 直观一点：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        ListNode* dummyhead = new ListNode(0);
        dummyhead->next = head;
        ListNode* cur = dummyhead;
        //两个都不为空时执行交换
        while(cur->next != NULL && cur->next->next != NULL) {
            //两个临时节点存储第二个交换数字的前后两个数字
            ListNode* temp = cur->next;
            ListNode* tmp = cur->next->next->next;
            cur->next = cur->next->next;//第一步让头结点的下一个指针指向第二个交换数字
            cur->next->next = temp;//第二步让第二个交换数字的指针指向第一个交换数字（已经临时存储了，不然第一个数字丢失了）
            cur->next->next->next = tmp;//第三步让此时的第一个交换数字（现在在第二个）的指针指向第三个数字
            cur = cur->next->next;//将执行结点移动两位进行下一轮交换
        }
        return dummyhead->next;
    }
};

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

题目链接：​​​​​​19. 删除链表的倒数第 N 个结点 - 力扣（LeetCode）

思路：

本人的思路是设置一个虚拟头结点在头结点前面遍历一遍得出链表长度再减去输入的数字，再遍历一遍后直接将倒数第n+1个结点接在第n-1个结点后面，是可行的。（跟Carl哥双指针差不多思路）

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* dummyhead = new ListNode(0);
        int x = 0;
        dummyhead->next = head;
        ListNode* cur = dummyhead;
        //设置一个虚拟头结点在头结点前面遍历一遍得出链表长度再减去输入的数字
        while(cur->next != NULL) {
            cur = cur->next;
            x++;
        }
        ListNode* cur1 = dummyhead;
        int m = x - n;
        //再遍历一遍后直接将倒数第n+1个结点接在第n-1个结点后面
        while(m != 0) {
            cur1 = cur1->next;
            m--;
        }
        cur1->next = cur1->next->next;
        return dummyhead->next;
    }
};

Carl哥思路：

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

思路是这样的，但要注意一些细节。

分为如下几步：

• 首先这里我推荐大家使用虚拟头结点，这样方便处理删除实际头结点的逻辑。

• 定义fast指针和slow指针，初始值为虚拟头结点。

• fast首先走n + 1步 ，为什么是n+1呢，因为只有这样同时移动的时候slow才能指向删除节点的上一个节点（方便做删除操作）。

• fast和slow同时移动，直到fast指向末尾。

• 删除slow指向的下一个节点。

LeetCode160.链表相交

题目链接：面试题 02.07. 链表相交 - 力扣（LeetCode）

 思路：

该题目就是求两个链表交点节点的指针。 但要注意：交点不是数值相等，而是指针相等。

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

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

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

/**
 * 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) {
        int a = 0,b = 0;
        ListNode* cur1 = headA;
        ListNode* cur2 = headB;
        //遍历链表A和链表B,注意此时指针直接指向头结点，无虚拟头结点，也就是指向第一个结点，因此不能用cur->next,否则会在NULL时继续指向下一个而报错
        while(cur1 != NULL) {
            cur1 = cur1->next;
            a++;
        }
        while(cur2 != NULL) {
            cur2 = cur2->next;
            b++;
        }
        //重置cur1,cur2的起始位置
        cur1 = headA;
        cur2 = headB;
        // 让cur1为最长链表的头，a为其长度
        if(b > a) {
            swap(a,b);
            swap(cur1,cur2);
        }
        //长度差
        int  x = a -b;
        //链表a,b对齐
        while(x--) {
            cur1 = cur1->next;
        }
        while(cur1 != NULL) {
            if(cur1 == cur2) {
                return cur1;
            }
            cur1 = cur1->next;
            cur2 = cur2->next;
        }
        return NULL;
    }
};

 LeetCode142.环形链表II

题目链接：142. 环形链表 II - 力扣（LeetCode）

思路：

1.判断链表是否有环

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

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

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

fast指针和slow指针一定会相遇。

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

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

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时，与极端情况一样，不过index1是走了n-1圈后与index2相遇。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
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;
            //快慢指针相遇，此时从head和相遇点开始查找，直到相遇
            if(slow == fast) {
                ListNode* index1 = fast;
                ListNode* index2 = head;
                while(index1 != index2) {
                    index1 = index1->next;
                    index2 = index2->next;
                }
                return index2;//返回环的入口
            }
        }
        return NULL;
    }
};