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

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

使用虚拟头节点，prev和cur分别指向需要修改的pair的前面以及pair的第一个，使用tmp存储下一个pair的第一个节点防止丢失信息。

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def swapPairs(self, head: Optional[ListNode]) -> Optional[ListNode]:
        dummy_head = ListNode(0)
        dummy_head.next = head

        prev, cur = dummy_head, head

        while cur:
            if cur.next == None:
                return dummy_head.next
            tmp = cur.next.next
            cur.next.next = cur
            prev.next = cur.next
            cur.next = tmp
            prev = cur
            cur = tmp
        return dummy_head.next

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

快慢指针，快指针先走n步，随后快慢指针同时走到终点，slow指针即指向需要被删除的节点。

这里要注意，让slow指针指向被删除的前一个才能正确删除节点，因此修改while循环条件，让指针在需要删除的节点前面就停下。

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def removeNthFromEnd(self, head: Optional[ListNode], n: int) -> Optional[ListNode]:
        dummy_head = ListNode(0)
        dummy_head.next = head
        slow, fast = dummy_head, dummy_head
        for i in range(n):
            fast = fast.next
        while fast.next:
            slow = slow.next
            fast = fast.next
        
        slow.next = slow.next.next
        return dummy_head.next

链表相交

先扫描一遍，看看有没有交点，有交点说明最后一个元素必定是一样的。记录俩链表长度，作差，再扫描一遍，用差值信息找交点。

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

class Solution:
    def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:
        curA, curB = headA, headB
        cntA, cntB = 0, 0
        while curA.next:
            curA = curA.next
            cntA += 1
        while curB.next:
            curB = curB.next
            cntB += 1
        if curA != curB:
            return None
        else:
            curA, curB = headA, headB
            if cntA >= cntB:
                diff = cntA - cntB
                for i in range(diff):
                    curA = curA.next
                while curA != curB:
                    curA = curA.next
                    curB = curB.next
            else:
                diff = cntB - cntA
                for i in range(diff):
                    curB = curB.next
                while curA != curB:
                    curA = curA.next
                    curB = curB.next
            return curA

142.环形链表II 

这里是两个问题，1、找环，2、找环入口

先找环，如果链表有环，单指针遍历必进死循环；所以这里使用不同步长的双指针，快指针一次跳两步，满指针一次跳1步。如果没有环，必定遇到Null。

如果有环，计算入口，假设入口index=i，那么slow指针走了i步就到了入口，这时fast在2i处。假设fast已经在环内转了n圈，经过k个时间步，fast再次追上了slow， 因为他俩相对速度是1， 所以必定在一圈之内追上，假设从环口走了k步相遇，则相遇点距离环口k。环长就是i+k, 也就是slow走的距离。

题目要求找环入口，从上面的分析易知，再走i步就到环口了。 而根据上述定义，从起点走i步也是环口，问题也就解完了。

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

class Solution:
    def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:
        slow, fast = head, head
        cnt = 0
        while fast and fast.next:
            fast = fast.next.next
            slow = slow.next
            cnt += 1
            if fast == slow:
                c = head
                while slow != c:
                    slow = slow.next
                    c = c.next 
                return slow
        return None