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

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

# 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(next = head)#虚拟头节点
        pre = dummy_head #在循环之前尽量只要一个会变的参数，方便循环时参数的改变
        while pre.next and pre.next.next:#当pre后面没数时，循环停止
            #在循环里面新定义的参数，都要用循环外的参数表示，方便数据的更新
            cur = pre.next#需要变化的第一个数
            post = pre.next.next#需要变化的第二个数
            #开始进行变换，先保存一下第三个数，第二个数的next一变化，就找不到第三个数了
            temp = post.next
            #注意在变化某个数的next时，要先确保指向它的数已经指向它，否则就找不到它了
            pre.next = post
            post.next = cur
            cur.next = temp
            #变换完成，要更新pre的位置，后移了两位
            pre = pre.next.next
        #返回要返回链表头部，即虚拟头节点的next
        return dummy_head.next

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

# 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]:
        #双指针法，快的先走n步，然后快慢一起走，快的走到最后一个时，删除慢的指向的元素
        dummy_head = ListNode(next = head)
        fast = dummy_head
        slow = dummy_head
        for i in range(0,n):#n=2要分析快的应该先走多少步，使得停止时慢的指向要删除的元素
            fast = fast.next
        while fast.next != None:
            fast = fast.next
            slow = slow.next
        slow.next = slow.next.next
        return dummy_head.next       

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

# 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) -> ListNode:
        cur_A = headA
        lenA = 1
        while cur_A.next!=None:
            cur_A = cur_A.next
            lenA += 1
        cur_B = headB
        lenB = 1
        while cur_B.next!=None:
            cur_A = cur_B.next
            lenB += 1
        if lenA > lenB:#让B变成长列表
            cur_B,cur_A = headA,headB
            lenB,lenA = lenA,lenB
        for i in range (0,lenB-lenA):
            cur_B = cur_B.next
        while cur_A.next!= None:
            if cur_A == cur_B:
                return cur_A
            else:
                cur_A = cur_A.next
                cur_B = cur_B.next
        return None

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

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

# 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 = head
        fast = head
        while fast and fast.next:
            slow = slow.next
            fast = fast.next.next
            # 如果相遇
            if slow == fast:
                p = head
                q = slow
                while p!=q:
                    p = p.next
                    q = q.next
                #你也可以return q
                return p

        return None