24. 两两交换链表中的节点 19.删除链表的倒数第N个节点 面试题 02.07. 链表相交 142.环形链表II

24. 两两交换链表中的节点 ​​​​​​​

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

使用虚拟头结点, 注意细节， 注意遍历终止条件

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

class Solution:
    def swapPairs(self, head: Optional[ListNode]) -> Optional[ListNode]:
        dummy_head = ListNode(next=head)
        cur = dummy_head
        while cur.next and cur.next.next:
            tmp = cur.next
            tmp1 = cur.next.next.next
            cur.next = cur.next.next
            cur.next.next = tmp
            cur.next.next.next = tmp1

            cur = cur.next.next
        return dummy_head.next

递归

class Solution:
    def swapPairs(self, head: Optional[ListNode]) -> Optional[ListNode]:
        dummy_head = ListNode(next=head)
        def swap(cur):
            while not cur.next or not cur.next.next:
                return dummy_head.next
            tmp = cur.next
            tmp1 = cur.next.next.next
            cur.next = cur.next.next
            cur.next.next = tmp
            cur.next.next.next = tmp1
            return swap(cur.next.next)
        return swap(dummy_head)

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

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

难点： 如何找到倒数第n + 1个节点， 用双指针

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

面试题 02.07. 链表相交 ​​​​​​​

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

方法1: 分别求出两个链表的长度，让它们在末尾位置对齐的情况下同时出发开始比较

class Solution:
    def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> ListNode:
        def get_length(head):
            node = head
            length = 0
            while node:
                node = node.next
                length += 1
            return length
        
        length_A = get_length(headA)
        length_B = get_length(headB)
        curA = headA
        curB = headB
        if length_A > length_B:
            for _ in range(length_A - length_B):
                curA = curA.next
        else:
            for _ in range(length_B - length_A):
                curB = curB.next
        
        while curA:
            if curA == curB:
                return curA
            curA = curA.next
            curB = curB.next
        
        return None

方法2: 

根据快慢法则，走的快的一定会追上走得慢的。只要其中一个链表走完了，就去走另一条链表的路，当慢的链表走完自己的开始走另一条的时候，它们是末尾位置对齐的。（走的快的链表会多走m-n个节点）如果有交点，他们最终一定会在同一个位置相遇

class Solution:
    def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> ListNode:
        curA = headA
        curB = headB
        while curA != curB:
            curA = curA.next if curA else headB
            curB = curB.next if curB else headA
        return curA

142.环形链表II

判断链表是否有环， 用快慢指针

fast指针每次移动两个节点，slow指针每次移动一个节点

fast指针一定先进入环中，如果fast指针和slow指针相遇的话，一定是在环中相遇

（相对于slow来说，fast是一个节点一个节点的靠近slow的，所以fast一定可以和slow重合​​​​​​​）

从头结点出发一个指针，从相遇节点 也出发一个指针，这两个指针每次只走一个节点， 那么当这两个指针相遇的时候就是 环形入口的节点。

class Solution:
    def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:
        slow = head
        fast = head
        while fast and fast.next:
            slow = slow.next
            fast = fast.next.next
            # 相遇了， 找到了环
            if slow == fast:
                index1 = head
                index2 = slow
                while index1 != index2:
                    index1 = index1.next
                    index2 = index2.next
                return index1
        return None