- 博客(3555)
- 资源 (3)
- 收藏
- 关注
RSS订阅
原创 1个在线全科家教平台的 HTML5 Demo
https://mp.weixin.qq.com/s/z22g5-MSgS1uOMb-trgx9w
2024-12-24 00:18:40
713
1
原创 Kubernetes Containerd ctr、crictl、nerdctl -容器和镜像操作命令工具
k8s 镜像和容器的操作工具的命令工具的使用详解
2022-12-11 19:52:54
15526
原创 Kubernetes.K8S.Cluster.1主 2 从. 2C 4G.CentOS7.6. 搭建日志.OK
Kubernetes.K8S.Cluster. 1主 2从2C 4G. CentOS7.6
2022-01-10 16:21:29
2821
1
原创 DeepSeek LeetCode 538. 把二叉搜索树转换为累加树 Java实现
关键观察：BST 的中序遍历是升序，那么反中序遍历（右 → 根 → 左）就是降序。· 最坏情况（链状树）递归栈可能达 O(n)，若树很深建议用迭代或 Morris。题目要求：每个节点的值替换为原树中大于等于该节点值的所有节点值之和。反中序遍历顺序：8, 7, 6, 5, 4, 3, 2, 1, 0。· Morris 遍历每个节点最多访问两次，总时间仍是 O(n)。递归 O(n) O(h)，h 为树高（递归栈）Morris 遍历（O(1) 空间，进阶）迭代 O(n) O(h)（显式栈）
2026-11-06 08:50:02
26
原创 DeepSeek LeetCode 537. 复数乘法 Java实现
注意输入中虚部可能为负（如 “1±1i”），所以不能简单地用 split(“\+”)，因为负号 - 会被误处理。输出时 LeetCode 期望的格式就是 “实部+虚部i”，虚部为负时会呈现 “±1i” 的形式，直接字符串拼接即可。· 空间复杂度：O(n + m)，split 会创建数组（若不计此开销则为 O(1)）。· 时间复杂度：O(n + m)，n、m 分别是两个字符串的长度，只做一次扫描解析。LeetCode 537. 复数乘法 - Java 实现。
2026-11-06 08:48:41
49
原创 DeepSeek LeetCode 535. TinyURL 的加密与解密 Java实现
面试首选方法一：自增 ID + Base62 + 哈希表，兼顾简洁、无冲突、可逆、短码紧凑，并能自然延伸讨论分布式 ID、冲突处理、缓存等系统设计问题。不需要真正压缩，只要保证 decode(encode(url)) == url 即可。· String encode(String longUrl)：把长 URL 转成短 URL。哈希表 + Base62 自增 短（随 id 增长） 无 是 ⭐⭐⭐⭐⭐。方法一：哈希表 + 自增 ID + Base62 编码（推荐）方法三：最简版（直接哈希表 + 自增）
2026-11-06 08:44:38
136
原创 DeepSeek LeetCode 532. 数组中的 k-diff 数对 Java实现
例如 nums = [3, 1, 4, 1, 5], k = 2，数对是 (1,3)、(3,5)，答案是 2（两个 1 只算一个）。· k = 0 时：x - 0 == x，当 x 第二次出现时 seen 已含 x，把 x 加入 pairs；之后再出现不会重复加入。· k = 0 时，diff == 0 意味着 nums[i] == nums[j]，跳过重复后每个值只会计一次，天然正确。在数组 nums 中找不同的数对 (i, j)，满足 i < j 且 |nums[i] - nums[j]| == k。
2026-11-06 08:43:11
174
原创 DeepSeek LeetCode 529. 扫雷游戏 Java实现
‘E’ 就返回。因为一旦某格被改成 ‘B’ 或数字后就不再是 ‘E’，天然起到"已访问"标记的作用，不需要额外的 visited 数组。关键点：BFS 中入队前把 ‘E’ 改成 ‘B’，否则同一格可能被多次入队（多个 0 邻居都扩散到它）。只统计 ‘M’，不要统计 ‘X’（本题初始棋盘只有 M/E，点到 M 直接结束，所以不会出现 X 在周围的情况，但严格来说统计 ‘M’ 即可）。· 数量 == 0 → 改为 ‘B’，并递归/扩散揭露周围所有未揭开的 ‘E’· 点到 ‘M’：改为 ‘X’，游戏结束。
2026-11-06 08:41:31
144
原创 DeepSeek LeetCode 528. 按权重随机选择 Java实现
TreeMap.higherEntry(target) 返回严格大于 target 的最小 key，正好对应二分结果。随机生成 r ∈ [0, total)，在前缀和数组中二分查找第一个 > r 的位置 idx，idx 就是答案。命中概率：下标 0 → 1/6，下标 1 → 3/6，下标 2 → 2/6，正好等于权重比例。因为每个下标对应的区间长度正好等于它的权重，所以命中概率 = 权重 / 总权重。· pickIndex：O(log n)（二分查找）· 空间：O(n)（前缀和数组）
2026-11-05 08:52:16
123
原创 DeepSeek LeetCode 526. 优美的排列 Java实现
dp[mask] 表示使用 mask 中数字填充前 popcount(mask) 个位置的方法数。从位置 1 到 n 依次填数字，用一个 used 数组标记数字是否已使用。尝试把未使用的数字 num 放到 pos，如果满足整除条件，则转移。· n ≤ 15 时，回溯法代码简单、实际运行很快，面试中更常写。· 时间复杂度：最坏 O(n!· 状态压缩 DP 思路更系统，适合展示动态规划能力。· 空间复杂度：O(n)，递归栈和 used 数组。· 时间复杂度：O(n * 2^n)· 空间复杂度：O(2^n)
2026-11-05 08:51:23
248
原创 DeepSeek LeetCode 523. 连续的子数组和 Java实现
初始化 map.put(0, -1)，这样当下标 i 的余数为 0 时，对应区间为 nums[0…i]，长度 = i - (-1) = i + 1，方便统一判断。+ nums[i]。因此只要两个下标 i < j 的前缀和模 k 的余数相同，且 j - i >= 2（子数组长度至少为 2），就返回 true。2 4 29 5 5 已存在 i - map[5] = 2 - 0 = 2 >= 2 → 返回 true。· 空间复杂度：O(min(n, k))，哈希表最多存 min(n, k) 个不同余数。
2026-11-05 08:51:01
79
原创 DeepSeek LeetCode 525. 连续数组 Java实现
初始 {0: -1} 必不可少：例如 [0, 1] 整体合法时，到下标 1 前缀和回到 0，用 1 - (-1) = 2 得到正确长度。+ nums[i-1]（把 0 当 -1 之后的和）。也就是说，两个位置的前缀和相等，它们之间的子数组就满足 0、1 数量相等。· 那么"0 和 1 数量相等"就等价于"该子数组的元素之和为 0"。· 空间复杂度：O(n)，哈希表最多存储 n + 1 个不同前缀和。思路：把 0 变成 -1，转成"和为 0 的最长子数组"· 把 0 看成 -1，1 看成 +1；
2026-11-05 08:50:07
60
原创 DeepSeek LeetCode 524. 通过删除字母匹配到字典里最长单词 Java实现
时间复杂度：O(d * L)，其中 d 为字典大小，L = |s| + 最长单词长度；排序版本额外有 O(d log d) 的排序开销。题目本质是：在字典中找出所有是 s 的子序列的单词，在这些单词中返回长度最大的；· 排序不能简单地只按长度降序，因为同长度下字典序要求最小，所以要按 (长度降序, 字典序升序) 复合排序。· 子序列判定：只需保持两个指针单向扫描，O(|word| + |s|) 时间。· 空间复杂度：O(1)（不计输入），排序版本为 O(log d) 栈空间。
2026-11-04 08:44:49
228
原创 DeepSeek LeetCode 522. 最长特殊序列 II Java实现
反过来，如果 s 是某个其他字符串的子序列，那么 s 的所有子序列也都是那个字符串的子序列，因此都不可能成为特殊序列。· 时间复杂度：O(n^2 * L)，其中 n 是字符串个数，L 是字符串最大长度；注意：相同内容的字符串会互相成为对方的子序列，因此重复字符串不会被误判为特殊序列。如果字符串 s 本身不是任何其他字符串的子序列，那么 s 本身就是特殊序列。特殊序列是某个字符串的子序列，且不能是其他任何字符串的子序列。· 空间复杂度：O(1)（不计排序所需空间）。
2026-11-04 08:44:30
297
原创 DeepSeek LeetCode 519. 随机翻转矩阵 Java实现
这样，每个仍在区间内的索引都等概率对应一个尚未被翻转的格子，而且每次 flip() 的时间是 O(1)，空间只随实际翻转次数增长。reset() 直接清空哈希表并恢复 remaining，同样是 O(1)。优化做法是把二维坐标压成一维索引，但只维护一个哈希表来记录“交换关系”，而不真正创建长度为 m \times n 的数组。其中空间 O(k) 只在 flip 实际发生后才增长，reset 后立即归零，符合题目对空间优化的要求。flip() O(1) 平均 O(k)，k 为累计翻转次数。
2026-11-04 08:43:45
233
原创 DeepSeek LeetCode 518. 零钱兑换 II Java实现
观察：dp[i][j] 只依赖于 dp[i-1][j] 和 dp[i][j-coin]（同一行的左侧），因此可以压缩成一维——这就是推荐写法。· 如果顺序颠倒（排列数）会得到 9 种（把 2+1+1+1 和 1+1+1+2 都算作不同方案）· 与 322 题（零钱兑换）的区别：322 求的是最少硬币数，本题求的是方案总数。外层硬币 / 内层金额（正序） 每种硬币"逐个加入"，不会重复计算顺序 ✅ 组合数。示例：coins = [1, 2, 5], amount = 5。amount = 0 1（空方案）
2026-11-04 08:42:04
193
原创 DeepSeek LeetCode 516. 最长回文子序列 Java实现
⚠️ pre 的更新时机是易错点：必须先 temp = dp[j] 把"旧值"（即 dp[i+1][j]）存下来，等 dp[j] 用完后，再把 pre = temp 供下一列 j+1 用作 dp[i+1][(j+1)-1] = dp[i+1][j]。j] 的最长回文子序列长度。遍历顺序的关键：dp[i][j] 依赖 dp[i+1][j-1]、dp[i+1][j]、dp[i][j-1]，即依赖更长区间（i 更大、j 更小）。区间 DP（二维） O(n²) O(n²) ⭐⭐⭐⭐⭐ 面试首选，逻辑最清晰。
2026-11-04 08:40:47
262
原创 DeepSeek LeetCode 515. 在每个树行中找最大值 Java实现
BFS 逐层扫，size 定边界，每层取 max（初始 Integer.MIN_VALUE），是本题最标准也最不易错的写法。DFS 也能做，靠"层号 == 列表长度"来第一次占位，之后的节点更新该层最大值。最坏空间都是 O(n)。DFS 在链状树时只占 O(h) = O(n) 的递归栈（比 BFS 的 O(1) 宽还占得多一些），BFS 在满二叉树时占 O(n/2)。DFS 的时间也是 O(n)，空间取决于树高 O(h)。DFS 前序 O(n) O(h)（树高） 代码短，需理解"层号 == 长度"判定。
2026-11-03 08:46:05
414
原创 DeepSeek LeetCode 513. 找树左下角的值 Java实现
最后一层的最左节点：BFS 每层从左到右遍历、记录每层第一个节点，最后一层第一个即答案；或 DFS 前序先左后右，用严格大于的深度判断记录"每层第一次到达的节点"。第一次到达更深的深度时，当前节点就是该深度最左的节点（因为先遍历左边）。注意：是"最底层"的"最左边"，不是整棵树的最左节点。核心：逐层遍历，每层从右往左入队，那么最后一个出队/访问的节点就是最后一层最左节点。或者更简单：每层从左往右遍历，记录每层第一个节点，最后一层的第一个节点就是答案。给定二叉树根节点 root，返回最底层最左边节点的值。
2026-11-03 08:45:32
196
原创 DeepSeek LeetCode 508. 出现次数最多的子树元素和 Java实现
给定二叉树根节点 root，统计每棵子树的元素之和（子树元素和 = 以该节点为根的子树所有节点值之和），返回出现次数最多的子树元素和。Map.merge(key, 1, Integer::sum) 等价于：map.put(key, map.getOrDefault(key, 0) + 1)，只是更简洁。后序遍历算子树和 + 哈希表计数 + 边算边维护最大值，最后筛出出现次数等于 maxCount 的所有子树和。· 子树和：2（节点 2）、-3（节点 -3）、4（节点 5 的整棵树：5+2-3=4）
2026-11-03 08:34:54
151
原创 DeepSeek LeetCode 503. 下一个更大元素 II Java实现
注意：2n - 1 次遍历中，前 n 次是正常入栈，后 n - 1 次的作用只是查找、弹出，并不是真的再把下标压进去（其实压了也没关系，因为后面不会再被用到，只是栈会变长一点点）。最后一位 i = 2n - 1 对应的下标是 n - 1，它的"下一个更大元素"只可能在 [n, 2n - 2] 中，正好覆盖了所有环回的可能，不需要再多走一圈。栈存下标（防重复值），比较用严格 <，答案默认 -1。核心技巧：把数组"逻辑上"翻倍成 2n 长（nums[i % n]），这样环形问题就转化为线性问题。
2026-11-03 08:34:16
106
原创 千问 LeetCode 453. 最小操作次数使数组元素相等 Java实现
这道题和前面几道一样，都属于“换个角度看操作”的类型。刷到这种题时，可以重点记一下：加 n-1 个 / 减 1 个 / 排序 / 贪心，经常能互相转化。需要我接着为你讲解 LeetCode 462. 最小操作次数使数组元素相等 II 的 Java 实现吗？这道题的关键是等价转换：每次让 n - 1 个元素加 1，等价于每次让 1 个元素减 1。所以最优策略就是把所有数都降到数组最小值，答案就是每个元素与最小值的差之和。
2026-11-03 08:33:50
134
原创 DeepSeek LeetCode 498. 对角线遍历 Java实现
按 k = i + j 分组，偶数对角线从下往上、奇数对角线从上往下，起点用 min(k, m-1) / max(0, k-n+1) 夹到矩阵内即可。两种方法时间复杂度相同（必须访问 m·n 个元素），面试中两种都可，推荐方法一，边界条件更少出错。方法二：坐标模拟 O(m·n) O(1)（除返回值） 代码短，但边界判断需谨慎。方法一：按对角线枚举 O(m·n) O(1)（除返回值） 逻辑直白，边界清晰。规则：编号从 0 开始，偶数号对角线从下往上，奇数号对角线从上往下。· 根据 k 的奇偶决定遍历方向。
2026-11-02 08:51:56
441
原创 DeepSeek LeetCode 494. 目标和 Java实现
于是问题转化为：从 nums 中选若干个数，使其和恰好为 P 的方案数，这就是经典的 0-1 背包计数问题。复杂度： 时间 O(n × sum)，空间 O(n × sum)（记忆化状态数）。· 时间：O(n × P)，其中 P = (sum + target) / 2。· (sum + target) 为奇数 → 无解（P 必须是整数）记忆化 DFS O(n·sum) O(n·sum) ⭐⭐⭐⭐。0-1 背包（一维） O(n·P) O§ ⭐⭐⭐⭐⭐。二维 DP O(n·P) O(n·P) ⭐⭐⭐。
2026-11-02 08:46:37
110
原创 DeepSeek LeetCode 491. 非递减子序列 Java实现
因为同一层的两个相同数字（比如 [4, 7, 6, 7] 中的两个 7）选择它们之后接下去的选择范围完全不同吗？不，是相同的 —— 它们后面可选的元素完全一致，因此产生的子序列完全相同，必须去重。· 时间复杂度：最坏情况下 O(2^n * n)，其中 n 为数组长度（构造每个答案需 O(n)），但由于去重剪枝，实际远小于此上界。[4,6,7] 和 [4,6,7]（来自两个不同的 7）会被 used 去重，只保留一份，符合题意。· 空间复杂度：O(n)，递归深度为 n，used 集合每层最多存 n 个元素。
2026-11-02 08:46:00
301
原创 千问 LeetCode 486. 预测赢家 Java实现
这道题和 LeetCode 877. 石子游戏 几乎一样（877 保证偶数长度且总数为奇数，所以答案恒为 true），另外 LeetCode 1406. 石子游戏 III 也是同样的“分差 DP”套路，只是变成了一维后缀。核心在于定义状态为“当前玩家能比对手多拿多少分”，而不是各自拿了多少分——这样就能把双方的最优选择统一成一个取最大值的式子。空间 O(n²) / O(n) / O(n²)（递归栈 O(n)）时间 O(n²)，共 n²/2 个状态，每个 O(1)方法二：空间优化到 O(n)
2026-11-02 08:45:27
163
原创 DeepSeek LeetCode 481. 神奇字符串 Java实现
用一个指针 i 表示「当前正在解释的组长度」在 s 中的下标，另一个指针 j 表示「下一个要写入的位置」，字符在 ‘1’ 和 ‘2’ 之间交替。· 初始 s = “122”：第 0 组是 ‘1’（长度 s[0]=1），第 1 组是 ‘22’（长度 s[1]=2）。因为 s 是自描述的，且每组至少长度 1，所以「读 s[i]」时 s[i] 一定已经被写出来了（i 始终小于 j）。长度序列 1,2,2,1,1,2,1,2,2,1,…步骤 i s[i] num 追加后 s j res。执行过程示例（n = 6）
2026-11-02 08:44:04
153
原创 DeepSeek LeetCode 478. 在圆内随机生成点 Java实现
原因是面积元是 dA = r·dr·dθ，半径越大对应的面积越大，所以半径应按 √U 分布而不是线性。证明：距圆心 R 内的面积占总体比例 F® = πR² / πr² = (R/r)²，由反函数采样 R = r·√U。面试中建议答极坐标法，并说明 sqrt 的数学原因，这是这题最大的加分点。极坐标 + sqrt O(1) 确定 O(1) 无循环，最稳。拒绝采样 O(1) 期望 O(1) 实现直观，最坏情况无上界。实现二：拒绝采样（同样正确，期望 O(1)）关键点在于「均匀」二字。方法 时间 空间 备注。
2026-11-01 13:58:25
194
原创 DeepSeek LeetCode 477. 汉明距离总和 Java实现
任意一个「1」和一个「0」的组合都会在这一位上产生 1 个距离，所以这一位对总和的贡献是 ones * (n - ones)把所有位（题目数据 nums[i] <= 10^9 < 2^30，遍历 0~30 位即可）的贡献累加。· 时间复杂度：O(31 * n)，即 O(n)，n 为数组长度。· 第 1 位：1 的个数 2，0 的个数 1 → 2×1 = 2。· 第 2 位：1 的个数 2，0 的个数 1 → 2。· 第 3 位：1 的个数 1，0 的个数 2 → 2。· 空间复杂度：O(1)。
2026-11-01 13:58:05
173
原创 DeepSeek LeetCode 475. 供暖器 Java实现
二分写法对每个房子做一次 O(log m) 查找，总复杂度 O(n log m + m log m)，稍慢于双指针，但同样正确且好理解。· 左右候选：heaters[j] 是右侧最近的，heaters[j-1] 是左侧最近的，取两者距离较小值作为该房子的最近距离；对每个房子，只需要找到离它最近的供暖器，然后记录所有房子到其最近供暖器距离的最大值，就是需要的最小加热半径。· 对当前房子，最近供暖器只可能是 heaters[j-1]（左边）或 heaters[j]（右边）；扫描部分为 O(n + m)。
2026-11-01 13:57:48
166
原创 DeepSeek LeetCode 474. 一和零 Java实现
内层双重循环逆序：i 从 m 递减到 zeros，j 从 n 递减到 ones。逆序保证 dp[i - zeros][j - ones] 是上一轮（未选当前字符串）的状态，从而实现 0-1 背包；背包有两个容量维度：m 个 0 和 n 个 1。· 若某个字符串的 zeros > m 或 ones > n，内层循环直接不会执行，等价于跳过，无需特判；定义 dp[i][j]：使用至多 i 个 0 和 j 个 1 时，最多能选的字符串数量。· 空间复杂度：O(m * n)，二维 DP 数组。
2026-11-01 13:57:32
243
原创 DeepSeek LeetCode 473. 火柴拼正方形 Java实现
idx == nums.length 时直接返回 true：因为每根火柴放入时都保证 sides[i] + nums[idx] <= target，所有火柴放完后总长度恰好是 4 * target，所以四条边必然都等于 target。· 剪枝 4 的判断：sides[i] + nums[idx] == target 表示放入之后该边正好填满。· 剪枝 3 的判断：sides[i] 已在上一行减回去，所以此时 sides[i] == 0 表示放入之前该边为空。空边都放不下，其他空边也一样，直接失败。
2026-11-01 13:57:06
88
原创 DeepSeek LeetCode 470. 用 Rand7() 实现 Rand10() Java实现
期望调用次数 ≈ 2 × (40/49) + 4 × (9/49)(60/63) + 6 × (9/49)(3/63)(20/21) + …注意 (x - 41) * 7 + rand7() 中 x - 41 的范围是 0~8，(x-41)*7 范围 0~56，加 rand7() 后为 1~63，确保每个值等概率。(rand7()-1) 生成 0~6 的 7 进制高位，rand7() 生成 1~7 的低位，组合得到 1~49，每个值概率都是 1/49。第二次成功 (9/49) * (60/63) 4。
2026-10-31 07:19:05
251
原创 DeepSeek LeetCode 468. 验证IP地址 Java实现
注意：String.split(regex, -1) 的 -1 参数会保留尾部空串，便于正确统计段数。分别判断是否为 IPv4 或 IPv6，都不满足则返回 “Neither”。· 空间复杂度：O(n)，split 产生的数组开销。· 时间复杂度：O(n)，只遍历字符串常数次。
2026-10-31 07:18:42
4
原创 DeepSeek LeetCode 467. 环绕字符串中唯一的子字符串 Java实现
那么以字符 c 结尾的合法唯一子串数量就是 maxLen[c]，因为长度为 1, 2, …, maxLen[c] 的后缀各对应一个唯一子串。一个子串能出现在环绕字符串中，当且仅当它满足：相邻字符在字母表中连续递增，其中 ‘z’ 后面可以接 ‘a’。以每个字符 c 结尾的、满足环绕连续条件的最长子串长度 maxLen[c]· 时间复杂度：O(n)，其中 n 是字符串 p 的长度。· 空间复杂度：O(1)，只使用了长度为 26 的数组。
2026-10-31 07:18:19
214
原创 DeepSeek LeetCode 462. 最小操作次数使数组元素相等 II Java实现
也可以用双指针：排序后，每一对 nums[j] - nums[i] 的差值累加即可。· 排序后，最小值和中位数、最大值和中位数之间的差值，可以通过双指针两两配对累加。每次操作可以让某个元素 +1 或 -1，目标是让所有元素相等。· 原题方法签名返回 int，最后强转为 int。· 时间复杂度：O(n log n)，主要是排序。· 空间复杂度：O(log n)，排序递归栈开销。· 使用 long 累加，避免中间结果溢出。要使这个和最小，x 应取数组的中位数。两种写法本质相同，任选一种即可。
2026-10-31 07:17:58
173
原创 豆包 LeetCode 624. 数组列表中的最大距离 Android实现
数组都已排列，所以每个数组的最小值是arr[0]、最大值是。minmax关键点：必须先算完距离再更新min/max，否则会把当前数组和自己的两端配对，违反"不同数组"约束。：时间 O(m)，空间 O(1)。
2026-10-31 07:17:37
122
原创 DeepSeek LeetCode 464. 我能赢吗 Java实现
m ≤ 20，约 2×10^7 次操作，Java 中可过。若想节省空间，可把 int[] 换成 HashMap<Integer, Boolean>，只存访问过的状态，代价是常数更大。sum 溢出 m*(m+1)/2 在 m=20 时只有 210，不会溢出，但养成用 long 的习惯。m = 20 时 int[1<<20] 约 4MB，可接受。· 先手无论选 i（1~10），对手选 11-i 立即达到 11 → 先手必输。· 剪枝 1：10 >= 1，先手选 1 直接赢 → 返回 true ✓。
2026-10-30 08:47:28
169
原创 DeepSeek LeetCode 462. 最小操作次数使数组元素相等 II Java实现
每次同时移动一对 (nums[left], nums[right])，让它们相遇的最优位置就是中位数——移动 nums[right] - nums[left] 次。注意 453 题的等价转化：每次给 n-1 个元素 +1，等价于每次给 1 个元素 -1，因此目标是让所有元素降到最小值。453. 最小操作次数使数组元素相等 只能 +1（一次加 n-1 个元素） 选最小值，代价为 Σ(nums[i] - min)· 代价：|1-2| + |2-2| + |3-2| = 1 + 0 + 1 = 2 ✓。
2026-10-30 08:45:48
197
原创 DeepSeek LeetCode 457. 环形数组是否存在循环 Java实现
因此，可以直接将这些节点的值置为 0，后续遍历直接跳过，确保每个节点最多被访问一次，实现 O(n) 时间。但还需排除长度为 1 的自环（即 slow == nextIndex(slow)），这种环不满足题目 k > 1 的要求。最经典的解法是快慢指针（Floyd 判圈算法），配合原地标记优化，可以将时间复杂度控制在 O(n)，空间复杂度 O(1)。拓扑排序（BFS） O(n) O(n) 思路直观（删除出度为 0 的节点），但需要额外空间。快慢指针（本解） O(n) O(1) 面试首选，原地标记是关键优化。
2026-10-30 08:44:54
【Linux与PostgreSQL】高频面试题160道及线上故障排查手册：涵盖系统运维、数据库性能调优与自动化监控实战方案
2026-10-15
【Linux运维】高频面试题与线上故障排查方法论：涵盖基础命令、Shell脚本、系统性能、网络安全、容器化及数据库实战案例解析
2026-10-13
【Java持久层框架】MyBatis-Plus 3.5.x核心特性与线上问题排查指南：从基础注解到高并发场景下的分页优化、多租户数据隔离及生产环境常见故障诊断方法论
2026-10-10
空空如也
TA创建的收藏夹 TA关注的收藏夹
TA关注的人