算法训练 | leetcode 24. 两两交换链表中的节点 19. 删除链表的倒数第 N 个结点 面试题 02.07. 链表相交 142. 环形链表 II

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

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

示例: 输入：head = [1,2,3,4]    输出：[2,1,4,3]

python3:保证头节点不移动

# 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)
        res = dummy_head
        while res.next and res.next.next:
            temp = res.next.next.next
            pre = res.next
            res.next = res.next.next
            res.next.next = pre
            pre.next = temp
            res = res.next.next
        return dummy_head.next

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

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

示例： 输入：head = [1,2,3,4,5], n = 2        输出：[1,2,3,5]

python3:双指针,fast先移动n+1步，fast和slow再同时移动，直到fast到null，此时fast和slow相差n+1位置，即slow指针在链表的倒数第 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]:
        dummy_head = ListNode(next = head)
        fast = dummy_head
        slow = dummy_head
        distance = n+1
        while distance:
            fast = fast.next
            distance-=1
        while fast:
            fast = fast.next
            slow = slow.next
        slow.next = slow.next.next
        return dummy_head.next

面试题 02.07. 链表相交

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

题目数据 保证 整个链式结构中不存在环。 注意，函数返回结果后，链表必须 保持其原始结构 。

示例：

输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3
输出：Intersected at '8'
解释：相交节点的值为 8 （注意，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,0,1,8,4,5]。
在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。

python3: 就是求两个链表交点节点的指针。 这里要注意，交点不是数值相等，而是指针相等。

# 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:
        nodeA = headA
        nodeB = headB
        sizeA, sizeB = 0, 0
        while nodeA:
            sizeA+=1
            nodeA = nodeA.next
        while nodeB:
            sizeB+=1
            nodeB = nodeB.next
        nodeA, nodeB = headA, headB
        if sizeA>sizeB:
            nodeA, nodeB = nodeB, nodeA
            sizeA, sizeB = sizeB, sizeA
        size = sizeB-sizeA
        while size:
            nodeB=nodeB.next
            size-=1
        while nodeA:
            if nodeB == nodeA:
                return nodeA
            nodeA = nodeA.next
            nodeB = nodeB.next
        return None

142. 环形链表 II

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

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

示例：输入：head = [3,2,0,-4], pos = 1    输出：返回索引为 1 的链表节点   

 解释：链表中有一个环，其尾部连接到第二个节点。

python3:双指针法—先找到相遇点，再依据头节点到环起始点和相遇点到环起始点两者距离相等找到环起始点

# 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]:
        fast = head
        slow = head
        while fast and fast.next:
            fast = fast.next.next
            slow = slow.next
            if fast==slow:
                index_fast= slow
                index_slow = head

                while index_fast != index_slow:
                    index_fast = index_fast.next
                    index_slow = index_slow.next
                return index_fast
        return None
        

题目来源：力扣（LeetCode）