- 博客(57)
- 收藏
- 关注
RSS订阅原创 78. 子集 - 力扣（LeetCode）
首先使用深度优先搜索（DFS）递归地构建每个子集。在每一步中，选择一个数字加入当前子集，或者跳过该数字。最后递归地处理下一个位置，直到所有可能的子集都被生成。返回该数组所有可能的子集（幂集）。 这道题是生成给定数字列表。
2025-04-11 14:53:16
213
原创 46. 全排列 - 力扣（LeetCode）
（Backtracking）来生成给定数字列表的所有排列。首先使用深度优先搜索（DFS）递归地构建每个排列。然后在每一步中，选择一个未被选中的数字，将其加入当前排列中。递归地处理下一个位置，直到排列构建完成。在递归返回时，恢复当前状态（回溯），以便尝试其他可能的选择。给定一个不含重复数字的数组。 这道题的思路是通过。
2025-04-11 14:31:08
424
原创 207. 课程表 - 力扣（LeetCode）
给定一个课程列表和它们的先修课程关系，判断是否可以完成所有课程。如果存在环形依赖（即课程之间形成一个循环），则无法完成所有课程。这道题的思路是通过深度优先搜索（DFS）和颜色标记法来检测图中是否存在环。在选修某些课程之前需要一些先修课程。请你判断是否可能完成所有课程的学习？，表示如果要学习课程。
2025-04-11 13:18:55
280
原创 200. 岛屿数量 - 力扣（LeetCode）
（陆地）组成的二维网格，计算网格中岛屿的数量。岛屿被定义为由相邻的陆地单元格组成的区域，相邻的单元格是上下左右四个方向相连的。遍历网格中的每个单元格，寻找未被访问的陆地单元格（值为。 DFS 的作用是将当前岛屿的所有相连单元格标记为已访问，避免重复计数。当找到一个未被访问的陆地单元格时，计数加1，并使用 DFS 标记与该单元格相连的所有陆地单元格为已访问（值为。递归检查当前单元格的上下左右四个方向，标记所有相连的陆地单元格。（水）组成的的二维网格，请你计算网格中岛屿的数量。将当前单元格的值设置为。
2025-04-11 08:56:45
353
原创 114. 二叉树展开为链表 - 力扣（LeetCode）
这道题的思想是通过递归的方式，将二叉树的左子树和右子树分别展平，然后调整当前节点的左右子树，将左子树移到右子树的位置，并将原来的右子树接回。最终，整个二叉树被展平为一个只包含右子节点的单链表。
2025-04-10 19:08:22
287
原创 230. 二叉搜索树中第 K 小的元素 - 力扣（LeetCode）
这道题通过定义一个深度优先搜索函数，用于中序遍历。中序遍历二叉搜索树会得到一个递增的有序序列，从而利用递归的方式找到第 k 小的元素。，请你设计一个算法查找其中第。小的元素（从 1 开始计数）。给定一个二叉搜索树的根节点。
2025-04-10 15:13:24
410
原创 98. 验证二叉搜索树 - 力扣（LeetCode）
这道题通过中序遍历的方式，检查二叉树是否为有效的二叉搜索树。如果在遍历过程中发现某个节点的值小于或等于前一个节点的值，则直接返回。，判断其是否是一个有效的二叉搜索树。给你一个二叉树的根节点。
2025-04-10 14:21:53
478
原创 102. 二叉树的层序遍历 - 力扣（LeetCode）
层序遍历是一种按层次顺序逐层访问二叉树节点的算法，从上到下、从左到右依次访问每个节点。（即逐层地，从左到右访问所有节点）。 给你二叉树的根节点。 这道题的思路是利用。
2025-04-10 13:17:05
422
原创 543. 二叉树的直径 - 力扣（LeetCode）
这里的路径长度是指路径上边的数量，而不是节点的数量。这道题的思想是利用深度优先搜索（DFS）递归地计算每个节点的最大链长，并在递归过程中更新全局变量。，记录当前找到的最长路径长度。这条路径可能经过也可能不经过根节点。是指树中任意两个节点之间最长路径的。给你一棵二叉树的根节点，返回该树的。就是二叉树的直径长度。由它们之间边数表示。 二叉树的直径是指。
2025-04-10 08:59:29
427
原创 101. 对称二叉树 - 力扣（LeetCode）
比较两个节点的值是否相等。递归比较左子树的左节点与右子树的右节点。递归比较左子树的右节点与右子树的左节点。只有当当前节点的值相等，并且左右子树的对应节点也对称时，才返回。如果一个节点为空，另一个节点不为空，说明当前这一对节点不对称，返回。如果两个节点都为空，说明当前这一对节点是对称的，返回。 这道题的思路为：设计一个递归函数。 给你一个二叉树的根节点。， 检查它是否轴对称。
2025-04-09 20:59:16
135
原创 226. 翻转二叉树 - 力扣（LeetCode）
思路为：先反转根节点的左右儿子，再反转左右儿子的左右子树及其内部的节点。，翻转这棵二叉树，并返回其根节点。给你一棵二叉树的根节点。
2025-04-09 20:32:59
193
原创 94. 二叉树的中序遍历 - 力扣（LeetCode）
中序遍历的顺序是：左子树 -> 根节点 -> 右子树。因此根据栈的先入后出原则，按照中序遍历的顺序将其右子节点、自身（标记为蓝色）、左子节点依次压入栈中。然后再依次弹出，即为左子树 -> 根节点 -> 右子树。 给定一个二叉树的根节点。
2025-04-09 19:48:38
422
原创 138. 随机链表的复制 - 力扣（LeetCode）
这类复制题的思路是哈希表遍历+两次遍历：第一次遍历原链表，创建所有新节点，并将原节点与新节点的映射关系存储在字典中。指针也都应指向复制链表中的新节点，并使原链表和复制链表中的这些指针能够表示相同的链表状态。指针指向原链表中 p.next 对应的新节点（通过字典查找），将新链表中对应节点的。节点组成，其中每个新节点的值都设为其对应的原节点的值。个节点组成的链表来表示输入/输出中的链表。的链表，每个节点包含一个额外增加的随机指针。，该指针可以指向链表中的任何节点或空节点。 返回复制链表的头节点。
2025-04-09 19:18:34
253
原创 24. 两两交换链表中的节点 - 力扣（LeetCode）
给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。 递归是一种将问题分解为更小子问题的方法。递归地进行同样的操作。最终，整个链表会通过递归调用被逐步交换完成。递归需要一个明确的终止条件，以避免无限递归。
2025-04-09 18:27:50
232
原创 2. 两数相加 - 力扣（LeetCode）
每次将两个节点的值与进位值相加，计算当前节点的值和新的进位值。使用哑巴节点简化链表的构建过程，确保所有边界情况（如链表长度不一致和最后的进位）都被正确处理。 将链表反过来看：这道题思路是通过迭代的方式将两个链表表示的数字相加，并返回结果链表。通过迭代的方式遍历链表。 你可以假设除了数字 0 之外，这两个数都不会以 0 开头。 请你将两个数相加，并以相同形式返回一个表示和的链表。的链表，表示两个非负的整数。它们每位数字都是按照。的方式存储的，并且每个节点只能存储。
2025-04-09 16:30:05
380
原创 240. 搜索二维矩阵 II - 力扣（LeetCode）
通过从矩阵的右上角开始搜索，利用矩阵的有序性（每行从左到右递增，每列从上到下递增），能够找到目标值或者确定目标值不在矩阵中。每次比较后，要么向下移动一行，要么向左移动一列，逐步缩小搜索范围，直到找到目标值或搜索范围超出矩阵边界。这道题的思想：比较每一行/列的最大值与。编写一个高效的算法来搜索。
2025-04-09 11:15:58
384
原创 54. 螺旋矩阵 - 力扣（LeetCode）
首先定义四个边界变量。输入：matrix = [[1,2,3,4],[5,6,7,8],[9,10,11,12]]遍历 matrix[1][2] 到 matrix[2][2]，添加到 res 中。遍历 matrix[2][1] 到 matrix[2][0]，添加到 res 中。遍历 matrix[1][0] 到 matrix[1][0]，添加到 res 中。输入：matrix = [[1,2,3],[4,5,6],[7,8,9]]输出：[1,2,3,4,8,12,11,10,9,5,6,7]
2025-04-09 10:48:40
685
原创 73. 矩阵置零 - 力扣（LeetCode）
如果 i 在 row 集合中（即 i == 0 或 i == 2），或者 j 在 col 集合中（即 j == 1 或 j == 2），则将该元素置零。输入：matrix = [[0,1,2,0],[3,4,5,2],[1,3,1,5]]输入：matrix = [[1,1,1],[1,0,1],[1,1,1]][4, 0, 0], # 第 1 行的第 1 和第 2 列被置零。输出：[[0,0,0,0],[0,4,5,0],[0,3,1,0]]输出：[[1,0,1],[0,0,0],[1,0,1]]
2025-04-08 21:15:01
341
原创 238. 除自身以外数组的乘积 - 力扣（LeetCode）
range(len(nums) - 2, -1, -1) 生成的序列是 2, 1, 0。计算每个位置左侧所有元素的乘积，存储在一个数组中。计算每个位置右侧所有元素的乘积，累积在一个变量中。输入: nums = [-1,1,0,-3,3]最终 res 变为 [24, 12, 8, 6]返回 res，即 [24, 12, 8, 6]。此时 res 变为 [1, 1, 2, 6]输入: nums = [1,2,3,4]输入数组是 [1, 2, 3, 4]输出: [0,0,9,0,0]之外其余各元素的乘积。
2025-04-08 15:05:51
290
原创 189. 轮转数组 - 力扣（LeetCode）
反转剩下的 4 个元素 [4,3,2,1]，得到 [1,2,3,4]。输入: nums = [1,2,3,4,5,6,7], k = 3。假设输入数组是 [1,2,3,4,5,6,7]，k=3。向右轮转 1 步: [7,1,2,3,4,5,6]向右轮转 2 步: [6,7,1,2,3,4,5]向右轮转 3 步: [5,6,7,1,2,3,4]旋转后的数组是 [5,6,7,1,2,3,4]。数组变为：[5,6,7,4,3,2,1]数组变为：[5,6,7,1,2,3,4]原数组：[1,2,3,4,5,6,7]
2025-04-08 14:09:27
366
原创 56. 合并区间 - 力扣（LeetCode）
合并 [5,7] 和 [6,8]，更新 res[-1][1] 为 8，res 变为 [[1,4], [5,8]]。合并 [1,3] 和 [2,4]，更新 res[-1][1] 为 4，res 变为 [[1,4]]。输入：intervals = [[1,3],[2,6],[8,10],[15,18]]排序后的区间列表是 [[1,3], [2,4], [5,7], [6,8]]。假设输入区间列表是 [[1,3], [2,4], [5,7], [6,8]]输出：[[1,6],[8,10],[15,18]]
2025-04-08 12:45:48
457
原创 53. 最大子数组和 - 力扣（LeetCode）
这样每一步都可以计算当前前缀和与最小前缀和的差值，这个差值就是当前可能的最大子数组和。最大子数组和可以通过找到某个位置的前缀和减去之前的最小前缀和来得到。，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。输入数组是 [−2, 1, −3, 4, −1, 2, 1, −5, 4]输入：nums = [-2,1,-3,4,-1,2,1,-5,4]res = 6，对应的最大子数组是 [4, -1, 2, 1]。解释：连续子数组 [4,-1,2,1] 的和最大，为 6。
2025-04-08 11:50:23
996
原创 239. 滑动窗口最大值 - 力扣（LeetCode）
假设输入数组为 nums = [1, 3, -1, -3, 5, 3, 6, 7]，k = 3。移除 deque 中所有小于 5 的元素（3, -1, -3），deque 变为空。的滑动窗口从数组的最左侧移动到数组的最右侧。窗口形成，记录 7 → res = [3, 3, 5, 5, 6, 7]。输入：nums = [1,3,-1,-3,5,3,6,7], k = 3。窗口形成，记录 6 → res = [3, 3, 5, 5, 6]。最终结果 res 为 [3, 3, 5, 5, 6, 7]。
2025-04-02 10:11:02
568
原创 560. 和为 K 的子数组 - 力扣（LeetCode）
检查 sums - k = 2 - 2 = 0 是否在 dic 中，存在，res += 1。检查 sums - k = 3 - 2 = 1 是否在 dic 中，存在，res += 1。检查 sums - k = 1 - 2 = -1 是否在 dic 中，不在，res 不变。更新 dic：{0: 1, 1: 1, 2: 1, 3: 1}。假设输入数组为 nums = [1, 1, 1]，k = 2。更新 dic：{0: 1, 1: 1, 2: 1}。输入：nums = [1,1,1], k = 2。
2025-04-02 09:19:49
314
原创 438. 找到字符串中所有字母异位词 - 力扣（LeetCode）
初始时，res 是空列表，cnt_p 是 {'a': 1, 'b': 1}，cnt_s 是空计数器。起始索引等于 0 的子串是 "cba", 它是 "abc" 的异位词。起始索引等于 6 的子串是 "bac", 它是 "abc" 的异位词。起始索引等于 2 的子串是 "ab", 它是 "ab" 的异位词。起始索引等于 0 的子串是 "ab", 它是 "ab" 的异位词。起始索引等于 1 的子串是 "ba", 它是 "ab" 的异位词。不考虑答案输出的顺序。输入: s = "abab", p = "ab"
2025-03-31 18:33:17
329
原创 42. 接雨水 - 力扣（LeetCode）
解释：上面是由数组 [0,1,0,2,1,0,1,3,2,1,2,1] 表示的高度图，在这种情况下，可以接 6 个单位的雨水（蓝色部分表示雨水）。left_max >= right_max，所以 res += 1 - 1 = 0，right -= 1。初始时，left = 0，right = 11，left_max = 0，right_max = 0。输入：height = [0,1,0,2,1,0,1,3,2,1,2,1]输入：height = [4,2,0,3,2,5]：更新为左边区域的最大高度。
2025-03-31 16:31:46
481
原创 11. 盛最多水的容器 - 力扣（LeetCode）
解释：图中垂直线代表输入数组 [1,8,6,2,5,4,8,3,7]。因为 height[left] == height[right]，right 减少到 5。因为 height[left] > height[right]，right 减少到 7。因为 height[left] > height[right]，right 减少到 4。因为 height[left] > height[right]，right 减少到 1。面积 = min(1, 7) * 8 = 1 * 8 = 8。
2025-03-31 10:37:03
793
原创 283. 移动零 - 力扣（LeetCode）
如果 nums[right] 是非零元素，交换 nums[left] 和 nums[right] 的值，并将 left 指针向右移动，指向下一个需要放置非零元素的位置。这种方法确保非零元素按顺序排列，而零元素被移动到数组的末尾。指向非零，交换两者的位置，将非零元素移动到前面，零元素移动到后面。）实现将非零元素向左移动，从而将零元素移动到数组的末尾。这样，非零元素会被移动到数组的前面，零元素会被移动到后面。指针向右移动，指向下一个需要放置非零元素的位置。移动到数组的末尾，同时保持非零元素的相对顺序。
2025-03-31 09:36:50
558
原创 128. 最长连续序列 - 力扣（LeetCode）
具体思想是通过集合的高效查找特性，快速判断元素是否存在，并通过遍历集合中的每个元素，寻找可能的连续序列起点，然后扩展序列并计算长度。假设输入数组是 [100, 4, 200, 1, 3, 2]，集合 set_nums 是 {100, 4, 200, 1, 3, 2}。序列长度是 5 - 1 = 4（序列是 [1, 2, 3, 4]）。输入：nums = [0,3,7,2,5,8,4,6,0,1]最终结果是 4，因为最长连续序列是 [1, 2, 3, 4]。是一个可能的连续序列的起点。
2025-03-31 08:48:22
465
原创 567. 字符串的排列 - 力扣（LeetCode）
当 right - left = 4 - 0 = 4，大于等于 len(s1) = 2，进入收缩循环。当 right - left = 5 - 1 = 4，大于等于 len(s1) = 2，进入收缩循环。检查 count == len(need)：2 == 2，满足条件，返回 True。window['b'] == need['b']，count 增加到 1。i 在 need 中，更新 window：window['a'] = 1。window['a'] == need['a']，count 增加到 2。
2025-03-29 12:43:12
721
原创 3. 无重复字符的最长子串 - 力扣（LeetCode）
当右指针指向的字符不在当前窗口中时，窗口向右扩展（右指针向右移动），并更新最长无重复子串的长度。right = 0：s[0] = 'a' 不在窗口 [0:0] 中，窗口扩展为 [0:1]，res = 1。right = 1：s[1] = 'b' 不在窗口 [0:1] 中，窗口扩展为 [0:2]，res = 2。right = 2：s[2] = 'c' 不在窗口 [0:2] 中，窗口扩展为 [0:3]，res = 3。right = 3：s[3] = 'a' 已在窗口 [0:3] 中，左指针向右移动到 1。
2025-03-29 09:53:11
474
原创 148. 排序链表 - 力扣（LeetCode）
调用 sortList(head)，链表为 4 → 2 → 1 → 3 → 5 → 6。比较 5 和 6，选择 5，结果链表为 1 → 2 → 3 → 4 → 5。比较 4 和 5，选择 4，结果链表为 1 → 2 → 3 → 4。最终合并后的链表为：1 → 2 → 3 → 4 → 5 → 6。假设有一个链表：4 → 2 → 1 → 3 → 5 → 6。最终结果应该是：1 → 2 → 3 → 4 → 5 → 6。比较 4 和 3，选择 3，结果链表为 1 → 2 → 3。
2025-03-29 09:15:34
688
原创 304. 二维区域和检索 - 矩阵不可变 - 力扣（LeetCode）
给定一个二维矩阵matrix，以下类型的多个请求：计算其子矩形范围内元素的总和，该子矩阵的为为。实现NumMatrix给定整数矩阵matrix进行初始化返回所描述的子矩阵的元素。输入:输出:解释:// return 8 (红色矩形框的元素总和)// return 11 (绿色矩形框的元素总和)// return 12 (蓝色矩形框的元素总和)最多调用104次sumRegion方法这道题是求解二维前缀和，用于快速计算二维矩阵中任意子矩阵的和。核心思想是预先计算一个二维前缀和数组。
2025-03-28 20:43:59
2048
原创 303. 区域和检索 - 数组不可变 - 力扣（LeetCode）
sumRange(1, 3) 对应的计算是 preSum[4] - preSum[1] = 10 - 1 = 9。sumRange(0, 2) 对应的计算是 preSum[3] - preSum[0] = 6 - 0 = 6。sumRange(2, 2) 对应的计算是 preSum[3] - preSum[2] = 6 - 3 = 3。所以，构造完成后的 preSum 数组是 [0, 1, 3, 6, 10]。假设我们有一个数组 nums = [1, 2, 3, 4]。内的所有元素之和，可以通过。
2025-03-28 14:46:40
757
原创 125. 验证回文串 - 力扣（LeetCode）
本题是判断一个字符串是否为回文的，回文是指正读和反读都相同的字符串。比较 'A' 和 'a'（忽略大小写后相同），移动指针 i 到 1，j 到 26。s[1] 是 ' '（空格，非字母数字），跳过，移动指针 i 到 2。比较 'm' 和 'm'（相同），移动指针 i 到 3，j 到 25。s[0] 是 'A'（字母），s[27] 是 'a'（字母）。s[2] 是 'm'（字母），s[26] 是 'm'（字母）。解释：在移除非字母数字字符之后，s 是一个空字符串 ""。字母和数字都属于字母数字字符。
2025-03-27 14:19:21
327
原创 18. 四数之和 - 力扣（LeetCode）
所以最终结果为 [[ -2, -1, 1, 2], [-2, 0, 0, 2], [-1, 0, 0, 1]]。假设输入数组为 nums = [1, 0, -1, 0, -2, 2]，目标值为 target = 0。通过移动这两个指针，可以高效地找到所有可能的后两个数，使得四个数的和等于目标值。输出：[[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]输入：nums = [1,0,-1,0,-2,2], target = 0。排序后的数组为 [-2, -1, 0, 0, 1, 2]。
2025-03-27 13:54:02
902
原创 15. 三数之和 - 力扣（LeetCode）
计算最大可能和：nums[i] + nums[-1] + nums[-2] = -4 + 2 + 1 = -1 < 0，说明无法找到和为0的组合，直接跳过。计算最小可能和：nums[i] + nums[i+1] + nums[i+2] = -4 + (-1) + (-1) = -6 < 0，继续。经过上述步骤，结果列表 res 中包含两个三元组：[ -1, -1, 2 ] 和 [ -1, 0, 1 ]，与预期输出一致。预期输出：[[ -1, -1, 2 ], [ -1, 0, 1 ]]
2025-03-27 10:44:06
793
原创 234. 回文链表 - 力扣（LeetCode）
然后将反转后的链表与前半段未反转的链表做比较，直到中间节点如果对应相同，则为回文数。将反转后的后半部分链表与原链表的前半部分逐个节点比较，如果所有对应节点的值都相等，则链表是回文的；fast 和 fast.next 都存在（fast 指向 1，fast.next 指向 2）。从中间节点开始，逐个将节点从原链表中取出，并将其插入到新链表的头部，从而实现反转。此时，反转后的后半部分链表为 1 -> 2 -> 3，pre 指向节点 1。此时，slow 指向节点 3，fast 指向节点 1。
2025-03-27 09:13:57
591
原创 25. K 个一组翻转链表 - 力扣（LeetCode）
首先统计链表的节点个数，这样可以知道是否还有足够的节点来进行分组反转。创建虚拟头节点：dummy.next = 1 -> 2 -> 3 -> 4 -> 5 -> None。这可以简化边界条件的处理，比如当链表为空或者只有一个节点时的操作。假设链表为 1 -> 2 -> 3 -> 4 -> 5 -> None，k=2。在每次处理时，通过一个循环逐个反转节点，保存当前节点的下一个节点到。最终链表为 2 -> 1 -> 4 -> 3 -> 5 -> None。：指向当前处理组的前一个节点，初始为虚拟头节点。
2025-03-26 18:04:39
999
空空如也
空空如也
TA创建的收藏夹 TA关注的收藏夹
TA关注的人