(补)代码随想录算法训练有营DAY4|Leetcode 24、19、面试题 02.07.、142

文章链接：

24. 两两交换链表中的节点 代码随想录

19. 删除链表的倒数第N个节点 代码随想录

面试题 02.07. 链表相交 代码随想录

142.环形链表II 代码随想录

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

继续补作业，链表第二部分内容，在day3的基础上对链表（主要是单链表）有了一定的了解和掌握，但是有些细节需要通过看视频学习掌握。

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

状态：思考20多分钟没明确的思路，看视频学习后再写代码

思路：继续使用虚拟头节点，从每对节点的前一个节点开始操作，注意操作顺序

如有链表：pre(虚拟头节点) -->1 -->2 -->3 -->4，要互换节点1、2，分3步：

        1）修改指针pre --> 2

        2)  修改指针2 --> 1

        3)  修改指针1 --> 3

修改后为pre -->2 -->1 -->3 -->4。但在执行第一步之前，要使用两个临时指针将原先节点1、3处的指针保存下来；否则pre -->2操作后，指向节点1的指针就断开了，后续的2-->1的操作就无法进行；1-->3的操作也有相同问题。以此类推，后续的链表节点互换采用相同的思路。

总结：

1. 遍历结束条件的设置：while cur.next != None(偶数个节点) and cur.next.next != None(奇数个节点) ，且两个条件顺序不能调换，防止空指针异常报错；也可写作 while !(cur.next == None or cur.next.next == None)

2. 一定要用两个临时指针来保存原先节点的指针，防止发生空指针异常等问题；保存好后，也要注意操作顺序，画图更有助于理解操作过程

3. cur的移动：下一对节点的前一个节点

4. 还有递归写法，暂时没看，之后二刷再学习吧

5. 时间复杂度：O(n)

    空间复杂度：O(1)

# 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]:
        dummyhead = ListNode(next=head)
        cur = dummyhead
        while (cur.next != None and cur.next.next != None):
            temp1 = cur.next
            temp2 = cur.next.next.next
            cur.next = cur.next.next
            cur.next.next = temp1
            temp1.next = temp2
            cur = cur.next.next
        return dummyhead.next

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

状态：思路比较明确，直接自己写代码，但是过程中有debug

思路：先计算链表长度size，倒数第n个节点就是正数第size-n+1个节点，之后按照昨天学习的“删除第n个元素”的思路来删除第size-n+1个节点即可

总结：

1. 思路比较明晰，但是实际写代码的过程中，还是容易混淆“第n个”和“下标为n（下标从0开始）"这两个概念，导致在写条件判断或写遍历范围时出问题

2. 看过视频讲解，使用的时快慢指针法，这个思路很巧妙：快指针先走n+1步，之后快慢指针一起移动，直到快指针指向末尾的None, 此时慢指针所指向的就是倒数第n个节点的前一个节点，即可进行删除操作

3. 两种方法的复杂度一致，个人认为第一种方法比较直接，但在遍历范围上容易出现小问题，需要注意；快慢指针法很巧思也比较明晰，值得学习

时间复杂度：O(L) -- L为链表长度

空间复杂度：O(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]:
        size = 0
        dummyhead = ListNode(next=head)
        cur = dummyhead.next
        while cur:
            size += 1
            cur = cur.next
        
        if n < 0 or n > size:
            return 
        cur2 = dummyhead        
        for i in range(1, size-n+1):
            cur2 = cur2.next
        cur2.next = cur2.next.next
        return dummyhead.next
            

面试题 02.07. 链表相交

状态：先看文字讲解，再学习已有代码，之后自己再复现一遍

思路：先求两个链表的长度，并将两个链表按照末尾对齐，同时两指针对齐，之后两指针同时向后移动，直至找到交点

总结：

1. 关键点在于：求两个链表交点节点的指针。交点不是数值相等，而是指针相等。

2. 要先做末尾对齐操作，再从同一起点出发，找交点

3. 循环条件为 while headA and headB，两个节点都不为空

4. 时间复杂度：O(n + m)

    空间复杂度：O(1)

# 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:           
        lenA = self.getLength(headA)
        lenB = self.getLength(headB)

        if lenA > lenB:
            headA = self.moveForward(headA, lenA - lenB)
        else:
            headB = self.moveForward(headB, lenB - lenA)

        while headA and headB:
            if headA == headB:
                return headA
            headA = headA.next
            headB = headB.next

        return None

    def getLength(self, head:ListNode) -> int:
        length = 0
        while head:
            length += 1
            head = head.next
        return length

    def moveForward(self, head:ListNode, steps:int) -> ListNode:
        while steps > 0:
            head = head.next
            steps -= 1
        return head

142.环形链表II

状态：先看视频，再写代码，但写代码的过程还是有些磕磕绊绊

思路：分两个难点 1）找环；2）找环的入口

        1）找环：快慢指针法，快指针fast每次移动两步，慢指针slow每次移动一步; 若有环，则快慢指针一定会在环内相遇，即判断是否存在fast == slow

        2）找环的入口（理论推导建议看老师的视频）：一个从链表头部开始的指针idx1，一个从环内的相遇点开始的指针idx2，两者同时向后移动，直到两者相等即为找到入口

总结：

1. 老师在视频里讲的很清晰，但是看得懂和写的对还是有差距，需要隔段时间二刷再巩固一下

2. 两个循环遍历条件：大循环找环while fast and fast.next 和小循环找入口while idx1 != idx2

3. 时间复杂度：O(n)

    空间复杂度：O(1)

# 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 = slow = head
        while fast and fast.next:
            fast = fast.next.next
            slow = slow.next
            if fast == slow:
                idx1 = fast
                idx2 = head
                while idx1 != idx2:
                    idx1 = idx1.next
                    idx2 = idx2.next
                return idx1

        return None