代码随想录算法训练营第四天

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

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

解决方法

1.递归

class Solution:
    def swapPairs(self, head: Optional[ListNode]) -> Optional[ListNode]:
        if head is None or head.next is None:  # 递归边界
            return head  # 不足两个节点，无需交换

        node1 = head
        node2 = head.next
        node3 = node2.next

        node1.next = self.swapPairs(node3)  # 1 指向递归返回的链表头
        node2.next = node1  # 2 指向 1

        return node2  # 返回交换后的链表头节点

2.虚拟头节点

class Solution:
    def swapPairs(self, head: Optional[ListNode]) -> Optional[ListNode]:
        tmp=sen=ListNode(next=head)
        while tmp.next and tmp.next.next:
            a=tmp.next
            b=tmp.next.next.next
            tmp.next=tmp.next.next
            tmp.next.next=a
            a.next=b
            tmp=tmp.next.next
        return sen.next

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

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

解决方法

1.利用数组遍历过程中存储地址

class Solution:
    def removeNthFromEnd(self, head: Optional[ListNode], n: int) -> Optional[ListNode]:
        sen=cur=ListNode(next=head)
        li=[sen]
        while cur:
            pre=cur
            cur=cur.next
            li.append(cur)
        li[-n-2].next=li[-n]
        return sen.next

2.快慢指针（利用快慢指针的间隔来表示倒数第几个）

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

面试题 02.07. 链表相交

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

图示两个链表在节点 c1 开始相交：

题目数据 保证 整个链式结构中不存在环。

注意，函数返回结果后，链表必须 保持其原始结构 。

解决方法

1.跟上题一样，先用数组存储，再俩个for循环查找（挺麻烦的）

class Solution:
    def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> ListNode:
        cur1=ListNode(next=headA)
        cur2=ListNode(next=headB)
        li1=[]
        li2=[]
        while cur1:
            cur1=cur1.next
            li1.append(cur1)
        while cur2:
            cur2=cur2.next
            li2.append(cur2)
        for i in li1:
            if i in li2:
                return i
        return None 

2.看的别人的（挺牛逼的）

让A和B同时从headA和headB一起走，如果到头了就从另一条线从头开始走，那么如果有交点的话，他们就会在从第二条线走的时候相遇，因为ao+oc+bo=bo+oc+ao（如果ao和bo等长，那么第一次走的时候就相遇了），如果没有交点，也会相遇，会在c点相遇，此时就是None。

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

142.环形链表II

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

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

不允许修改 链表。

解决方法

1.集合

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

2.快慢指针

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
                while slow != fast:
                    slow = slow.next
                    fast = fast.next
                return slow
        return None