leetcode刷题-链表篇

原创 已于 2024-04-10 19:40:11 修改 · 751 阅读 · 12 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#leetcode #链表 #linux

于 2024-04-10 11:01:44 首次发布

目录

链表

203. 移除链表元素

题目

给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。

示例 1：

输入：head = [1,2,6,3,4,5,6], val = 6
输出：[1,2,3,4,5]

示例 2：

输入：head = [], val = 1
输出：[]

示例 3：

输入：head = [7,7,7,7], val = 7
输出：[]

提示：

 - 列表中的节点数目在范围 [0, 10^4] 内
 - 1 <= Node.val <= 50
 - 0 <= val <= 50

代码

  • 虚拟头节点（哨兵）
    时间复杂度 O(N)
    空间复杂度 O(1)
# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def removeElements(self, head: Optional[ListNode], val: int) -> Optional[ListNode]:
        cur = dummy = ListNode(next=head)
        while cur and cur.next:
            while cur.next and cur.next.val == val:
                cur.next = cur.next.next
            cur = cur.next
        return dummy.next

707. 设计链表

题目

你可以选择使用单链表或者双链表，设计并实现自己的链表。

单链表中的节点应该具备两个属性：val 和 next 。val 是当前节点的值，next 是指向下一个节点的指针/引用。

如果是双向链表，则还需要属性 prev 以指示链表中的上一个节点。假设链表中的所有节点下标从 0 开始。

实现 MyLinkedList 类：

  • MyLinkedList() 初始化 MyLinkedList 对象。
  • int get(int index) 获取链表中下标为 index 的节点的值。如果下标无效，则返回 -1 。
  • void addAtHead(int val) 将一个值为 val 的节点插入到链表中第一个元素之前。在插入完成后，新节点会成为链表的第一个节点。
  • void addAtTail(int val) 将一个值为 val 的节点追加到链表中作为链表的最后一个元素。
  • void addAtIndex(int index, int val) 将一个值为 val 的节点插入到链表中下标为 index 的节点之前。如果 index 等于链表的长度，那么该节点会被追加到链表的末尾。如果 index 比长度更大，该节点将 不会插入 到链表中。
  • void deleteAtIndex(int index) 如果下标有效，则删除链表中下标为 index 的节点。

示例 ：

输入
["MyLinkedList", "addAtHead", "addAtTail", "addAtIndex", "get", "deleteAtIndex", "get"]
[[], [1], [3], [1, 2], [1], [1], [1]]
输出
[null, null, null, null, 2, null, 3]

解释
MyLinkedList myLinkedList = new MyLinkedList();
myLinkedList.addAtHead(1);
myLinkedList.addAtTail(3);
myLinkedList.addAtIndex(1, 2);    // 链表变为 1->2->3
myLinkedList.get(1);              // 返回 2
myLinkedList.deleteAtIndex(1);    // 现在，链表变为 1->3
myLinkedList.get(1);              // 返回 3

提示：

 - 0 <= index, val <= 1000
 - 请不要使用内置的 LinkedList 库。
 - 调用 get、addAtHead、addAtTail、addAtIndex 和 deleteAtIndex 的次数不超过 2000 。

代码

  • 单链表法 保存dummy 和维护链表长度size
    时间复杂度 O(N)
    空间复杂度 O(1)
# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def removeElements(self, head: Optional[ListNode], val: int) -> Optional[ListNode]:
        cur = dummy = ListNode(next=head)
        while cur and cur.next:
            while cur.next and cur.next.val == val:
                cur.next = cur.next.next
            cur = cur.next
        return dummy.next

206. 反转链表

题目

给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

示例 1：

输入：head = [1,2,3,4,5]
输出：[5,4,3,2,1]

示例 2：

输入：head = [1,2]
输出：[2,1]

示例 3：

输入：head = []
输出：[]

提示：

 - 链表中节点的数目范围是 [0, 5000]
 - -5000 <= Node.val <= 5000

**进阶：**链表可以选用迭代或递归方式完成反转。你能否用两种方法解决这道题？

代码

  • 双指针法 cur指向head pre 指向None一步步改指向
    时间复杂度 O(N)
    空间复杂度 O(1)
# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def removeElements(self, head: Optional[ListNode], val: int) -> Optional[ListNode]:
        cur = dummy = ListNode(next=head)
        while cur and cur.next:
            while cur.next and cur.next.val == val:
                cur.next = cur.next.next
            cur = cur.next
        return dummy.next

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

题目

给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。

示例 1：

输入：head = [1,2,3,4]
输出：[2,1,4,3]

示例 2：

输入：head = []
输出：[]

示例 3：

输入：head = [1]
输出：[1]

提示：

 - 链表中节点的数目在范围 [0, 100] 内
 - 0 <= Node.val <= 100

代码

  • 迭代 dummy三步操作改next
    时间复杂度 O(N)
    空间复杂度 O(1)
# 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]:
        cur = dummy = ListNode(next=head)
        while cur.next and cur.next.next:
            next1 = cur.next
            next3 = cur.next.next.next
            cur.next = cur.next.next
            cur.next.next = next1
            next1.next = next3
            cur = cur.next.next
        return dummy.next

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

题目

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

示例 1：

输入：head = [1,2,3,4,5], n = 2
输出：[1,2,3,5]

示例 2：

输入：head = [1], n = 1
输出：[]

示例 3：

输入：head = [1,2], n = 1
输出：[1]

提示：

 - 链表中结点的数目为 sz
 - 1 <= sz <= 30
 - 0 <= Node.val <= 100
 - 1 <= n <= sz

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

代码

  • 双指针 dummy快指针先走n步 然后快慢指针一起走快指针到尾部 慢指针修改next
    时间复杂度 O(N)
    空间复杂度 O(1)
# 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]:
        slow = fast = dummy = ListNode(next=head)
        while n:
            fast = fast.next
            n -= 1
        while fast.next:
            fast = fast.next
            slow = slow.next
        slow.next = slow.next.next
        return dummy.next

LCR 023. 相交链表

题目

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

图示两个链表在节点 c1 开始相交：
在这里插入图片描述

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

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

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

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

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

输入：intersectVal = 2, listA = [0,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1
输出：Intersected at '2'
解释：相交节点的值为 2 （注意，如果两个链表相交则不能为 0）。
从各自的表头开始算起，链表 A 为 [0,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
 - 0 <= m, n <= 3 * 104
 - 1 <= Node.val <= 105
 - 0 <= skipA <= m
 - 0 <= skipB <= n
 - 如果 listA 和 listB 没有交点，intersectVal 为 0
 - 如果 listA 和 listB 有交点，intersectVal == listA[skipA + 1] == listB[skipB + 1]

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

代码

  • 双指针 利用总长度为m+n
    时间复杂度 O(m+n)
    空间复杂度 O(1)
# 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:
        A, B = headA, headB
        while A != B:
            A = A.next if A else headB
            B = B.next if B else headA
        return A

141. 环形链表

题目

给你一个链表的头节点 head ，判断链表中是否有环。

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。注意：pos 不作为参数进行传递 。仅仅是为了标识链表的实际情况。

如果链表中存在环 ，则返回 true 。 否则，返回 false 。

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

输入：head = [3,2,0,-4], pos = 1
输出：true
解释：链表中有一个环，其尾部连接到第二个节点。

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

输入：head = [1,2], pos = 0
输出：true
解释：链表中有一个环，其尾部连接到第一个节点。

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

输入：head = [1], pos = -1
输出：false
解释：链表中没有环。

提示：

 - 链表中节点的数目范围是 [0, 104]
 - -10^5 <= Node.val <= 10^5
 - pos 为 -1 或者链表中的一个 有效索引 。

**进阶：**你能用 O(1)（即，常量）内存解决此问题吗？

代码

  • 双指针 利用循环特性
    时间复杂度 O(n)
    空间复杂度 O(1)
# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def hasCycle(self, head: Optional[ListNode]) -> bool:
        # 快慢指针
        slow = fast = head
        while fast and fast.next:
            fast = fast.next.next
            slow = slow.next
            if slow == fast:
                return True
        return False

142. 环形链表 II

题目

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

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。

不允许修改 链表。

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

输入：head = [3,2,0,-4], pos = 1
输出：返回索引为 1 的链表节点
解释：链表中有一个环，其尾部连接到第二个节点。

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

输入：head = [1,2], pos = 0
输出：返回索引为 0 的链表节点
解释：链表中有一个环，其尾部连接到第一个节点。

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

输入：head = [1], pos = -1
输出：false
解释：链表中没有环。

提示：

 - 链表中节点的数目范围是 [0, 104]
 - -10^5 <= Node.val <= 10^5
 - pos 为 -1 或者链表中的一个 有效索引 。

进阶： 你能用 O(1)（即，常量）内存解决此问题吗？

代码

  • 双指针 利用循环特性
    时间复杂度 O(n)
    空间复杂度 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: Optional[ListNode]) -> Optional[ListNode]:
        slow = fast = head
        while True:
            if not(fast and fast.next): return 
            fast, slow = fast.next.next, slow.next
            if fast == slow: break
        fast = head
        while fast != slow:
            fast, slow = fast.next, slow.next
        return fast

2. 两数相加

题目

给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。

请你将两个数相加，并以相同形式返回一个表示和的链表。

你可以假设除了数字 0 之外，这两个数都不会以 0 开头。

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

输入：l1 = [2,4,3], l2 = [5,6,4]
输出：[7,0,8]
解释：342 + 465 = 807.

示例 2：

输入：l1 = [0], l2 = [0]
输出：[0]

示例 3：

输入：l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]
输出：[8,9,9,9,0,0,0,1]

提示：

 - 每个链表中的节点数在范围 [1, 100] 内
 - 0 <= Node.val <= 9
 - 题目数据保证列表表示的数字不含前导零

代码

  • 递归或者迭代
    时间复杂度 O(n)
    空间复杂度 O(n)或O(1)
# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def addTwoNumbers(self, l1: Optional[ListNode], l2: Optional[ListNode], carry=0) -> Optional[ListNode]:
        # 递归
        # if l1 is None and l2 is None:
        #     return ListNode(carry) if carry else None
        # if l1 is None:
        #     l1, l2 = l2, l1
        # carry += l1.val + (l2.val if l2 else 0)
        # l1.val = carry % 10
        # l1.next = self.addTwoNumbers(l1.next, l2.next if l2 else None, carry // 10)
        # return l1

        # 迭代
        cur = dummy = ListNode()
        carry = 0
        while l1 or l2 or carry:
            carry += (l1.val if l1 else 0) + (l2.val if l2 else 0)
            cur.next = ListNode(carry % 10)
            carry //= 10
            cur = cur.next
            if l1: l1 = l1.next
            if l2: l2 = l2.next
        return dummy. Next

445. 两数相加 II

题目

给你两个 非空 链表来代表两个非负整数。数字最高位位于链表开始位置。它们的每个节点只存储一位数字。将这两数相加会返回一个新的链表。

你可以假设除了数字 0 之外，这两个数字都不会以零开头。

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

输入：l1 = [7,2,4,3], l2 = [5,6,4]
输出：[7,8,0,7]

示例 2：

输入：l1 = [2,4,3], l2 = [5,6,4]
输出：[8,0,7]

示例 3：

输入：l1 = [0], l2 = [0]
输出：[0]

提示：

 - 链表的长度范围为 [1, 100]
 - 0 <= node.val <= 9
 - 输入数据保证链表代表的数字无前导 0

**进阶：**如果输入链表不能翻转该如何解决？

代码

  • 迭代 拆解为反转链表+两数相加
    时间复杂度 O(n)
    空间复杂度 O(1)
# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def reverseList(self, head):
        cur, pre = head, None
        while cur:
            cur.next, pre, cur = pre, cur, cur.next
        return pre
    def addTwo(self, l1, l2):
        cur = dummy = ListNode()  # 哨兵节点
        carry = 0  # 进位
        while l1 or l2 or carry:  # 有一个不是空节点，或者还有进位，就继续迭代
            if l1: carry += l1.val  # 节点值和进位加在一起
            if l2: carry += l2.val  # 节点值和进位加在一起
            cur.next = ListNode(carry % 10)  # 每个节点保存一个数位
            carry //= 10  # 新的进位
            cur = cur.next  # 下一个节点
            if l1: l1 = l1.next  # 下一个节点
            if l2: l2 = l2.next  # 下一个节点
        return dummy.next  # 哨兵节点的下一个节点就是头节点
    def addTwoNumbers(self, l1: Optional[ListNode], l2: Optional[ListNode]) -> Optional[ListNode]:
        l1 = self.reverseList(l1)
        l2 = self.reverseList(l2)
        l3 = self.addTwo(l1, l2)
        return self.reverseList(l3)
  • 栈 两个栈存储每个链表的值 然后慢慢迭代创建新的链表
    时间复杂度 O(max⁡(m,n))
    空间复杂度 O(m+n)
# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    # 栈
    def addTwoNumbers(self, l1: Optional[ListNode], l2: Optional[ListNode]) -> Optional[ListNode]:
        s1, s2 = [], []
        while l1:
            s1.append(l1.val)
            l1 = l1.next
        while l2:
            s2.append(l2.val)
            l2 = l2.next
        dummy = ListNode()
        carry = 0
        while s1 or s2 or carry:
            s = (s1.pop() if s1 else 0) + (s2.pop() if s2 else 0) + carry
            carry, val = divmod(s, 10)
            dummy.next = ListNode(val, dummy.next)
        return dummy. Next
hyl_2022
关注
leetcode刷题指南 - 两个月完成
iamjiangxiaoqian的博客
07-29 871
链表(8题) + 双指针(11题) = 19题。: 数据结构类(19题) = 19题。
leetcode刷题账号-LeetCode:LeetCode刷题记录(C#)
07-06
这个压缩包文件"LeetCode-master"很可能包含了某个用户在刷题过程中的代码记录或者解决方案。 在刷LeetCode的过程中，有几个关键知识点是值得深入探讨的： 1. **基础数据结构**：在LeetCode的题目中，常见数据结构...
LeetCode刷题---反转链表
元清的博客
12-03 2834
给你单链表的头节点head，请你反转链表，并返回反转后的链表。
LeetCode刷题-C++
qq_20553359的博客
03-02 1921
1.2 内联函数 参考【C++】之内联函数(inline)申明 2.1 inline函数需要支持调试, 在debug版本下内联函数一律都是call函数地址, 想要观察inline函数在调用处展开需要在release版本下观察概念 2.2 用inline修饰的函数叫做内联函数，编译时C++编译器会在调用内联函数的地方展开，没有函数压栈的开销特征 2.3 内联函数是一种以空间来换取时间的做法，省区调用函数的额外开销，内联函数会直接在函数调用处把原函数拷贝过来，所以如果函数代码很长或者很复杂，不适合转变为内
LeetCode分类刷题----链表篇
池鱼
01-12 1494
设立两个快慢指针，先让快指针走n+步，当快指针指向链表尾节点的时候，此时慢指针恰好走到要删除节点的前一个节点，此时对慢指针进行删除即可。设头节点到成环节点的距离为x，设成环节点到相遇节点的距离为y，设相遇节点到成环节点的距离为z。给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点。两个指针，当着两个指针走向尽头时，然后转向另一个链表的头节点，直到这两个链表相遇，因为这两个节点都走了同样的长度。当n=1的时候有x=z。
leetcode刷题-链表总结（python）
weixin_57139537的博客
02-19 1167
链表是一系列节点组成的元素集合。每个节点包含两个部分，数据域item和指向下一个节点的指针next。通过节点之间的互相连接最终串成一个链表。单链表，链表的入口节点称为头结点head，最后一个节点指向None。双链表，双链表的每个节点有两个指针，一个指向前一个一个指向后一个节点。循环链表，链表首尾相连。
LeetCode刷题链表
的博客
05-04 1334
画图 = 直观 + 形象 + 便于理解引入虚拟头节点，便于处理边界情况，方便我们对链表进行操作3. 大胆去定义变量，不要吝啬空间，可以简单化链表链接快慢双指针，判断环，找链表中环的入口，找链表中倒数第n个节点链表中的常用操作：创建一个新节点 new尾插头插，使用虚拟头节点，例题逆序链表，如下图。
LeetCode刷题---链表
2301_79969994的博客
01-10 1545
将已知链表存放在一个新的链表中，将已知链表的每一个节点头插进新的链表中，需要三个变量：一个变量存放新的链表的节点信息，一个变量存放下一个节点的信息，一个变量来存放当前位置的信息。由上图可知可以创建一个新的链表，然后依次把两个链表中小的数尾插进新的链表，准备两个节点，一个节点遍历新的链表，一个节点始终指向新链表的头结点，用两个链表依次比较来填充新的链表。所以我们就需要3个变量，一个节点存放指向其他节点的信息，另一个节点是被指向的节点，还需要一个节点来存放下一个节点的信息。给定链表头结点，找出链表中间节点。
LeetCode刷题笔记 --- python
纸短情长的博客
01-21 2513
Leecode刷题笔记
LeetCode刷题知识点笔记---数组、链表篇（Java语言）
qq_45757188的博客
06-13 531
当 n 为奇数时，slow 恰好指向中间结点，当 n 为 偶数时，slow 恰好指向中间两个结点的靠前一个(可以考虑下如何使其指向后一个结点呢？当一个链表有环时，快慢指针都会陷入环中进行无限次移动，然后变成了追及问题。当两个指针都进入环后，每轮移动使得慢指针到快指针的距离增加一，同时快指针到慢指针的距离也减少一，只要一直移动下去，快指针总会追上慢指针。此时，p 指向第 k+1个结点，q 指向头节点，两个指针的距离为 k。然后，同时移动 p 和 q，直到 p 指向空，此时 q 即指向倒数第 k 个结点。
Leetcode刷题-206：反转链表
ITSOK_123的博客
04-06 1133
解题思路1.题目描述2.题目分析3.题目解答 1.题目描述 给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。 示例1： 输入：head = [1,2,3,4,5] 输出：[5,4,3,2,1] 示例2： 输入：head = [1,2] 输出：[2,1] 示例3： 输入：head = [] 输出：[] 来源：力扣（LeetCode） 2.题目分析 这道题就是个十分简单的节点方向操作题，不涉及什么复杂的算法。我们可以通过构造一个带有头结点的链表使用头插法来实现一个新的反向链表。以[
精选资源
leetcode分类-LeetCode:LeetCode刷题记录，主要记录代码和做题思路
06-30
LeetCode刷题记录，记录代码和做题思路。 算法 167. 两数之和 II - 输入有序数组: 633. 平方数之和: 345. 反转字符串中的元音字母: 680. 验证回文字符串 Ⅱ: 88. 合并两个有序数组: 141. 环形链表: 392. 判断子序列:...
leetcode分类-leetcode:leetcode刷题总结
06-30
本篇文章将针对“leetcode分类-leetcode:leetcode刷题总结”这一主题，对LeetCode的刷题经验进行深入探讨，并结合开源项目“leetcode-master”分享一些实用技巧和心得。 首先，我们要明确LeetCode的刷题分类。...
精选资源
leetcode跳跃-leetcode:leetcode刷题笔记
06-30
leetcode刷题笔记 005-2. 最长回文子串 字符串+中心扩散 :star:010-3. 正则表达式匹配 动态规划 019-2. 删除链表的倒数第N个节点 链表+快慢指针 022-2. 括号生成 回溯法 :star:031-2. 下一个排列 数组+思维 034-2. ...
leetcode 1351. 统计有序矩阵中的负数 简单
2401_88085478的博客
12-28 285
矩阵中的元素无论是按行还是按列，都以非严格递减顺序排列。你可以设计一个时间复杂度为。矩阵中共有 8 个负数。
【Golang】LeetCode 55. 跳跃游戏
YGGP的博客
12-28 348
基于 Golang 解决 LeetCode 55. 跳跃游戏。
LeetCode 97. 交错字符串 - 二维DP经典题解（C语言实现）
最新发布
六六哥的博客
01-03 418
给定三个字符串 s1、s2、s3，判断 s3 是否可以由 s1 和 s2 交错组成。leetcode​交错的含义是：保持 s1、s2 各自字符相对顺序不变，把它们按某种顺序“插”在一起，形成 s3。leetcode​例如：s1 = “aabcc”，s2 = “dbbca”，可以拆成 “aa” + “bc” + “c” 和 “dbbc” + “a”，交错后得到 “aadbbcbcac”，所以返回 true。leetcode​。
#leetcode#
wnaan的博客
01-01 822
/ leftMax[i]：表示「前缀区间 nums[0...i]」的最大子数组和（必须包含nums[0]，向右延伸）// 记录从数组末尾向左累加的「后缀和」(nums[i...n-1])// 剪枝条件：当前已选元素数(temp.size()) + 剩余可选元素数(n-cur+1) < k。// ========== 第二阶段：枚举【类型2：跨首尾的环形子数组】的最大和 ==========// 环形子数组和 = 后缀和(nums[i..n-1]) + 前缀最大和(nums[0..i-1])
LeetCode 462 - 最小操作次数使数组元素相等 II
网罗天下方法，方便你我开发！！！
12-31 784
这道题看起来像个“数学题”，但其实更准确地说，它是一个非常典型的工程决策问题： 当你可以自由地调整每个元素，目标是让整体成本最低时，应该把大家“拉”到哪里？ 很多人第一反应是“取平均数”，但这道题偏偏不是。 真正的答案，其实和一个我们经常忽略、但非常重要的概念有关：中位数。
掌握数据结构：leetcode刷题与链表反转实践
可能表示这个文件夹是整个LeetCode刷题项目的主干部分，其中包含了所有相关的代码、笔记和教程。 总结而言，该文件夹为Java开发者提供了一个用于练习和学习数据结构、算法以及LeetCode题目的资源库。资源丰富，涵盖...
评论 1
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值