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

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

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

开始写代码没有考虑到：while的条件，在分奇数偶数的情况下均需要满足；

    只考虑了tmp，没有想到tmp1，tmp1如果不进行暂存，在更改了"2"的指针后无法找到“3”的位置，会造成超时；

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

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

        return dummy_node.next

 卡哥视频中说讲的是n+1，但是原理相同，都是以NULL作为临界执行相应的条件；

 此题巧妙之处在于利用双指针，n作为快慢指针的间距来解决，delete操作首先需要确定删除元素的前一个位点，然后在将前一个位点指向删除元素的后一个位点进行解决。

面试题 02.07. 链表相交

class Solution:
    def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> ListNode:
        curA = headA
        curB = headB 
        lenA , lenB = 0,0
        while curA:
            curA = curA.next
            lenA += 1
        while curB:
            curB = curB.next
            lenB += 1
        curA1 = headA
        curB1 = headB
        if lenA > lenB:
            curA1 , curB1 = curB1 , curA1
            lenA , lenB = lenB , lenA
        for _ in range(lenB - lenA):
            curB1 = curB1.next
        while curA1:
            if curA1 == curB1:
                return curA1
            else:
                curA1 = curA1.next
                curB1 = curB1.next
        return None

142. 环形链表 II

class Solution:
    def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:
        fast = head
        slow = head 
        while fast != None and fast.next != None:
            fast = fast.next.next
            slow = slow.next
            if fast == slow:
                index1 = fast
                index2 = head
                while index1 != index2:
                    index1 = index1.next
                    index2 = index2.next
                return index1
        return None

推导过程如下：