代码随想录算法训练营第四天 | Leetcode 24. 两两交换链表中的节点、19.删除链表的倒数第N个节点、链表相交、 142.环形链表II

本文链接：https://blog.csdn.net/odwsdt/article/details/133849805

题目：24. 两两交换链表中的节点

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

涉及数据结构

链表

解法

文档讲解：两两交换
视频讲解：两两交换

思路

虚拟结点：只有知道要反转节点的前一个节点，才能进行交换，因此cur应该是要反转的节点的前一个节点
常见问题：空指针异常/无限死循环→遍历的终止条件（偶数节点时，cur.next=none终止，奇数时，cur.next.next=none终止）
步骤：cur指向2，2指向1，1指向3
注意：cur指向2之后，cur原本指向1的指针就没有了，1无法索引到，因此要先备份一个1节点；同理，2指向1之后，2原本指向3的指针没有了，因此要先备份一个3节点
另外可以参考力扣官方的顺序，cur -> 2; 1 -> 3; 2 -> 1，同样需要备份（1和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_head = ListNode(0, head)
        cur = dummy_head
        while cur.next and cur.next.next:
            tmp_1 = cur.next # copy 1
            tmp_2 = cur.next.next.next # copy 3
            # swap
            # step1 cur.next -> 2
            cur.next = cur.next.next
            # step2  2 -> 1
            cur.next.next = tmp_1
            # step3 1 -> 3
            tmp_1.next = tmp_2
            # step4 update cur
            cur = cur.next.next
        return dummy_head.next

效果、心得：

类似反转链表，需要多熟练反转的步骤和注意备份
需要多注意终止条件

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

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

涉及数据结构

单链表

我的思路

遍历得到size
从0到size-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(0,head)
        p = dummy_head
        size = 0
        while p.next:
            size += 1
            p = p.next
        cur = dummy_head
        for _ in range(size - n):
            cur = cur.next
        cur.next = cur.next.next
        return dummy_head.next

解法

文档讲解：删除链表的倒数第N个节点
视频讲解：删除链表的倒数第N个节点

思路

再次强调：如果要删除/反转某个/两个节点，操作指针一定是前一个节点
一次遍历：快慢指针经典应用：如果要删除倒数第n个节点，让fast移动n步，然后让fast和slow同时移动，直到fast指向链表末尾。删掉slow所指向的节点
实现细节：
1、虚拟头结点
2、结合再次强调，slow应该指向要删除的节点的上一个节点，才能操作要删除的节点，因此fast实际上移动n+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(0,head)
        slow = dummy_head
        fast = dummy_head
        for _ 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. 链表相交

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

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

在这里插入图片描述

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

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

涉及数据结构

单链表

我的思路

有点懵圈看讲解

解法

文档讲解：链表相交

思路

求两个链表交点节点的指针。但要注意，交点不是数值相等，而是指针相等。
求出两个链表的长度，并求出两个链表长度的差值，然后让curA移动到和curB 末尾对齐的位置【有点类似双指针，用于对齐】
此时就可以比较curA和curB是否相同，如果不相同，同时向后移动curA和curB，如果遇到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:
        pA = headA
        m = 0
        while pA:
            m += 1
            pA = pA.next
        
        pB = headB
        n = 0
        while pB:
            n += 1
            pB = pB.next

        curA, curB = headA, headB
        if m > n:
            for _ in range(m-n):
                curA = curA.next
        else:
            for _ in range(n-m):
                curB = curB.next
        flag = 0
        while curA and curB:
            if curA == curB:
                flag = 1
                return curA
            curA = curA.next
            curB = curB.next
        if flag == 0:
            return None

等比例法

# 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 not headA or not headB:
            return None
        
        # 在每个链表的头部初始化两个指针
        pointerA = headA
        pointerB = headB
        
        # 遍历两个链表直到指针相交
        while pointerA != pointerB:
            # 将指针向前移动一个节点
            pointerA = pointerA.next if pointerA else headB
            pointerB = pointerB.next if pointerB else headA
        
        # 如果相交，指针将位于交点节点，如果没有交点，值为None
        return pointerA

效果、心得：

代码复用需熟悉(求长度、移动较长链表指针两个函数)
等比例法好东西！！

题目：142. 环形链表 II

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

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

不允许修改链表。

涉及数据结构

环形链表

解法

文档讲解：环形链表 II
视频讲解：环形链表 II

思路

判断是否有环

快慢指针：如果无环，快慢指针不会相遇；如果有环，快慢指针接连进环并最终相遇
一旦进入环，就是一个快指针“追”慢指针的过程：相对于慢指针，快指针每次以移动1个节点的速度靠近慢指针（假设快指针每次移动2步，慢指针每次移动1步）（若是快3慢1，就有可能出现快指针把慢指针跳过去的情况）

找到环的入口

快指针至少走一圈才能和慢指针相遇
设：head 到环的入口距离为x，快慢指针相遇点与入口距离为y，从相遇点走回入口距离为z，在快慢指针相遇前，快指针走了n圈，则有表达式(快指针速度2，慢指针速度1)
$y)\\ ∴ x = n(y + z) - y\\ x = (n - 1)(y + z) + z$
上面等式意义：如果有一个节点从head出发，另一个节点从相遇点``出发，则最终两个节点会在环的入口相遇【多看讲解视频】
为什么慢指针会在自己第一圈就被快指针追上？→ 配合视频讲解。当快指针入环后，假设在环内位置position_fast。慢指针来到入口index时，开始进入【快追慢】的过程。假设慢指针从入口走了一圈到入口，因为快指针的速度是慢指针的两倍，因此快指针移动两圈，已经超过了慢指针，因此可推出慢指针不会走超过一圈就被快指针追上。

在这里插入图片描述

# 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_point1 = fast # 相遇点
                index_point2 = head # 从头
                while index_point1 != index_point2:
                    index_point1 = index_point1.next
                    index_point2 = index_point2.next
                return index_point1 # 相遇位置即环的入口

        return None