day4 24.两两交换链表中的节点 19.删除链表的倒数第N个节点 160.链表相交 142.环形链表

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)

        cur = dummy_head
        while cur.next and cur.next.next: # cur的下一个节点与下下个节点都要为空才能跳出循环
            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_head.next

 

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

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

进阶：你能尝试使用一趟扫描实现吗？

示例 1：

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

示例 2：

输入：head = [1], n = 1 输出：[]

示例 3：

输入：head = [1,2], n = 1 输出：[1]

第一种写法（双指针法）：

# 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

        n += 1
        while n > 0 and fast:
            n -= 1
            fast = fast.next

        while fast:
            fast = fast.next
            slow = slow.next
            
        slow.next = slow.next.next

        return dummy_head.next

160.链表相交

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

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

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

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

示例 1：

示例 2：

示例 3：

第一种写法： 

# 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:
        curA = headA
        curB = headB

        lenA = 0
        lenB = 0
        while curA:
            curA = curA.next
            lenA += 1
        
        while curB:
            curB = curB.next
            lenB += 1

        curA = headA
        curB = headB

        # 让curA为最长链表的头，lenA为其长度
        if lenB > lenA:
            lenA, lenB = lenB, lenA
            curA, curB = curB, curA

        # 求长度差
        gap = lenA - lenB
        # 让curA与curB在同一起点上（末尾位置对齐）
        while gap > 0:
            gap -= 1
            curA = curA.next

        # 遍历两链表
        while curA:
            if curA == curB:
                return curA
            curA = curA.next
            curB = curB.next

        return None

 142.环形链表

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

为了表示给定链表中的环，使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。

说明：不允许修改给定的链表。

第一种写法（快慢指针法）：

# 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:
                index1 = head
                index2 = fast
                while index1 != index2:
                    index1 = index1.next
                    index2 = index2.next

                return index1
            
        return