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

• 今日学习的文章链接，或者视频链接

第二章 链表part02

• 自己看到题目的第一想法

24：

画图出来好理解

19：

看了题解后，原来可以用双指针：

02.07:

leetcode刷到过，有一种难懂的解法, 双指针：

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

时间复杂度O(a+b)

空间复杂度O(1)

142:

leetcode刷到过，快慢指针

• 看完代码随想录之后的想法 

24:

用dummyhead来做：

class Solution:
    def swapPairs(self, head: Optional[ListNode]) -> Optional[ListNode]:
            dummyhead = ListNode(next=head)
            pre = dummyhead
            
            # 必须有pre的下一个和下下个才能交换，否则说明已经交换结束了
            while pre.next and pre.next.next:
                cur = pre.next
                post = pre.next.next
                
                # pre，cur，post对应最左，中间的，最右边的节点
                pre.next = post
                temp = post.next  # Store original post.next
                post.next = cur
                cur.next = temp
                
                pre = pre.next.next
            return dummyhead.next

19:

依然用dummyhead来做：

class Solution:
    def removeNthFromEnd(self, head: Optional[ListNode], n: int) -> Optional[ListNode]:
        dummyhead = ListNode(next = head)
        fast,slow = dummyhead, dummyhead
        #fast先移动n+1步
        for _ in range(n+1):
            fast = fast.next
        #让slow指向要删除元素的前面一个元素
        while fast:
            fast = fast.next
            slow = slow.next
        # 删除slow.next这个节点
        slow.next = slow.next.next

        return dummyhead.next

02.07:

更容易理解的双指针

class Solution:
    def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> ListNode:
        if headA is None or headB is None:
            return None

        length_A = 0
        length_B = 0
        cur = headA
        while cur:
            length_A += 1
            cur = cur.next

        cur = headB
        while cur:
            length_B += 1
            cur = cur.next

        if length_A>length_B:
            cur_long = headA
            length_long = length_A
            cur_short = headB
            length_short = length_B
        else:
            cur_long = headB
            length_long = length_B
            cur_short = headA
            length_short = length_A
        
        gap = length_long - length_short
        for _ in range(gap):
            cur_long = cur_long.next
        while cur_long:
            if cur_long == cur_short:
                return cur_long
            cur_long = cur_long.next
            cur_short = cur_short.next
        
        return None

时间复杂度O(a+b)

空间复杂度O(1)

142：

class Solution:
    def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:
        slow, fast = head, head
        while fast and fast.next:
            slow = slow.next
            fast = fast.next.next
            # 如果相遇
            if slow == fast:
                p = head
                q = slow
                while p!=q:
                    p = p.next
                    q = q.next
                    #你也可以return q
                return p
        return None

 

• 自己实现过程中遇到哪些困难

双指针的理解

边界条件、循环结束条件的判断

• 今日收获，记录一下自己的学习时长

双指针突飞猛进