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

24. 两两交换链表中的节点https://leetcode.cn/problems/swap-nodes-in-pairs/description/

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

示例 1：

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

示例 2：

输入：head = []
输出：[]

示例 3：

输入：head = [1]
输出：[1]

在两两反转时以两个节点为组，需要考虑前一个节点的指向，因为单链表遍历时无法回溯到之前节点，所以这里需要用到双指针，然后就是通过临时变量来移动指针。

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution(object):
    def swapPairs(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """
        dummy_head = ListNode(next=head)
        pre = dummy_head
        cur = dummy_head.next
        while cur and cur.next:
            temp = cur.next.next
            pre.next = cur.next
            cur.next.next = cur
            cur.next = temp
            pre = cur
            cur = temp
        return dummy_head.next

19. 删除链表的倒数第 N 个结点https://leetcode.cn/problems/remove-nth-node-from-end-of-list/description/

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

本题难点在于因为不知道链表有多长，所以没法通过倒数第n个这个信息来控制指针移动的步数，所以这里需要使用到双指针。假设第一个节点为倒数第n个节点，那么第一个节点移动n-1步就是末尾节点，因为要用到删除操作，需要找到倒数第n个节点的前一个节点，所以这里用到了虚拟头节点，将慢指针向前移动一个节点。同时移动两个指针，直到快指针到达链表末尾，找到待删除节点前一节点。

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution(object):
    def removeNthFromEnd(self, head, n):
        """
        :type head: ListNode
        :type n: int
        :rtype: ListNode
        """
        dummy_head = ListNode(next=head)
        slow = dummy_head
        fast = dummy_head
        for _ in range(n):
            fast = fast.next
        while fast.next:
            slow = slow.next
            fast = fast.next
        slow.next =  slow.next.next
        return dummy_head.next

面试题 02.07. 链表相交https://leetcode.cn/problems/intersection-of-two-linked-lists-lcci/description/

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

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

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

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

示例 1：

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

观察两个链表，相交节点是两个链表同时拥有的节点，所以使用哈希表能够快速的找到重复的节点。

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution(object):
    def getIntersectionNode(self, headA, headB):
        """
        :type head1, head1: ListNode
        :rtype: ListNode
        """
        nodes = set()
        cur = headA
        while cur:
            nodes.add(cur)
            cur = cur.next
        cur = headB
        while cur:
            if cur in nodes:
                return cur
            cur = cur.next
        return
        

这种方法很简单，但是有个问题就是建立哈希表空间复杂度是O(n)，如果要进行优化，使用快慢指针可以达到O(1)的空间复杂度，并且保持O(n)的时间复杂度。快慢指针的思路是，先遍历两个链表得到分别的长度，再将两个链表对齐一一对比。

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution(object):
    def getIntersectionNode(self, headA, headB):
        """
        :type head1, head1: ListNode
        :rtype: ListNode
        """
        lenA = self.getlength(headA)
        lenB = self.getlength(headB)
        if lenA > lenB:
            headA = self.moveforward(headA, lenA-lenB)
        else:
            headB = self.moveforward(headB, lenB-lenA)
        while headA:
            if headA == headB:
                return headA
            headA = headA.next
            headB = headB.next
        return None

    def getlength(self, head):
        current = head
        length = 0
        while current:
            current = current.next
            length += 1
        return length

    def moveforward(self, head, steps):
        current = head
        for _ in range(steps):
            current = current.next
        return current

142. 环形链表 IIhttps://leetcode.cn/problems/linked-list-cycle-ii/description/

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

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

不允许修改 链表。

示例 1：

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

同样的因为当链表有环时，在进行遍历时一定会出现重复节点，通过哈希表能够快速找到该节点。

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution(object):
    def detectCycle(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """
        cur = head
        nodes = set()
        while cur:
            if cur in nodes:
                return cur
            nodes.add(cur)
            cur = cur.next
        return

这种方法同样会消耗更多内存，而判断是否有环有个经典的方法叫做龟兔指针，通过这种方法可以判断是否存在环，但是不能够确定环的入口。这时需要用到一些数学知识。

两者相遇时走的路程：

slow = x+y

fast = x+y+n(z+y)

又因为快指针每次走两步，慢指针每次走一步所以2slow = fast，代入化简得到x=(n-1)(y+z)+z，n是快指针与慢指针相遇前走过的圈数，因为快指针先进环所以n一定是大于1的。在这里需要补充的是快指针一定会在慢指针进入环走完一圈之前与之相遇，考虑以下两种情况：

1. 如果slow进环入口，fast也在环入口。慢指针走一环，快指针走两环。

2. slow进环的时候，fast一定是在环的任意一个位置。那么fast指针走到环入口3的时候，已经走了k + n 个节点，slow相应的应该走了(k + n) / 2 个节点。因为k是小于n的（图中可以看出），所以(k + n) / 2 一定小于n。所以这时慢指针还没到达环入口，而快指针已经到达环入口了，所以快指针一定是超过了慢指针了。又因为快指针相对于慢指针每次走一步，以慢指针为坐标原点，快指针在x负轴，每次走一步一定会经过原点。

接上，因为y+z是圈的周长，所以x=z，也就是说慢指针走到环入口的路程和快指针此时位置到环入口的路程是相同的，因此如果在起点设置一个指针，在快指针位置设置一个指针，两者每次移动一步一定会在环入口相遇。

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution(object):
    def detectCycle(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """
        # 快慢指针法
        slow = head
        fast = head
        while fast and fast.next:
            slow = slow.next
            fast = fast.next.next
            if slow == fast:
                slow = head
                while slow != fast:
                    slow = slow.next
                    fast = fast.next
                return slow
        return