代码随想录|24两两交换链表节点，19删除链表的倒数第N个，面试题02.07 链表相交，142环形链表

代码随想录|24两两交换链表节点，19删除链表的倒数第N个，面试题02.07 链表相交，142环形链表

两两交换链表节点

题目链接：leetcode

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

该题有两个关键点：

1. 循环条件的判断。每两个就要做一次交换，直至最后剩一个或者直接为None值。这里我们假设有节点 cur, first, second, 其中我们需要交换first 和second。那么遍历结束条件就是first或者second为None， 所以我们在while循环条件为（first != None, second != None). 而循环变量cur则更新为second
2. 节点赋值的顺序。将节点分别赋值到指针上，可以避免因指向改变而找不到节点的下一个。

# 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 = ListNode(val=0,next=head)
        cur = dummy
        while(cur.next != None and cur.next.next != None):
            first,second,tmp = cur.next,cur.next.next,cur.next.next.next
            cur.next = second
            second.next = first
            first.next = tmp
            cur = cur.next.next
        return dummy.next

删除链表的倒数第N个

题目链接：leetcode

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

关键点：

1. 单链表只有一个方向，所以确定倒数第N个节点是主要问题。这里考虑使用固定窗口。注意到最后一个节点与倒数第N个差了（n-1)个节点，因此可以考虑先让快指针先跑（n-1）个节点，然后快慢再同时往下遍历，保持着两个指针间距，直到快指针遍历到最后一位，此时的慢指针即为倒数第N位。
2. 在单链表的增删节点操作中，上一个的信息总是很重要。为了方便，我们再加一个指针指向慢指针的上一个。于是在初始化时，我们需要创建两个虚拟节点，pre，dummy。这里一共用了三个指针pre,cur(慢指针)，fast(快指针)。

# 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 = ListNode(val = 0, next= head)
        pre = ListNode(val = 0, next = dummy)
        cur = dummy
        fast = dummy
        for i in range(n-1):
            fast = fast.next
        while(fast.next):
            fast = fast.next
            pre,cur = pre.next,cur.next
        pre.next = cur.next
        return dummy.next

链表相交

题目链接:leetcode

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

关键点：
需要注意的是：对于节点的相等，不仅仅是节点里的值相等，而是这个类整体相等，所以相当于后面的所有结点相等。这样找到的相等节点就不存在跨过几个节点后取值不等了。所以我们只需要循环找到curA = curB即可。
注意到相交之后所有节点相等直到最后一个，所以我们可以对齐尾部，然后从对齐的开头节点开始遍历，判别节点是否相等。

# 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,curB = headA,headB
        lenA,lenB = 0,0
        while(curA):
            lenA += 1
            curA= curA.next
        while(curB):
            lenB += 1
            curB= curB.next
        curA,curB = headA,headB
        if(lenA < lenB):
            lenA,lenB = lenB,lenA
            curA,curB = curB,curA
        gap = lenA - lenB
        for _ in range(gap):
            curA = curA.next
        while(curA):
            if curA == curB:
                return curA
            curA,curB = curA.next,curB.next
        return None

环形链表II

题目链接:leetcode

题目描述：给定一个链表的头节点 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,fast = head,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