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

代码随想录刷题第四天

交换两两节点 (LC 24)

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

示例：

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

• 两两交换节点，在交换之前现在链表前面增加一个dummyhead, cur指向更换节点前的一个节点(更换前两个节点是cur指向dummyhead).
• 随后，使用三个变量先储存后续的三个节点指针：t1 = cur.next.next.next , t2 = cur.next.next, t3 = cur.next.
• 之后重构这几个节点直接的关系，cur.next = t2, cur.next.next = t1, cur.next.next.next = t3. 如下图所示。
• 随后将cur向后移动两个节点，直到cur.next/cur.next.next=None.

代码实现：

class Solution(object):
    def swapPairs(self, head):
        dummyhead = ListNode()
        dummyhead.next = head
        cur = dummyhead
        while (cur.next!=None and cur.next.next!=None):
            temp3 = cur.next.next.next
            temp2 = cur.next.next
            temp1 = cur.next
            cur.next = temp2
            cur.next.next = temp1
            cur.next.next.next = temp3           
            cur = cur.next.next
        return dummyhead.next

删除链表的倒数第N个节点 (LC 19)

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

示例：

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

我的思路：
先用一个while循环找到链表的size, 再用一个while循环找到第n-1个节点（要删除的节点的前一个节点）作为cur，使用之前的方法完成删减 cur.next = cur.next.next. 这种方式时间复杂度为O(n^2)

我的代码实现

class Solution(object):
    def removeNthFromEnd(self, head, n):
        dummyhead = ListNode()
        dummyhead.next = head
        cur = dummyhead
        size = 0
        while（cur.next!=None）:
        	cur = cur.next
        	size+=1
        n = size=n
        cur = dummyhead
        while(n>0):
        	cur = cur.next
        	n-=1
        cur.next = cur.next.next
        return dummyhead.next

卡哥思路
非常不错的一个双指针思路。由于n为倒数第几个节点，所以要删除的节点距离链表末尾为n. 所以快指针可以先走n+1步，留出倒数的间隔，慢指针指在dummyhead,然后快慢指针一起走，直到快指针指向Null, 随后使用之前方法完成删减cur.next = cur.next.next. 这种方式时间复杂度为O(n)

代码实现

class Solution(object):
    def removeNthFromEnd(self, head, n):
        dummyhead = ListNode()
        dummyhead.next = head
        fast, slow = dummyhead, dummyhead
        for _ in range (n+1):
            fast = fast.next
        while (fast!=None):
            fast = fast.next
            slow = slow.next
        slow.next = slow.next.next
        return dummyhead.next

面试题 02.07. 链表相交

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

示例：

输入：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 个节点。

需要注意的是，如果两个链表长度不相等，链表的相交点永远不可能在较长的链表的前面节点部分，因为从末尾相交，就算全部相交，长链表也会剩下几个未相交的头结点。

因此，我们可以先通过两个循环，找到两个链表的长度，然后求出差值gap，将长链表的cur1指针，向后移动gap个节点，cur2指针初始化在短链表的head, 随后两个指针共同向后移动直到找到cur1==cur2,即为两个链表的相交点。

代码实现

class Solution(object):
    def getIntersectionNode(self, headA, headB):
        sizeA = 0
        sizeB = 0
        cur = headA
        while (cur!=None):
            cur = cur.next
            sizeA+=1
        cur = headB
        while (cur!=None):
            cur = cur.next
            sizeB+=1
        gap = abs(sizeB-sizeA)
        curA = headA
        curB = headB
        for _ in range(gap):
            if sizeA > sizeB:
                curA = curA.next
            else:
                curB = curB.next
        while curA:         #  遍历curA 和 curB，遇到相同则直接返回
            if curA == curB:
                return curA
            else:
                curA = curA.next 
                curB = curB.next
        return None 

环形链表II (LC 142) 很难！！！

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

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

示例：

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

这道题一共有两个问题需要解决：

1. 判断链表是否有环？
   可以使用快慢双指针。快慢指针同时出发，快指针每次移动两个节点，慢指针每次移动一个节点。如果没有换，快指针永远无法和慢指针相遇，而快指针会先遇到Null. 如果有环，则快指针和慢指针一定会相遇。在环中，相当于快指针追击慢指针，速度差为1，肯定会相遇。

2. 找到环入口

当相遇时，我们可以定义三个距离变量，x:起始点到环入口， y:环入口到相遇点，z:相遇点到环入口。

所以此题的步骤就是：

1. 使用快慢指针寻找指针相遇点，判断链表是否有环
2. 在链表头head和相遇点开始向后移动，直到两者相遇，新的相遇点即为环入口（根据数学公式推导得出）

代码实现

class Solution(object):
    def detectCycle(self, head):
        fast, slow = head, head
        while (fast!=None and fast.next!=None):
            fast = fast.next.next
            slow = slow.next
            if fast == slow:
                index1 = slow
                index2 = head
                while (index1!=index2):
                    index1 = index1.next
                    index2 = index2.next
                return index1
        return None

FAQ:
为什么slow指针进入环后没走完一圈的时候就被fast指针追上了？

因为 fast 的速度是 slow 的两倍，slow 走一圈的距离，fast 可以走两圈，所以肯定能在下一圈前追上。所以在公式中 slow = x+y.

总结
前三道题还比较容易，感觉使用前一天的内容可以较为轻松的解决。最后一题环形链表在没看答案之前毫无思路，不过双指针判断是否有环以及环入口的数学推导确实很精彩，需要再加强消化。继续加油！