代码随想录算法训练营第4天 | 24. 两两交换链表中的节点 + 19.删除链表的倒数第N个节点 + 160. 链表相交 + 142.环形链表II-CSDN博客

本文链接：https://blog.csdn.net/weixin_63840907/article/details/132395376

今日任务：

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

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

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

分析：

使用虚拟头结点，避免对头结点（没有前一个指针指向头节点）进行单独处理
交换相邻两个元素，一定要画图，不画图容易乱，写出操作的顺序

# 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:
            temp = current.next#防止节点被修改
            temp1 = current.next.next.next

            current.next = current.next.next
            current.next.next = temp
            temp.next = temp1
            current = current.next.next

        return dummy_head.next

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

题目链接：19. 删除链表的倒数第 N 个结点 - 力扣（LeetCode）

分析：

根据提示中的1<=n<=sz，不许考虑超出边界的问题
使用虚拟头结点，不需要特殊考虑头结点

思路（双指针）：

定义fast指针与slow指针，初始值为虚拟头结点
fast 首先走n+1步，相当于当fast为空时，slow为要被删除结点的前一个结点

class Solution:
    def removeNthFromEnd(self, head: ListNode, n: int) -> ListNode:
        dummy_head = ListNode(next=head)
        slow, fast = dummy_head, dummy_head

        for _ in range(n + 1):
            fast = fast.next

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

        return dummy_head.next

160.链表相交

题目链接：面试题 02.07. 链表相交 - 力扣（LeetCode）

分析:

此题是求两个链表交点节点的指针注意：交点不是数值相等，而是指针相等

思路（双指针法+等比例法）：

注意：

即使A、B不相交，代码也不会死循环，因为它们长度的最小公倍数不会变，若不相交。最终都会指向null，此时相等，跳出循环

参考：LeetCode 160. 相交链表（超详细超容易理解的动画解法！！！） - 知乎 (zhihu.com)

# 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:
        if  headA == None or  headB == None:
            return None

        #初始化两个指针
        pointA = headA
        pointB = headB

        while(pointA!=pointB):
            pointA = pointA.next if pointA else headB
            pointB = pointB.next if pointB else headA
        
        return pointA

142.环形链表||

题目链接：142. 环形链表 II - 力扣（LeetCode）

分析：

考察两个知识点：1.判断链表是否有环 2.如果有环，如何找到这个环的入口

思路（快慢指针法）：

Q1：判断链表是否有环：

使用快慢指针法，定义fast和slow指针，从头结点出发，fast指针每次移动两个节点，slow指针每次移动一个节点，其实相对于slow来说，fast是一个节点一个节点的靠近slow，如果fast指针和slow指针相遇，则一定是在环中相遇

Q2：如果有环，如何找到这个环的入口：

# 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

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

            if fast == slow:
                slow = head

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

                return slow

        
        return None