（第7天）【leetcode题解】19、删除链表的倒数第n个节点 面试题02.07.链表相交 142、环形链表II

19、删除链表的倒数第n个节点

题目描述

给你一个链表，删除链表的倒数第 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]

思路

有两个重点

1. 怎样根据n找到要删除的节点。
2. 找到要删除的节点之后要怎么删除。

代码

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* dummyHead = new ListNode(0);//创建虚拟头节点
        dummyHead->next = head;//虚拟头节点指向head
        ListNode* fast = dummyHead;//fast指针指向虚拟头节点，从虚拟头结点开始出发
        ListNode* slow = dummyHead;//slow指针指向虚拟头节点，从虚拟头节点出发

        //先移动fast指针
        while (n-- && fast!= NULL) {
            fast = fast->next;//把fast向前移动n步
        }
        fast = fast->next;//再把fast向前移动一步

        //fast、slow开始同时移动，最终slow指向的节点就是要删除节点的上一个节点
        while (fast != NULL) {
            fast = fast->next;
            slow = slow->next;
        }

        //删除指定节点
        ListNode *tmp = slow->next;
        slow->next = tmp->next;
        delete tmp;
        // slow->next = slow->next->next;

        return dummyHead->next;
    }
};

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

面试题02.07. 链表相交

题目描述

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

思路

分两种情况。

1. 两个单链表相交。设置两个指针同时从headA和headB开始走，两个指针移动的累计距离始终相等。当指针走到当前链表的末尾时，指向另一条链表的开头。当两个指针累计移动的长度等于上一条链表的长度+当前链表没有相交之前的长度时，两个指针相交，此时指针指向的就是相交链表的头节点
2. 两个单链表不相交。仍然设置两个指针从headA和headB同时开始移动，移动到链表末尾时指向另一条链表的开头。当两个指针累计移动的长度等于两条链表的长度之和时，都指向null，此时认为链表相交，返回null。

代码

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        ListNode *p = headA, *q = headB;//设置两个指针，初始位置分别为headA和headB
        while (p != q) {
            p = p ? p->next : headB;//如果p不空的话，就把p移到它的下一个节点；否则移到另一条链表的头节点
            q = q ? q->next : headA;//如果q不空的话，把q移到它的下一个节点；否则移到另一条链表的头节点
        }
        return p;
    }
};

142、环形链表II

题目描述

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

思路

1. 判断是否有环：设置fast和slow双指针，fast一次走两步、slow一次走一步。如果有环，fast和slow一定会（在环中）相遇。
2. 找到环的入口（已经判断有环）：

• 设从head到环形入口为x，从环形入口到相遇位置距离为y，从相遇位置再到环形入口距离为z。
• 从开始到相遇，fast移动：x+y+(y+z)；slow移动：x+y。
• 又因为，fast移动距离一定是slow的两倍，得出：2(x+y)=x+y+(y+z)。化简得：x=(n-1)(y+z)+z。（n>=1）。
• 当n=1时，x=z，也就是说，从相遇点到环形入口的距离等于从链表头到环形入口的距离。这时，两个指针分别从链表头和相遇点出发，一定会在环形入口相遇。
• n>1时，同理，两指针也会在环形入口相遇，只不过从相遇点出发的指针会在环形中多绕几圈。

代码

class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        ListNode *fast = head, *slow = head;//设置快慢指针
        //有环
        while (fast != NULL && fast->next != NULL) {
            slow = slow->next;//慢指针每次移动一位
            fast = fast->next->next;//快指针每次移动两位
            //快慢指针相遇
            if (fast == slow) {
                //设置两个指针同时从head和相遇点出发
                ListNode *index1 = head;
                ListNode *index2 = fast;
                //出发
                while (index1 != index2) {
                    index1 = index1->next;
                    index2 = index2->next;
                }
                return index2;//返回环的入口
            }
        }
        //无环
        return NULL;
    }
};

• 时间复杂度：O(n)。判断是否有环的过程中，两个指针的移动次数(slow的移动距离)不会超过链表的长度，最大操作次数不会超过n；在寻找环形入口的过程中，指针的移动距离不会超过链表的长度，最大操作次数不会超过n。总体操作次数不会超过2n。
• 空间复杂度：O(1)。操作过程中不会额外开辟存储链表的空间。

疑点分析

1.为什么不会出现每次fast跳过slow的情况呢？

在环中，fast每次移动两个节点，slow每次移动一个节点，那么就可以把这个过程认为是fast相对于slow一次移动一个节点，所以不会跳过去。

2.为什么第一次在环中相遇slow的步数不是x+若干倍环的长度+y而是x+y？

• 首先，slow进环的时候fast一定已经在环中的某个地方。
• 设环的长度为n。
• 考虑极端情况，fast刚在入口处出发，slow就进入了入口。（此时为fast需要遇到slow所需走过的最大距离）
• 当slow下次走到环入口时，在环中走过的距离为n，而这时，fast已经走了2n，在这期间，fast一定会遇到slow。