【LeetCode】力扣刷题之路 (20240401~20240405)

最新推荐文章于 2024-07-22 16:27:42 发布

Ms.Q

最新推荐文章于 2024-07-22 16:27:42 发布

阅读量776

点赞数 22

文章标签： leetcode 算法职场和发展

本文链接：https://blog.csdn.net/weixin_44940843/article/details/137273152

版权

文章讲述了如何在LeetCode上解决两个单链表相交的问题，以及如何原地移除数组中特定值的元素。给出了示例代码和详细解释。作者还提出了时间复杂度优化的挑战：设计一个O(m+n)且只用O(1)内存的相交链表解决方案。

摘要由CSDN通过智能技术生成

题目(20240401~20240405)

160.相交链表

给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点，返回 null。
图示两个链表在节点 c1 开始相交：
在这里插入图片描述
题目数据保证整个链式结构中不存在环。
注意，函数返回结果后，链表必须保持其原始结构。
自定义评测：
评测系统的输入如下（你设计的程序不适用此输入）：

intersectVal - 相交的起始节点的值。如果不存在相交节点，这一值为 0
listA - 第一个链表
listB - 第二个链表
skipA - 在 listA 中（从头节点开始）跳到交叉节点的节点数
skipB - 在 listB 中（从头节点开始）跳到交叉节点的节点数
评测系统将根据这些输入创建链式数据结构，并将两个头节点 headA 和 headB 传递给你的程序。如果程序能够正确返回相交节点，那么你的解决方案将被视作正确答案。

示例 1：
在这里插入图片描述

输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,6,1,8,4,5], skipA = 2, skipB = 3
输出：Intersected at ‘8’
解释：相交节点的值为 8 （注意，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,6,1,8,4,5]。
在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。
— 请注意相交节点的值不为 1，因为在链表 A 和链表 B 之中值为 1 的节点 (A 中第二个节点和 B 中第三个节点) 是不同的节点。换句话说，它们在内存中指向两个不同的位置，而链表 A 和链表 B 中值为 8 的节点 (A 中第三个节点，B 中第四个节点) 在内存中指向相同的位置。

示例 2：
在这里插入图片描述

输入：intersectVal = 2, listA = [1,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1
输出：Intersected at ‘2’
解释：相交节点的值为 2 （注意，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 A 为 [1,9,1,2,4]，链表 B 为 [3,2,4]。
在 A 中，相交节点前有 3 个节点；在 B 中，相交节点前有 1 个节点。

示例 3：
在这里插入图片描述

输入：intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2
输出：null
解释：从各自的表头开始算起，链表 A 为 [2,6,4]，链表 B 为 [1,5]。
由于这两个链表不相交，所以 intersectVal 必须为 0，而 skipA 和 skipB 可以是任意值。
这两个链表不相交，因此返回 null 。

提示：

listA 中节点数目为 m
listB 中节点数目为 n
1 <= m, n <= 3 * 10⁴
1 <= Node.val <= 10⁵
0 <= skipA <= m
0 <= skipB <= n
如果 listA 和 listB 没有交点，intersectVal 为 0
如果 listA 和 listB 有交点，intersectVal == listA[skipA] == listB[skipB]

进阶：你能否设计一个时间复杂度 O(m + n) 、仅用 O(1) 内存的解决方案？

代码

from typing import Optional


class ListNode:
    def __init__(self, x):
        self.val = x
        self.next = None


class Solution:
    # 获取相交的节点值
    def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:
        A = headA
        B = headB
        while A != B:
            A = A.next if A else headB
            B = B.next if B else headA
        return A


if __name__ == '__main__':
    # 160.相交链表 - 示例1
    listA = [4, 1, 8, 4, 5]
    listB = [5, 6, 1, 8, 4, 5]
    intersectVal = 8
    skipA = 2
    skipB = 3
    headA = ListNode(listA[0])
    headA.next = ListNode(listA[1])
    headA.next.next = ListNode(listA[2])
    headA.next.next.next = ListNode(listA[3])
    headA.next.next.next.next = ListNode(listA[4])
    headB = ListNode(listB[0])
    headB.next = ListNode(listB[1])
    headB.next.next = ListNode(listB[2])
    headB.next.next.next = ListNode(listB[3])
    headB.next.next.next.next = ListNode(listB[4])
    headB.next.next.next.next.next = ListNode(listB[5])
    headA.next.next = headB.next.next.next
    s = Solution()
    res = s.getIntersectionNode(headA, headB)
    print(f"Intersected at '{res.val}'")  # 输出：Intersected at '8'
    # 示例2
    intersectVal = 2
    listA = [1, 9, 1, 2, 4]
    listB = [3, 2, 4]
    skipA = 3
    skipB = 1
    headA = ListNode(listA[0])
    headA.next = ListNode(listA[1])
    headA.next.next = ListNode(listA[2])
    headA.next.next.next = ListNode(listA[3])
    headA.next.next.next.next = ListNode(listA[4])
    headB = ListNode(listB[0])
    headB.next = ListNode(listB[1])
    headB.next.next = ListNode(listB[2])
    headA.next.next.next = headB.next
    res = s.getIntersectionNode(headA, headB)
    print(f"Intersected at '{res.val}'")  # 输出：Intersected at '2'
    # 示例3
    intersectVal = 0
    listA = [2, 6, 4]
    listB = [1, 5]
    skipA = 3
    skipB = 2
    headA = ListNode(listA[0])
    headA.next = ListNode(listA[1])
    headA.next.next = ListNode(listA[2])
    headA.next.next.next = None
    headB = ListNode(listB[0])
    headB.next = ListNode(listB[1])
    headB.next.next = None
    res = s.getIntersectionNode(headA, headB)
    print(f"Intersected at '{res}'")  # 输出：null

27. 移除元素

给你一个数组 nums 和一个值 val，你需要原地移除所有数值等于 val 的元素，并返回移除后数组的新长度。
不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并原地修改输入数组。
元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。
说明:
为什么返回数值是整数，但输出的答案是数组呢?
请注意，输入数组是以「引用」方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。
你可以想象内部操作如下:

// nums 是以“引用”方式传递的。也就是说，不对实参作任何拷贝
int len = removeElement(nums, val);
// 在函数里修改输入数组对于调用者是可见的。
// 根据你的函数返回的长度, 它会打印出数组中该长度范围内的所有元素。
for (int i = 0; i < len; i++) {
print(nums[i]);
}

示例 1：

输入：nums = [3,2,2,3], val = 3
输出：2, nums = [2,2]
解释：函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。你不需要考虑数组中超出新长度后面的元素。例如，函数返回的新长度为 2 ，而 nums = [2,2,3,3] 或 nums = [2,2,0,0]，也会被视作正确答案。

示例 2：

输入：nums = [0,1,2,2,3,0,4,2], val = 2
输出：5, nums = [0,1,3,0,4]
解释：函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4。注意这五个元素可为任意顺序。你不需要考虑数组中超出新长度后面的元素。

提示：

0 <= nums.length <= 100
0 <= nums[i] <= 50
0 <= val <= 100

代码

from typing import List


class Solution:
    def removeElement(self, nums: List[int], val: int) -> int:
        for i in range(len(nums) - 1, -1, -1):
            if nums[i] == val:
                nums.pop(i)
        return len(nums)


if __name__ == '__main__':
    # 27.移除元素 - 示例1
    nums = [3, 2, 2, 3]
    val = 3
    s = Solution()
    res = s.removeElement(nums, val)
    print(res, f", nums = {nums}")  # 输出：2, nums = [2,2]
    # 示例2
    nums = [0, 1, 2, 2, 3, 0, 4, 2]
    val = 2
    res = s.removeElement(nums, val)
    print(res, f", nums = {nums}")  # 输出：5, nums = [0,1,3,0,4]

Ms.Q

关注

22
点赞
踩
21

收藏

觉得还不错? 一键收藏
0
评论
【LeetCode】力扣刷题之路 (20240401~20240405)

给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点，返回 null。图示两个链表在节点 c1 开始相交：题目数据保证整个链式结构中不存在环。注意，函数返回结果后，链表必须保持其原始结构。自定义评测：评测系统的输入如下（你设计的程序不适用此输入）：示例 1：示例 2：示例 3：提示：进阶：你能否设计一个时间复杂度 O(m + n) 、仅用 O(1) 内存的解决方案？27. 移除元素给你一个数组 nums 和一个值 va
复制链接

扫一扫