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

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

题目链接： https://leetcode.cn/problems/swap-nodes-in-pairs/description/

文章讲解：代码随想录

视频讲解：帮你把链表细节学清楚！ | LeetCode：24. 两两交换链表中的节点_哔哩哔哩_bilibili

第一次写的时候，奇数和偶数长度判断写得太丑陋了，但是图画出来就很清楚了

学习一下递归的思想和做法

# 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]:
        if head is None or head.next is None:
            return head

        # 待翻转的两个node分别是pre和cur
        pre = head
        cur = head.next
        next = head.next.next
        
        cur.next = pre  # 交换
        pre.next = self.swapPairs(next) # 将以next为head的后续链表两两交换
         
        return cur

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

题目链接：https://leetcode.cn/problems/remove-nth-node-from-end-of-list/

文章讲解：代码随想录

视频讲解：链表遍历学清楚！ | LeetCode：19.删除链表倒数第N个节点_哔哩哔哩_bilibili

想到了用快慢双指针，然后在条件卡了一下，不应fast.next

# 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, next=head)
        slow, fast = dummy_head, dummy_head
        for i in range(n + 1):
            fast = fast.next
        while fast: # fast.next
            slow = slow.next
            fast = fast.next
        slow.next = slow.next.next
        return dummy_head.next

面试题 02.07. 链表相交

题目链接：https://leetcode.cn/problems/intersection-of-two-linked-lists-lcci/

文章讲解：代码随想录

视频讲解：

第一时间想到了哈希表，在不使用额外空间的情况下，学习了掐头统一遍历的思路

简洁写法

# 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:
        A, B = headA, headB
        while A != B:
            A = A.next if A else headB
            B = B.next if B else headA
        return A

142.环形链表II

 题目链接：https://leetcode.cn/problems/linked-list-cycle-ii/

文章讲解：代码随想录

视频讲解：把环形链表讲清楚！ 如何判断环形链表？如何找到环形链表的入口？ LeetCode：142.环形链表II_哔哩哔哩_bilibili

快慢指针的思路很巧妙，但是从数学上计算入口不如再用一个指针来的方便

# 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]:
        if not head:
            return None
        slow, fast = head, head
        while fast:
            slow = slow.next
            if fast.next:
                fast = fast.next.next
            else:
                return None
            if slow == fast:
                ptr = head
                while ptr != slow:
                    ptr = ptr.next
                    slow = slow.next
                return ptr
        return None