【代码随想录算法训练营】第4天 | 第二章 链表（二）

主要内容

1. 链表交换
2. 链表删除
3. 链表相交
4. 环形链表

题目

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

题目描述

链接

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

思路分析

代码

迭代

class Solution:
    def swapPairs(self, head: Optional[ListNode]) -> Optional[ListNode]:
        dummy = ListNode(-1)
        dummy.next = head
        p = dummy
        while p.next and p.next.next:
            # next = p.next
            # next_3 = p.next.next.next
            # p.next = p.next.next
            # p.next.next = next
            # next.next = next_3
            # p = next
            
            # 优化等价写法，更清晰
            start = p.next
            end = p.next.next
            p.next = end
            start.next = end.next
            end.next = start
            p = start
        return dummy.next    

时间复杂度 $O(n)$，空间复杂度 $O(1)$

理解递归
① 终止条件：head is None or head.next is None 
② 返回值：交换后的子链表
③ 调用单元：做了啥，待交换的为head与next，head后接交换后的子链表，next后接head,完成交换

class Solution:
    def swapPairs(self, head: Optional[ListNode]) -> Optional[ListNode]:
        # 理解递归
        # ① 终止条件：head is None or head.next is None 
        # ② 返回值：交换后的子链表
        # ③ 调用单元：做了啥，待交换的为head与next，head后接交换后的子链表，next后接head,完成交换
        if head is None or head.next is None:
            return head
        next = head.next
        head.next = self.swapPairs(next.next)
        next.next = head
        return next   

时间复杂度：O(n)，其中 n 是链表的节点数量。需要对每个节点进行更新指针的操作。
空间复杂度：O(n)，其中 n 是链表的节点数量。空间复杂度主要取决于递归调用的栈空间。

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

题目描述

链接

思路分析

双指针，哑节点

代码

class Solution:
    def removeNthFromEnd(self, head: ListNode, n: int) -> ListNode:
        dummy=ListNode(0)
        dummy.next=head
        left,right=dummy,dummy
        for i in range(n):
            right=right.next
        while(right.next):
            left=left.next
            right=right.next
        left.next=left.next.next
        return dummy.next

时间复杂度 $O(n)$，空间复杂度 $O(1)$

面试题 02.07. 链表相交

题目描述

链接

思路分析

双指针，while A!=B, A头接B尾，B头接A尾

代码

class Solution:
    def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> ListNode:
        pA = headA
        pB = headB
        while pA != pB:
            if pA is None:
                pA = headB
            else:
                pA = pA.next    

            if pB is None:
                pB = headA
            else:
                pB = pB.next
        return pA    

时间复杂度 $O(m+n)$，空间复杂度 $O(1)$

142. 环形链表 II

题目描述

链接

思路分析

若有环，则f与s相遇，环外为a, 环内为b
f = 2s = s + nb ==> s = nb, f = 2nb
p从头走到入口点走过 p = a + n*b
让slow再走a步就到了入口，

代码

class Solution:
    def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:
        fast, slow, p = head, head, head
        while True:
            if fast is None or fast.next is None:
                return None
            fast = fast.next.next
            slow = slow.next
            if fast == slow:
                break         
        while p!=slow:
            p = p.next
            slow = slow.next
        return slow   

时间复杂度 $O(n)$，空间复杂度 $O(1)$