- 博客(25)
- 收藏
- 关注
RSS订阅原创 209.长度最小的子数组- 力扣(LeetCode)
在 prefix 中从位置 i+1 到 n+1 查找第一个 >= prefix[i] + target 的位置。以右指针为准遍历，倘若区间内[left, right] (左闭右闭)的和未达到target，直接向右。因为我们会记录下等于时刻的长度。输入：target = 11, nums = [1,1,1,1,1,1,1,1]输入：target = 7, nums = [2,3,1,2,4,3]输入：target = 4, nums = [1,4,4]解释：子数组 [4,3] 是该条件下的长度最小的子数组。
2025-04-13 15:05:59
248
原创 200.岛屿数量- 力扣(LeetCode)
对矩阵进行依次遍历，如果当前grid[i] [j] == "1",则启动DFS模式。找到与之相连的所有1，将其置为0。搜索结束后，我们找到了一个岛屿，岛屿数量+=1。如此循环，最终返回岛屿数量即可。给你一个由 '1'（陆地）和 '0'（水）组成的的二维网格，请你计算网格中岛屿的数量。岛屿总是被水包围，并且每座岛屿只能由水平方向和/或竖直方向上相邻的陆地连接形成。此外，你可以假设该网格的四条边均被水包围。的值为 '0' 或 '1'输入：grid = [输入：grid = [
2025-04-12 13:13:27
271
原创 169.多数元素- 力扣(LeetCode)
若数组的前 a 个数字的 票数和 =0 ，则 数组剩余 (n−a) 个数字的 票数和一定仍 >0 ，即后 (n−a) 个数字的 众数仍为 x。根据以上推论，记数组首个元素为 n1，众数为 x ，遍历并统计票数。若记 众数 的票数为 +1 ，非众数 的票数为 −1 ，则一定有所有数字的 票数和 >0。= x ： 抵消的所有数字中，众数 x 的数量最少为 0 个，最多为一半。当 n1 = x ： 抵消的所有数字中，有一半是众数 x。设输入数组 nums 的众数为 x ，数组长度为 n。
2025-04-12 10:45:00
355
原创 107.二叉树的层序遍历II- 力扣(LeetCode)
给你二叉树的根节点 root ，返回其节点值 自底向上的层序遍历。（即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）输入：root = [3,9,20,null,null,15,7]输出：[[15,7],[9,20],[3]]树中节点数目在范围 [0, 2000] 内。倒转代码：return ans[::-1]102题基础上结果倒转。输入：root = [1]输入：root = []
2025-04-12 09:50:23
336
原创 102.二叉树的层序遍历- 力扣(LeetCode)
第3层：q = [4, 5] → 处理 4, 5 → vals = [4, 5] → q = [] → ans = [[1], [2, 3], [4, 5]]第2层：q = [2, 3] → 处理 2, 3 → vals = [2, 3] → q = [4, 5] → ans = [[1], [2, 3]]第3层：cur = [4, 5] → vals = [4, 5] → nxt = [] → ans = [[1], [2, 3], [4, 5]]最终结果：[[1], [2, 3], [4, 5]]。
2025-04-12 09:37:11
367
原创 94.二叉树的中序遍历- 力扣(LeetCode)
如果为空了，也就是root是空节点了，说明当前子树的左节点都已经遍历完了，可以开始将左节点值加到res中了，从stack中弹出最近遍历到的节点，将节点值加到res中后让root = root.right。但中序遍历要先存左节点，所以是一直遍历左节点直到左节点为空，然后从栈中弹出上一个节点，这个节点将是当前子树的最左节点，将该节点的值存到res中，然后再令root = root.right。进入 inorder(3)，递归调用 inorder(3.left)（即 inorder(None)），返回。
2025-04-11 16:21:30
737
原创 90.子集II- 力扣(LeetCode)
1.首次遇到元素（如 1 和第一个 2）：将元素添加到 所有现有子集（res）中，生成新子集。例如：1 添加到空集生成 [1]；第一个 2 添加到 [] 和 [1] 生成 [2] 和 [1,2]。2.遇到重复元素（如第二个 2）：仅将元素添加到 上一轮生成的新子集（cur）中。例如：第二个 2 添加到上一轮的 [2] 和 [1,2]，生成 [2,2] 和 [1,2,2]，而不会重复生成 [2]。
2025-04-10 21:32:57
420
原创 78.子集- 力扣(LeetCode)
回到 helper(0, [])，处理 j=1（元素2），调用 helper(2, [2])，添加 [2]，再处理 j=2（元素3），调用 helper(3, [2, 3])，添加 [2, 3]。处理 2：生成 [[2], [2, 1]] → 合并后 res = [[], [1], [2], [2, 1]]处理 3：生成 [[3], [3, 1], [3, 2], [3, 2, 1]] → 合并后得到所有子集。输出：[[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]]
2025-04-10 18:54:16
988
原创 77.组合- 力扣(LeetCode)
combinations （组合）符合题意，创建列表[i for i in range(1, n + 1)]，组合个数k，返回的一个迭代器对象，每个元素tuple格式，转换格式即可得到答案。输出： [ [2,4], [3,4], [2,3], [1,2], [1,3], [1,4], ]生成可迭代对象中所有长度为 r 的无重复元素组合（不考虑顺序，元素不重复）。生成可迭代对象中所有长度为 r 的可重复元素组合（不考虑顺序，元素可重复）。生成可迭代对象中所有长度为 r 的排列（考虑顺序，元素不重复）。
2025-04-10 13:59:46
481
原创 57.插入区间- 力扣(LeetCode)
给你一个 无重叠的 ，按照区间起始端点排序的区间列表 intervals，其中 intervals[i] = [starti, endi] 表示第 i 个区间的开始和结束，并且 intervals 按照 starti 升序排列。输入：intervals = [[1,2],[3,5],[6,7],[8,10],[12,16]], newInterval = [4,8]解释：这是因为新的区间 [4,8] 与 [3,5],[6,7],[8,10] 重叠。输出：[[1,2],[3,10],[12,16]]
2025-04-09 21:49:26
634
原创 56.合并区间- 力扣(LeetCode)
再次利用区间按照左端点排序的性质，更后面的区间的左端点也大于 6，无法与当前合并区间相交，所以当前合并区间 [1,6] 就固定下来了，把新的合并区间 [8,10] 加入答案。遍历到 intervals[3]=[15,18]，由于左端点 15 大于当前合并区间的右端点 10，无法合并（两个区间不相交），我们找到了一个新的合并区间 [15,18] 加入答案。输入：intervals = [[1,3],[2,6],[8,10],[15,18]]输出：[[1,6],[8,10],[15,18]]
2025-04-08 13:50:11
456
原创 53.最大子数组和- 力扣(LeetCode)
设动态规划列表 dp ，dp[i] 代表以元素 nums[i] 为结尾的连续子数组最大和。为何定义最大和 dp[i] 中必须包含元素 nums[i] ：保证 dp[i] 递推到 dp[i+1] 的正确性；如果不包含 nums[i] ，递推时则不满足题目的 连续子数组 要求。
2025-04-06 13:54:50
354
原创 49.字母异位词分组- 力扣(LeetCode)
如果把 aab,aba,baa 按照字母从小到大排序，我们可以得到同一个字符串 aab。而对于每种字母出现次数不同于 aab 的字符串，例如 abb 和 bab，排序后为 abb，不等于 aab。输入: strs = ["eat", "tea", "tan", "ate", "nat", "bat"] 输出: [["bat"],["nat","tan"],["ate","eat","tea"]]根据这一点，我们可以用哈希表来分组，把排序后的字符串当作 key，原字符串组成的列表（即答案）当作 value。
2025-04-05 19:30:00
160
原创 46.全排列- 力扣(LeetCode)
遍历所有可能的元素选择（j 从 0 到 n-1）对于未被使用的元素，执行选择操作，递归处理下一层（i+1），最后执行撤销操作，恢复状态。输出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]i == 3，保存排列 [1, 2, 3]，回溯恢复 used[2] = False。在 dfs(2) 中，选择 j=1（值 2），保存排列 [1, 3, 2]。在 dfs(1) 中，选择 j=1（值 2），递归调用 dfs(2)。输出：[[0,1],[1,0]]
2025-04-05 15:45:51
212
原创 35.搜索插入位置- 力扣(LeetCode)
给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。有序数组，采用二分查找可以有O(log n)的时间复杂度。输入: nums = [1,3,5,6], target = 5。输入: nums = [1,3,5,6], target = 2。输入: nums = [1,3,5,6], target = 7。请必须使用时间复杂度为 O(log n) 的算法。nums 为 无重复元素 的 升序 排列数组。
2025-04-05 14:37:15
145
原创 25.K 个一组翻转链表 - 力扣(LeetCode)
给你链表的头节点 head ，每 k 个节点一组进行翻转，请你返回修改后的链表。k 是一个正整数，它的值小于或等于链表的长度。如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。你不能只是单纯的改变节点内部的值，而是需要实际进行节点交换。输入：head = [1,2,3,4,5], k = 2输出：[2,1,4,3,5]输入：head = [1,2,3,4,5], k = 3输出：[3,2,1,4,5]链表中的节点数目为 n。
2025-04-05 14:10:00
108
原创 92.反转链表 II- 力扣(LeetCode)
给你单链表的头指针 head 和两个整数 left 和 right ，其中 left <= right。请你反转从位置 left 到位置 right 的链表节点，返回 反转后的链表。这道题是206题反转链表的进阶版，指定了反转链表内部的范围，在此基础上考虑指定范围反转后的内部链表与外部链表链接关系。输入：head = [1,2,3,4,5], left = 2, right = 4。输入：head = [5], left = 1, right = 1。输出：[1,4,3,2,5]链表中节点数目为 n。
2025-04-03 09:15:10
362
原创 206.反转链表- 力扣(LeetCode)
给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。只需要改变链表的next指针的指向，直接将链表反转。输入：head = [1,2,3,4,5]链表中节点的数目范围是 [0, 5000]输入：head = [1,2]输出：[5,4,3,2,1]输入：head = []
2025-03-31 10:01:48
117
原创 27.移除元素- 力扣(LeetCode)
你的函数应该返回 k = 5，并且 nums 中的前五个元素为 0,0,1,3,4。然后返回 nums 中与 val 不同的元素的数量。你的函数函数应该返回 k = 2, 并且 nums 中的前两个元素均为 2。更改 nums 数组，使 nums 的前 k 个元素包含不等于 val 的元素。nums 的其余元素和 nums 的大小并不重要。= val，则更新 nums[k]=nums[i]，然后k+1。把 nums 中的不等于 val 的数，依次填在 0,1,2,…如果所有的断言都通过，你的解决方案将会。
2025-03-31 08:51:45
413
原创 24.两两交换链表中的节点- 力扣(LeetCode)
给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。输入：head = [1,2,3,4] 输出：[2,1,4,3]调整指针：dummy -> 2 -> 1 -> 3。调整指针：1 -> 4 -> 3 -> None。pre指向dummy，cur指向1，t指向2。最终结果：2 -> 1 -> 4 -> 3。输入：head = [1] 输出：[1]输入：head = [] 输出：[]cur指向3，t指向4。
2025-03-29 14:13:48
344
原创 22.括号生成- 力扣（LeetCode）
如果当前左括号剩余数量小于右括号（left < right），说明已添加的左括号多于右括号，此时可安全添加右括号，递归调用减少右括号数量，路径添加右括号。产生右分支的时候，还受到左分支的限制，右边剩余可以使用的括号数量一定得在严格大于左边剩余的数量的时候，才可以产生分支；输入：n = 3 输出：["((()))","(()())","(())()","()(())","()()()"]如果还有左括号可用（left > 0），则递归调用，减少左括号数量，路径添加左括号。left：剩余可用的左括号数量。
2025-03-29 10:25:16
462
原创 21.合并两个有序链表- 力扣（LeetCode）
比较 list1和 list2的节点值，如果 list1的节点值小，则把 list1加到新链表的末尾，然后把 list1替换成它的下一个节点。如果两个节点值一样，那么把谁加到新链表的末尾都是一样的，不妨规定把 list1加到新链表末尾。cur.next = list2 → 最终链表 dummy -> 1 -> 2 -> 3 -> 4。cur.next = list1 → 新链表为 dummy -> 1 -> 2 -> 3。cur.next = list2 → 新链表为 dummy -> 1 -> 2。
2025-03-28 20:34:43
484
原创 2.两数相加- 力扣（LeetCode）
递归调用处理 l1.next 和 l2.next（若 l2 存在），并传递新的进位 s// 10 #在代码中确保l1非空，可以不用考虑l1与l2的长度问题。当 l1 和 l2 均为 None 时，若存在进位 carry，则创建新节点存储进位，结束递归。若 l1 为空，交换 l1 和 l2，确保后续逻辑中 l1 非空，统一处理逻辑。输入：l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]输入：l1 = [2,4,3], l2 = [5,6,4]输出：[8,9,9,9,0,0,0,1]
2025-03-25 23:30:00
399
原创 1. 两数之和- 力扣（LeetCode）
这种方法的时间复杂度为O(n)，其中n是数组的长度，因为只需遍历一次数组。：如果差值存在，说明我们找到了两个数，它们的和等于目标值，直接返回它们的索引。如果不存在，则将当前元素及其索引存入哈希表中，继续遍历。如果target - x存在于哈希表中，返回对应的索引和当前索引。target - x是目标值与当前元素的差值，我们需要检查这个差值是否存在于哈希表中。使用enumerate遍历数组，j是当前元素的索引，x是当前元素的值。：对于每个元素，计算目标值与当前元素的差值，检查该差值是否存在于哈希表中。
2025-03-25 17:50:58
433
空空如也
空空如也
TA创建的收藏夹 TA关注的收藏夹
TA关注的人