算法训练营Day04

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

力扣题目链接(opens new window)

给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。

你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。

又一道使用虚拟头结点的题目。

分析题目先画图，明确交换的步骤。

本题亮点：两次提前保存temp；判断遍历终止条件

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

力扣题目链接(opens new window)

给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。

进阶：你能尝试使用一趟扫描实现吗？

双指针方法的经典应用：

先让fast指针移动n+1，然后快慢指针同时移动直至fast指向空，删除slow指针的下一个slow.next

注意：为什么是n+1而不是n, 因为此时slow指针才是指向被删除节点的前一个，方便进行删除操作

时间复杂度: O(n)

空间复杂度: O(1)

6. 面试题 02.07. 链表相交

同：160.链表相交

力扣题目链接(opens new window)

给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。

图示两个链表在节点 c1 开始相交：

题目数据 保证 整个链式结构中不存在环。

注意，函数返回结果后，链表必须 保持其原始结构 。

双指针法

# 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
​
        cur = headA
        while cur:
            cur = cur.next
            lenA += 1
​
        cur = headB
        while cur:
            cur = cur.next
            lenB += 1
        
        #双指针法，先移动较长的链表的指针
        curA, curB = headA, headB
        if lenA < lenB:
            for i in range(lenB-lenA):
                curB = curB.next
        else:
            for i in range(lenA-lenB):
                curA = curA.next
​
        #判断是否相等
        while curA:
            if curA == curB:
                return curA
            else:
                curA = curA.next
                curB = curB.next
        return None
​

移动较长链表的指针的这部分代码也可简化：

        curA, curB = headA, headB
        if lenA > lenB:     # 让curB为最长链表的头，lenB为其长度
            curA, curB = curB, curA
            lenA, lenB = lenB, lenA 
        for _ in range(lenB - lenA):  # 让curA和curB在同一起点上（末尾位置对齐）
            curB = curB.next 

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

• 空间复杂度：O(1)

#（版本二）求长度，同时出发 （代码复用）
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

7. 142-环形链表II

力扣题目链接(opens new window)

题意： 给定一个链表，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。

为了表示给定链表中的环，使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。

说明：不允许修改给定的链表。

经典题目。依旧使用双指针，但还涉及推导数学关系。

主要涉及两步：

1. 判断链表是否环

   设置快慢指针，fast每次移动2个结点，slow每次移动1个结点，若两者可以相遇，则一定有环；反之则无。

   注意：

   • fast一定先进入环中，若相遇，肯定是在环中相遇。

   • fast相对于slow的相对速度是1，所以若有环，一定会相遇

   • 若设置fast每次移动3个及以上结点则不一定相遇，因为相当于跳动不连续，有可能跳过slow。

1. 如果有环，如何找到环的入口

   假设从头结点到环形入口节点的节点数为x；环形入口节点到指针相遇节点的节点数为y；从相遇节点再到环形入口节点节点数为 z。 如图所示：

   

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

   （注意：slow是在进环的第一圈就被fast追上的。因为slow进环时，fast已在环内，在slow走一圈的时间里，fast已走出两圈的长度，所以一定会中途相遇并超过slow）

   因为fast速度是slow的2倍， 所以：(x + y) * 2 = x + y + n (y + z)

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

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

   所以将x单独表示为 x = n (y + z) - y ,

   整理得到 x = (n - 1) (y + z) + z 注意这里n>=1，因为 fast指针至少要多走一圈才能相遇slow指针。

   此时，若n=1, x=z; 则可以设置index1和index2 分别从头结点和相遇结点出发，分别速度为1，最终在环入口结点处相遇。

   若n>1, 则表示index2 在环里多走了(n-1)圈，但依旧是在环入口结点处相遇，判断条件是一样的。

• 时间复杂度: O(n)，快慢指针相遇前，指针走的次数小于链表长度，快慢指针相遇后，两个index指针走的次数也小于链表长度，总体为走的次数小于 2n

• 空间复杂度: 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: ListNode) -> ListNode:
        visited = set()
        
        while head:
            if head in visited:
                return head
            visited.add(head)
            head = head.next
        
        return None