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

 语言为python 题目中所有的参考资料都来自于代码随想录 代码随想录 (programmercarl.com) 大家可以自行查看

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

题目链接：24. 两两交换链表中的节点 - 力扣（LeetCode）

题目解析：题目要求需要交换相邻链表节点 只能进行节点交换 然后返回头节点 不得修改节点内部的值

思路：首先我们设置一个虚拟头结点dummy_head dummy_head=ListNode(next=head) 让current=dummy_head 如果他可以交换 那么就必须要存在两个相邻的元素还没有进行过交换 所以判断条件为current.next and current.next.next 用while循环判断是否有两个 while current.next and current.next.next: 我们用temp1来储存current.next  用current.next=current.next.next来交换节点 然后将当前节点 current 的下一个节点 temp1 取出来，并将 current.next 指向 temp1.next。然后再将 current.next.next 指向 temp1，并将 temp1.next 指向 current.next 的下一个节点。最后将 current 移到下一个需要交换的节点处。

下面是代码

# 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)
        current=dummy_head
        while current.next and current.next.next:
            temp1=current.next
            current.next=current.next.next
            temp1.next=current.next.next
            current.next.next = temp1
            current = current.next.next
        return dummy_head.next

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

题目链接：. - 力扣（LeetCode）

思路：本题需要删除倒数第n个结点 所以不能单纯的用while逐渐current.next来得到倒数第n个结点

我们采用快慢指针 定义fast slow dummy_head虚拟头结点 让fast与slow初始位置都在dummy_head 上 用for i in range(n+1) 使fast指针运动到第n个节点的位置上 用while fast来移动fast与slow slow.next fast.next 最后fast指向none的时候 跳出while 让slow.next=slow.next.next 来删去倒数第n个结点 下面为解释为什么采取上面的操作 因为倒数第n个节点我们无法正常取到 所以先让fast到正数第n个节点 用while fast fast.next slow.next 一直使fast 与slow 以相同的速度移动 同时这两个之间相差n+1个结点  当fast指向none的时候 slow离none差n+1个节点 所以这时候slow.next就指向了倒数第n个结点 于是我们用slow.next=slow.next.next来删去第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)
        slow=fast=dummy_head
        for i in range(n+1):
            fast=fast.next
        while fast:
            fast=fast.next
            slow=slow.next
        slow.next=slow.next.next
        return dummy_head.next

面试题 02.07. 链表相交

题目链接是:面试题 02.07. 链表相交

思路：我们分成两种情况讨论 第一种情况是链表相交 链表相交的时候 链表a的长度加上相交的长度加上链表b的长度其实是等于链表b的长度加上相交的长度加上链表a的长度 也就是说我们让指针a从headA开始 指针b从headB开始 a 与 b 分别进行上述的过程 那么a与b一定会在相交点相交

如果链表不相交 其实在尾部也会有一个none相交 这时候a与b在none相交 会return 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:
        ta,tb=headA,headB
        while ta!=tb:
            ta=ta.next if ta else headB
            tb=tb.next if tb else headA
        return ta

142.环形链表II

题目链接:力扣题目链接

思路：这个题首先需要检查是否存在环形结构 以及如何判断入环的第一个节点 我们这里采取快慢指针的方法 因为不涉及到对头节点的操作 于是我们不用设置虚拟头结点 我们让slow与fast都指向head 用while fast and fast.next 来判断 fast一次动两步 slow一次动一步 如果存在slow==fast的情况 那么就存在环形结构 如果不等于就不存在 存在的情况下 我们让slow回到head 让slow与fast以同样的速度移动 在它们相遇的位置就是环入口

下面是对slow与fast相同速度移动时候相遇的位置是环入口的解释：fast是slow的速度的两倍 在相同时间内fast走的距离是slow的两倍 然后又以同样的速度移动 这时候它们都会在入口相遇

• 慢指针走过的距离：a + b
• 快指针走过的距离：a + b + n*c （n 为整数，表示快指针在环内走了 n 圈）

根据快慢指针的速度关系，有 2*(a+b) = a+b+n*c，可以推导出 a = (n-1)*c + c-b。

这意味着如果此时让慢指针重新指向链表头部，并且让快指针继续从相遇点开始以相同的速度移动，当慢指针再次走到环的起始节点时，慢指针走过的距离为 a，而快指针从相遇点开始走过的距离为 (n-1)*c + c-b，也会恰好走到环的起始节点，从而找到了环的起始节点。

下面是代码

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