【训练营】- Day 04-CSDN博客

本文链接：https://blog.csdn.net/weixin_44906029/article/details/132252553

Day04 链表

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

思路：dummy_head指向2，2指向1, 1指向3

注意：需要保存两个临时节点，避免在操作第一步的时候断开的节点被释放

temp为节点1

temp1为节点3

# 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
        while cur.next and cur.next.next:
            temp = cur.next
            temp1 = cur.next.next.next
            cur.next = cur.next.next
            cur.next.next = temp
            temp.next = temp1
            cur = cur.next.next
        return dummy_head.next

2. 删除链表的倒数第N个节点 (双指针)

题目：19删除链表的倒数第N个节点

关键：找到倒数第n个节点，指针一定要指向操作节点上一个节点

思路：先让快指针移动n步，在让快慢指针同时移动，当快指针指向空节点意味着慢指针指向了倒数第n个节点

问题：依旧需要使用虚拟头结点

# 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)
        fast = dummy_head
        slow = dummy_head
        for _ in range(n+1):
            fast = fast.next
        while fast:
            slow = slow.next
            fast = fast.next
        slow.next = slow.next.next
        return dummy_head.next

3. 面试题 02.07. 链表相交

面试题 02.07. 链表相交

注意：数值相同不代表指针相同

问题：循环时记得把当前指针移动到下一节点

在处理节点时，要将指针重新指向开头

# 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, lenb = 0,0
        cura, curb = headA, headB
        while cura:
            cura = cura.next
            lena+=1

        while curb:
            curb = curb.next
            lenb+=1
        cura, curb = headA, headB
        if lena> lenb:
            cura, curb = curb, cura
            lena, lenb = lenb, lena

        for i in range(lenb-lena):
            curb = curb.next

        while cura and curb:
            if cura == curb:
                return cura
            else:
                cura = cura.next
                curb = curb.next
        return None

4. 环形链表II

142.环形链表II

难点：如何找到环的入口

那么相遇时： slow指针走过的节点数为: x + y， fast指针走过的节点数：x + y + n (y + z)，n为fast指针在环内走了n圈才遇到slow指针，（y+z）为一圈内节点的个数A。

因为fast指针是一步走两个节点，slow指针一步走一个节点，所以 fast指针走过的节点数 = slow指针走过的节点数 * 2：

(x + y) * 2 = x + y + n (y + z)

两边消掉一个（x+y）: x + y = n (y + z)

因为要找环形的入口，那么要求的是x，因为x表示头结点到环形入口节点的的距离。

所以要求x ，将x单独放在左面：x = n (y + z) - y ,

再从n(y+z)中提出一个（y+z）来，整理公式之后为如下公式：x = (n - 1) (y + z) + z 注意这里n一定是大于等于1的，因为 fast指针至少要多走一圈才能相遇slow指针。

这个公式说明什么呢？

先拿n为1的情况来举例，意味着fast指针在环形里转了一圈之后，就遇到了 slow指针了。

当 n为1的时候，公式就化解为 x = z，

这就意味着，从头结点出发一个指针，从相遇节点也出发一个指针，这两个指针每次只走一个节点，那么当这两个指针相遇的时候就是环形入口的节点。

也就是在相遇节点处，定义一个指针index1，在头结点处定一个指针index2。

让index1和index2同时移动，每次移动一个节点，那么他们相遇的地方就是环形入口的节点。

# 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, head
        while fast and fast.next:
            slow = slow.next
            fast = fast.next.next
            if fast == slow:
                p = slow
                q = head
                while p!=q:
                    p = p.next
                    q = q.next
                return p
        return None