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

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

思路

1. 定义虚拟头节点
2. 如果是偶数个节点，到最后判断现节点的下一个节点为空则停止；如果是奇数个节点，最后一个不用交换，判断现节点的下下个节点为空则停止。注意先判断cur.next不为空。
3. 要在进行交换操作之前保存1,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 != None and cur.next.next != None:
            temp1 = cur.next
            temp3 = cur.next.next.next
            
            cur.next = temp1.next
            cur.next.next = temp1
            temp1.next = temp3
            
            cur = cur.next.next
        return dummy_head.next

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

思路

1. 快指针先往前移 n+1 位，因为删除操作需要用被删除元素的前一位节点进行删除，所以比n多差一位。
2. 再把快慢指针同时向后移，直到快指针到空，此时慢指针在倒数第 n+1 个节点。
3. 再进行删除操作。

代码

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

面试题02.07.链表相交

思路

1. 求两个链表的长度
2. 将长链表的cur指针移动到后面与短链表相同的地方，也就是两个链表尾部对齐
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:
        lenA = 0
        cur = headA
        while cur != None:
            lenA += 1
            cur = cur.next
        lenB = 0
        cur = headB
        while cur != None:
            lenB += 1
            cur = cur.next

        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:
            if curA == curB:
                return curA
            else:
                curA = curA.next
                curB = curB.next

        return None

代码复用+精简

class Solution:
    def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> ListNode:
        dis = self.getLength(headA) - self.getLength(headB)
        
        # 通过移动较长的链表，使两链表长度相等
        if dis > 0:
            headA = self.moveForward(headA, dis)
        else:
            headB = self.moveForward(headB, abs(dis))
        
        # 将两个头向前移动，直到它们相交
        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. 判断进入环的位置：从头结点出发一个指针，从相遇节点 也出发一个指针，这两个指针每次只走一个节点， 那么当这两个指针相遇的时候就是环形入口的节点（推理过程详见文章讲解）

代码

双指针法

# 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 = head
        fast = head

        while fast and fast.next:
            slow = slow.next
            fast = fast.next.next

            if fast == slow:
                slow = head
                while slow != fast:
                    slow = slow.next
                    fast = fast.next
                return slow

        return None

集合法

# 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

每日总结

1. 总是因为各种事情耽误了进度，以及快要差一个星期了，周末要赶紧补一补
2. 链表常用的几个思路有：虚拟头节点、快慢指针