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

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

初始思路：就是一整个理解错意思的状态..............后来理解对了也不会做。（这是一句废话）

课程：B站 卡哥 两两交换链表中的节点

思路更新：这道题我感觉可以被列为经典题型，就是拥有固定套路的代码。从思想来说，虚拟头结点的设置直接降低了这道题的coding难度；循环条件也是需要注意的，可以在纸上画个图，找找规律，另外还要注意奇偶数的问题。有趣的地方是，当链表的指针被改了的时候，它原来的next就没有办法获得了，因此需要提前将这个结点存入temp。

代码：

# 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(next = head) # 设置一个虚拟头结点
        cur = dummy_head # 把current指针指向与dummy_head一样的位置

        # 循环条件是分为奇数和偶数两种情况，是“and”关系，奇数条件放前面
        while cur.next != None and cur.next.next != None:
            # 因为第三步会修改cur的指向，cur.next就没法找到了，所以需要提前存
            temp = cur.next
            temp1 = cur.next.next.next
            # 改变cur的指向
            cur.next = cur.next.next
            cur.next.next = temp
            temp.next = temp1
            # 移动cur的位置
            cur = cur.next.next
        
        # 返回真实的head结点
        return dummy_head.next

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

coding tips：两个指针如果都指向同一个位置，可以连等初始化： slow = fast = dummy_head

---

初始思路：不会，双指针是怎么个双法？？

课程：B站 卡哥 删除倒数第N个结点

思路更新：牛*！惊艳！！！听完思路我豁然开朗！仿佛身处米奇妙妙屋。这道题的方法我称为 游标卡尺法！1）删除节点，指针应该指向要删除结点的前一个结点；2）设置两个指针slow, fast，让fast先向后移动n+1个位置（此处就是为了让slow与fast之间相距n+1个结点的位置，听懂掌声），相当于是一个游标卡尺的作用；3）同步向后移动指针，直到fast==None，此时slow就会指向要删除的结点的前一个位置!!!!!!!!!!；4）进行删除操作。

代码：

# 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(next = head)
        # slow, fast = dummy_head, dummy_head  # 这样也可以
        slow = fast = dummy_head  # 可以连等
        i = 1

        # 确定fast的位置
        while i < n + 2:
            fast = fast.next
            i += 1
        
        # 两指针共同进步
        while fast != None:
            slow = slow.next
            fast = fast.next
        
        # 删除目标结点
        slow.next = slow.next.next

        return dummy_head.next

面试题 02.07. 链表相交

初始思路：刚开始没有思路，看了一半讲解，写完了计算AB长度，之后不知道该如何将链表尾端对齐，即将长的链表的指针移到与短的等长的位置。

思路更新：看完讲解后，light up myself的点在于：1）始终坚持把某一个指针指向最长的链表，如果A短了，就把它与B交换；2）对齐尾端无非是将长链表的指针向后移动个与短链表的长度差值的结点数量；3）数值相同，不代表指针相同，最后返回的是指针。

代码：

# 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:
        curA, curB = headA, headB
        i, j = 0, 0 

        # 计算AB链表的长度
        while curA:
            i += 1
            curA = curA.next
        while curB:
            j += 1
            curB = curB.next
        
        curA, curB = headA, headB

        # 将curA永远指向最长链表
        if j > i:
            curA, curB = curB, curA
            i, j = j, i
        
        # 对齐表尾
        for _ in range(i - j):
            curA = curA.next
        # 共同移动
        while curB:
            if curA != curB:
                curA = curA.next
                curB = curB.next
            else:
                return curA
        
        return None

LeetCode142.环形链表II

课程：B站 卡哥 环形链表II

思路：一道追及相遇问题（熊猫哭泣），主要考察：

• 判断链表是否环。可以使用快慢指针法，分别定义 fast 和 slow 指针，从头结点出发，fast指针每次移动两个节点，slow指针每次移动一个节点，如果 fast 和 slow指针在途中相遇 ，说明这个链表有环。
• 如果有环，如何找到这个环的入口。如图：

代码：

# 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]:
        slow = fast = head
        
        while fast and fast.next:
            slow = slow.next
            fast = fast.next.next
            
            # If there is a cycle, the slow and fast pointers will eventually meet
            if slow == fast:
                # Move one of the pointers back to the start of the list
                slow = head
                while slow != fast:
                    slow = slow.next
                    fast = fast.next
                return slow
        # If there is no cycle, return None
        return None

总结

链表的知识可以说是从本科以后就没有怎么接触过了，前两天重新学习的时候只知道题目的思想但是写不出来，很沮丧，感觉自己是不是要学不会了，结果今天学习下半章的时候很有进步，所以学习的事情不能着急，要相信自己。

链表的操作非常神奇，解题思路也很巧妙，双指针（游标卡尺法、追及相遇问题等）。主要还是要熟悉对链表的增删创建等操作。链表挺有意思！

（在补卡，保持着delay一天的学习进度orz）