Leetcode刷题记录（代码随想录day04）

Day 04

依旧是链表。主要是双指针用法

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

给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。你不能只是单纯的改变节点内部的值（即，只能进行节点交换）。

解：看了题解发现思路是一样的，但我设置了很多个变量……
总之方法就是先设定虚拟头节点A，然后找到一组要交换的节点BC，三个节点交换，并找到下一个要交换的点B（确定它存在）和上一组节点中连接新点B的节点（因为这个指针要变）

  // 我写的
    class Solution:
        def swapPairs(self, head: Optional[ListNode]) -> Optional[ListNode]:
            pre = head
            cur = head
            last = ListNode(0, pre)
            head = last
            if pre == None:
                return head.next
            while(pre.next != None):
                cur = pre.next
                if cur.next != None:
                    temp = cur.next
                    pre.next = temp
                    cur.next = pre
                    last.next = cur
                    last = pre
                    pre = temp
                else:
                    pre.next = None
                    cur.next = pre
                    last.next = cur
            return head.next
    
    // 更简单的解法
    class Solution:
        def swapPairs(self, head: ListNode) -> ListNode:
            res = ListNode(next=head)
            pre = res
            
            # 必须有pre的下一个和下下个才能交换，否则说明已经交换结束了
            while pre.next and pre.next.next:
                cur = pre.next
                post = pre.next.next
                
                # pre，cur，post对应最左，中间的，最右边的节点
                cur.next = post.next
                post.next = cur
                pre.next = post
    
                pre = pre.next.next
            return res.next

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

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

解：双指针经典例题。先让头指针和尾指针间隔n个节点，然后同时移动，头指针指向尾部时，尾指针.next则指向要删除的节点。注意建立虚拟头节点

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

160. 相交链表

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

解：注意这两个单链表为链式且不存在环，所以如果他们有相交，从交点开始后面的节点都是相同的，因此要从尾端开始倒推。

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

142. 环形链表（中等）

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

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

解：好复杂的题，直接看题解了。也是双指针。

令快指针每次走两步，慢指针每次走一步，快指针相对于慢指针每次都只前进一步，则二者必会在某一点相遇。假设从头节点到环入口距离为x，环入口到相遇节点为y，相遇节点到环入口为z，则慢指针走过的距离为x+y，快指针走过的距离为x+y+n*(y+z)。快指针可能比慢指针在环内走了多圈，但慢指针只会在环内走不到一圈。因为二者最远距离一个环的长度-1，则当慢指针走过一个环时，快指针必然走了两个环，他们肯定会在环中相遇。

又快指针的步数是慢指针的两倍，则有：2(x+y) = x+y+n(y+z)

要求的是x，则：x = (n - 1) (y + z) + z。定义两个指针分别在相遇节点和头节点，一起移动，当两个指针相遇时，头节点指针走过x，相遇节点指针走过z+m*(y+z)，则相遇点为入口。动图如下：

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