代码随想录算法训练营Day4|leetcode24 两两交换链表中的节点、leetcode19 删除链表的倒数第N个节点、面试题 02.07 链表相交、leetcode142 环形链表II-CSDN博客

本文链接：https://blog.csdn.net/weixin_48821824/article/details/132248624

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

题目链接：24. 两两交换链表中的节点 - 力扣（LeetCode）

视频讲解：帮你把链表细节学清楚！ | LeetCode：24. 两两交换链表中的节点_哔哩哔哩_bilibili

文章讲解：代码随想录

思路：使用虚拟头节点，并用两个临时指针保存当前结点的下一个以及当前结点的下一个的下一个的下一个。

# 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(-1, head)
        cur = dummy_head
        while cur.next != None and cur.next.next != None:
            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

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

题目链接：19. 删除链表的倒数第 N 个结点 - 力扣（LeetCode）

视频讲解：链表遍历学清楚！ | LeetCode：19.删除链表倒数第N个节点_哔哩哔哩_bilibili

文章讲解：代码随想录

思路：定义一个快指针一个慢指针，先让快指针走n+1步，然后快慢指针同时向前走，当快指针指向空值时，慢指针便指向倒数第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(-1, head)
        fast = dummy_head
        slow = dummy_head
        n += 1
        for i in range(n):
            fast = fast.next
        while fast:
            fast = fast.next
            slow = slow.next
        slow.next = slow.next.next
        return dummy_head.next

面试题 02.07 链表相交

题目链接：面试题 02.07. 链表相交 - 力扣（LeetCode）

文章讲解：代码随想录

思路：先让curA指向A的头节点，curB指向B的头节点，求出A,B的长度，然后设置B为较长的链表，然后让curA移动到，和curB 末尾对齐的位置，然后比较curA和curB是否相同，相同则找到交点，不同则继续下一个。

# 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
        lenB = 0
        cur = headA
        while cur:
            cur = cur.next
            lenA += 1
        cur = headB
        while cur:
            cur = cur.next
            lenB += 1
        curA = headA
        curB = headB
        if lenA > lenB:      #让b为较长链表
            curA, curB = curB, curA
            lenA, lenB = lenB, lenA
        for _ in range(lenB - lenA):
            curB = curB.next
        while curA:
            if curA == curB:
                return curA
            else:
                curA = curA.next
                curB = curB.next
        return None

leetcode142.环形链表II

题目链接：142. 环形链表 II - 力扣（LeetCode）

视频讲解：把环形链表讲清楚！如何判断环形链表？如何找到环形链表的入口？ LeetCode：142.环形链表II_哔哩哔哩_bilibili

文章讲解：代码随想录 (programmercarl.com)

难点：

判断是否有环？使用快慢指针，快指针一次走两步，慢指针一次走一步，只要快慢指针能相遇就说明有环。

如何找到环的入口？假设头节点到入口长度为x，入口到相遇长度为y，相遇到环起点长度为z。则有慢指针路程为x+y，快指针路程为x+n(y+z),其中n为快指针与慢指针相遇前快指针在环内走过的圈数，再有快指针走过的路程是慢指针路程的二倍可得等式x = (n-1)（y + z) + z。类比操场跑圈可知，在起点设置指针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]:
        fast = head
        slow = head
        while fast and fast.next:
            fast = fast.next.next
            slow = slow.next
            if fast == slow:
                index1 = head
                index2 = fast
                while index1 != index2:
                    index1 = index1.next
                    index2 = index2.next
                return index1
        return None