代码随想录Day4：两两交换节点+删除倒数第N个节点+链表相交+环形链表II

一、两两交换链表中的节点（24. ）

题目

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

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

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

class Solution:
    def swapPairs(self, head: Optional[ListNode]) -> Optional[ListNode]:
        dummy_head = ListNode(next=head) # 虚拟头节点
        current = dummy_head
        while current.next and current.next.next:
            former = current.next
            current.next = former.next # 步骤一
            latter_next = current.next.next
            current.next.next = former # 步骤二
            former.next = latter_next  # 步骤三
            current = current.next.next
        return v_head.next

二、删除链表的倒数第N个节点（19.）

题目

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

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

双指针法

解题思路：定义fast指针和slow指针，初始值为虚拟头结点，fast首先走n + 1步；然后fast和slow同时移动，直到fast指向末尾，此时slow指向的是倒数第n+1个节点，即倒数第n个节点的上一节点。

class Solution:
    def removeNthFromEnd(self, head: Optional[ListNode], n: int) -> Optional[ListNode]:
        dummy_head = ListNode(next=head)
        fast = dummy_head
        slow = dummy_head
        for i in range (n+1):
            fast = fast.next
        while fast:
            slow = slow.next
            fast = fast.next
        slow.next = slow.next.next
        return dummy_head.next

三、链表相交（面试题 02.07.）

题目

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

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

注意：数值相同，不代表指针相同。

解法

题目分析：相交节点以及后续部分一定是位于列表最后部分的，所以只需要将长链表和短链表的末尾对齐来比较尾端部分。

解题思路：令curA指向长链表第len(A)-len(B)+1个节点，令curB指向短链表第1个节点，比较curA和curB是否相同，如果不相同，同时向后移动curA和curB，如果遇到curA == curB，则找到交点。

class Solution:
    def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> ListNode:
        lenA = 0
        lenB = 0
        tempA = headA
        tempB = headB
        while tempA: # 得到链表A的长度
            tempA = tempA.next
            lenA += 1
        while tempB: # 得到链表B的长度
            tempB = tempB.next
            lenB += 1
        curA = headA
        curB = headB
        if lenA >= lenB: # 如果A是长链表
            dif = lenA - lenB
            for i in range (dif):
                curA = curA.next
            while curA != curB:
                curA = curA.next
                curB = curB.next
            return curA
        else:            # 如果B是长链表
            dif = lenB - lenA
            for i in range (dif):
                curB = curB.next
            while curA != curB:
                curA = curA.next
                curB = curB.next
            return curA

四、环形链表II（142.）

题目

142. 环形链表 II - 力扣（LeetCode）

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

解法1：快慢指针法

有环，则快慢指针必相遇

令快慢指针速度差为1，若链表中有长度为L=y+z的环，则快慢指针必相遇，相遇时两者的路程为：

slow指针：x+y

fast指针：x+n×(y+z)+y，其中n≥1，表示fast指针在环内走了n圈才等到slow指针

注：slow指针不会在环内绕几圈才与fast相遇，这是因为在环内fast和slow的距离必然少于L，速度差为1，则fast追上slow的时间必然少于L，slow来不及完整地绕环转一圈。

找环的入口

fast指针走过的节点数 = slow指针走过的节点数 * 2：(x + y) * 2 = x + y + n (y + z)

两边消掉一个（x+y）: x + y = n (y + z)

x表示头结点到环的入口节点的的距离：x = n (y + z) - y ,

从n×(y+z)中提出一个(y+z)来：x = (n - 1) (y + z) + z

这意味着，从头结点出发一个指针，从相遇节点也出发一个指针，这两个指针每次只走一个节点， 那么这两个指针相遇的位置就是环形的入口节点。

class Solution:
    def detectCycle(self, head: ListNode) -> ListNode:
        slow = head
        fast = head
        
        while fast and fast.next:
            slow = slow.next      # 慢指针一次跳一步
            fast = fast.next.next # 快指针一次跳两步
            
            if slow == fast: # 若快慢指针相遇，则必有环，此时须找到环入口
                slow = head  # 令slow节点从头节点出发
                while slow != fast:
                    slow = slow.next
                    fast = fast.next
                return slow  # slow和fast再次相遇的位置就是环形的入口节点

        return None #无环则返回None

解法2：并查集法

解题思路：用一个集合visited来记录已经访问过的节点。通过遍历链表，如果当前节点已经在visited集合中出现过，则说明链表存在环，返回当前节点即为环的起始节点，否则将当前节点加入visited集合。如果遍历结束后仍然没有找到环，则返回None

class Solution:
    def detectCycle(self, head: ListNode) -> ListNode:
        visited = set()
        
        while head:
            if head in visited:
                return head
            visited.add(head)
            head = head.next
        
        return None