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

本文链接：https://blog.csdn.net/weixin_44551379/article/details/128163174

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

题目链接

思路

利用虚拟头节点，交换节点的指向。注意①cur一定是指向要操作的两个节点的前一个节点（否则无法对其操作），②跳出循环的判断一定是.next在前（否则若.next为空，.next.next就是对空指针操作，会报错）。③以及临时变量存储节点temp1 temp2
（具体代码如下）

# 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()
        dummyhead.next = head
        cur = dummyhead
        while cur.next != None and cur.next.next != None:   #注意要先写.next再写.next.next
            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

反思

写循环判断前想过分两边（链表长为奇数和偶数）判断，但按照如上写法会更简洁。一开始会混淆cur是指向虚拟头节点还是头节点.next，以及返回是dummy还是dummy.next，多练习

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

题目链接

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

思路

反转链表，找到第n个元素，然后删掉
嗯，我的思想永远都巨复杂还写不出
卡哥：快慢指针指向虚拟头节点，让快指针先走n+1步，再两个一起走，这样当fast->null时，slow指的就是要删掉节点的前一个节点（这是什么聪明人想的聪明方法）
（具体代码如下）

class Solution:
    def removeNthFromEnd(self, head: Optional[ListNode], n: int) -> Optional[ListNode]:
        dummyhead = ListNode()
        dummyhead.next = head
        fast, slow = dummyhead, dummyhead
        for _ in range(n+1):
            fast = fast.next
        while fast:
            fast = fast.next
            slow = slow.next
        slow.next = slow.next.next
        return dummyhead.next

反思

通过快慢指针，找到倒数第n个节点的方法，绝了。值得学习

LeetCode 面试题 02.07. 链表相交

题目链接

面试题 02.07. 链表相交

思路

这道题原来不是看值相等，是看节点相同.一个跟上题相似的逻辑，通过先走一个，缩小差距，再齐头并进
（代码如下）

class Solution:
    def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> ListNode:
        cur = headA
        size1, size2 = 1, 1
        while cur:
            cur = cur.next
            size1 += 1
        cur = headB
        while cur:
            cur = cur.next
            size2 += 1
        cur1, cur2 = headA, headB
        #让cur2指向长链表
        if size1 > size2:
            cur1, cur2 = headB, headA
            size1, size2 = size2, size1
        for _ in range(size2 - size1):
            cur2 = cur2.next
        while cur1 != cur2:
            cur1 = cur1.next
            cur2 = cur2.next
        if cur1:
            return cur1
        else:
            return None

反思

一开始以为是看值相等，想着只要找相同就好了，后面说是节点。但还是没想过通过先走一个来解决两链表不相等长的情况

LeetCode 142.环形链表II

题目链接

142.环形链表II

思路

双指针思想：快指针走两步，慢指针走一步，两种相遇表示有环，相遇位置和起始位置一起走，相遇位置为环的入口
公式和画图：
证明相遇节点的位置和判断条件
代码如下：

class Solution:
    def detectCycle(self, head: Optional[ListNode]) -> Optional[ListNode]:
        fast, slow = head, head
        while fast!=None and fast.next!=None:
            fast = fast.next.next
            slow = slow.next
            if fast == slow:
                index1 = fast
                index2 = head
                while index1!=index2:
                    index1 = index1.next
                    index2 = index2.next
                return index1
        
        return None