数据结构标签_DeepSeek技术社区

数据结构

DeepSeek LeetCode 82. 删除排序链表中的重复元素 II Rust实现

关键点：用 tail: &mut Box 作为"新链表尾指针"，每次保留节点后 tail = tail.next.as_mut().unwrap() 向后移动；· 空间复杂度：O(1)，只使用了常数个额外指针（返回的新链表本身可视为原地重建）。输入：1 -> 2 -> 3 -> 3 -> 4 -> 4 -> 5。1 1 false 接到 tail，tail 指向 1。2 2 false 接到 ta

稚辉君.MCA.P9.JAVA
2026-09-16 00:02:21

 150

#算法 #数据结构 #leetcode +2
DeepSeek LeetCode 107. 二叉树的层序遍历 II Java实现

使用队列进行正常层序遍历，每层结果用 LinkedList.addFirst() 插入到结果头部，即可实现自底向上。BFS 队列最多存一层的节点数，最坏 O(n)；面试中推荐方法一（BFS + 头插），逻辑清晰，无需最后反转，且直接得到自底向上的结果。给定二叉树，返回其节点值自底向上的层序遍历，即从叶子层到根层。正常层序遍历，把每层依次加入结果，最后整体反转。DFS O(n) O(h)，h 为树

 稚辉君.MCA.P9.JAVA
2026-09-16 00:02:03

 38

#后端 #leetcode #算法 +2
DeepSeek LeetCode 106. 从中序与后序遍历序列构造二叉树 Java实现

右子树 [inRoot + 1, inRight] [postLeft + leftSize, postRight - 1]左子树 [inLeft, inRoot - 1] [postLeft, postLeft + leftSize - 1]106 中序 + 后序后序最后一个后序 [postLeft, postLeft+leftSize-1]· 中序遍历：[[左子树中序], 根节点, [右子

 稚辉君.MCA.P9.JAVA
2026-09-16 00:01:50

 80

 1

#数据结构 #算法 #后端 +2
DeepSeek LeetCode 105. 从前序与中序遍历序列构造二叉树 Java实现

右子树 [preLeft + leftSize + 1, preRight] [inRoot + 1, inRight]左子树 [preLeft + 1, preLeft + leftSize] [inLeft, inRoot - 1]若不用 HashMap 而在中序中线性查找根，时间会退化为 O(n²)（如链状树）。递归 + HashMap O(n) O(n)（哈希表 + 递归栈）· 前序遍历：

稚辉君.MCA.P9.JAVA
2026-09-16 00:01:39

 74

 1

#后端 #leetcode #算法 +2
DeepSeek LeetCode 82. 删除排序链表中的重复元素 II Python3实现

LeetCode 82. 删除排序链表中的重复元素 II - Python3 实现。因为可能会删除头节点，所以使用哑节点（dummy）简化边界处理。· prev 指向最后一个确定保留下来的节点。· curr 用于遍历链表。Python3 代码。

稚辉君.MCA.P9.JAVA
2026-09-16 00:01:28

 160

 1

#python #后端 #算法 +2
DeepSeek LeetCode 81. 搜索旋转排序数组 II C#实现

当 nums[left] == nums[mid] == nums[right] 时，无法判断哪一半是有序的，此时只能收缩边界（left++、right–）。其余情况与 33 题一致：判断 mid 落在左半有序区还是右半有序区，然后在有序区间内判断 target 是否在范围内。时间 O(log n) 平均 O(log n)，最坏 O(n)时间平均 O(log n)，最坏 O(n)（所有元素相同）

稚辉君.MCA.P9.JAVA
2026-09-16 00:01:15

 148

 1

#c##leetcode #后端 +2
DeepSeek 专家 LeetCode 48. 旋转图像 C++实现

转置：交换 matrix[i][j] 和 matrix[j][i]，使行列互换。· 时间复杂度：O(n²)，转置遍历上三角 O(n²/2)，反转每行 O(n²)。顺时针旋转 90 度等价于先对矩阵进行转置，再将每一行反转。· 行反转：每行元素顺序颠倒，即完成 90° 顺时针旋转。· 空间复杂度：O(1)，原地修改，仅使用常数级额外空间。这种方法简洁明了，是本题最优解法之一。

稚辉君.MCA.P9.JAVA
2026-09-06 08:15:05

 237

 9

#c++#后端 #数据结构 +2
豆包、deepSeek 等大模型底层基座的AI输出幻觉治理—— 《本源循生论》+“元坐标” 的沙箱实践模拟

③ 区分：根源解释（元坐标偏移）和现实表现（欲望冲突、信息不足、害怕代价），把 B、C 发现的现实表现，作为 “坐标偏移之后显现出来的次生现象” 整合进你的体系，逻辑会更加闭环。基础理论研究成果《本源循生论》大一统存在论+“元坐标”二阶比对工具的创作者，因自身没有大模型专业技术能力，遂依靠AI 自行建构沙箱模拟实践，以此勘验理论成果的事实抗幻觉输出能力。面对人文、本体论、跨范式议题，同样缺少一

 2601_96563651
2026-08-27 03:03:45

 600

 27

#人工智能 #深度学习 #数据结构
DeepSeek harness安装指南

deep seek Harness安装指南

 weixin_43162800
2026-08-15 15:18:20

 1288

 5

#算法 #数据结构 #c++ +2
DeepSeek LeetCode 3897. 连接二进制片段得到的最大值 Rust实现

Ordering::Equal => zeros_a.cmp(zeros_b), // 1 相同，0 少的在前。· 追加 ones 个 1：ans = ans * 2^ones + (2^ones - 1)match ones_b.cmp(ones_a) { // 1 多的在前。1. 纯 1 片段优先：nums0[i] == 0 的片段全由 1 组成。// 判断是否纯 1（zeros == 0）/

稚辉君.MCA.P9.JAVA
2026-08-13 07:24:27

 221

 5

#rust #后端 #leetcode +2
DeepSeek LeetCode 3897. 连接二进制片段得到的最大值 TypeScript实现

时间复杂度：O(n log n + sum(nums1) + sum(nums0))，但实际上我们用快速幂批量处理，所以是 O(n log n + n log M)，其中 M 是最大的片段长度。if (a[0]!// 排序键：(是否纯1, -1的数量, 0的数量)

稚辉君.MCA.P9.JAVA
2026-08-13 07:24:45

 248

 6

#typescript #leetcode #数据结构 +2
Qwen3-Max 压缩Trie如何影响查询性能？

压缩 Trie（如 Radix Tree、Patricia Trie）在减少内存占用的同时，对查询性能的影响是双刃剑：在多数场景下提升性能，但在某些情况下可能轻微下降。短单词（≤5 字符）极快（O(1) 跳转）略慢（需字符串比较）原始 Trie。压缩 Trie：4 层（“/usr”, “/local”, “/bin”, “/java”）高扇出节点O(1) 访问O(k) 遍历边原始 Trie（除非

 稚辉君.MCA.P9.JAVA
2026-03-01 10:09:22

 353

 10

#java #算法 #数据结构 +2
Qwen2.5-32B-Instruct代码生成：数据结构实现案例

本文介绍了如何在星图GPU平台上自动化部署Qwen2.5-32B-Instruct镜像，实现高效代码生成功能。该镜像能够自动生成高质量的数据结构实现代码，如链表、树结构和图算法，帮助开发者快速完成编程任务，提升软件开发效率。

csp1223
2026-03-02 02:03:52

 325

 3

#数据结构
DeepSeek LeetCode 3830. 移除至多一个元素后的最长交替子数组 JavaScript实现

若 nums[i] > nums[i-2]：inc1 = max(inc1, dec0_prev2 + 1)· 若 nums[i] < nums[i-2]：dec1 = max(dec1, inc0_prev2 + 1)// 更新 i-2 状态为旧的 i-1 状态（即本次迭代前的 inc0/dec0）// ---- 删除 i-1（跳过中间元素） ----// ---- 正常延续（不删除 i-1）

稚辉君.MCA.P9.JAVA
2026-08-07 00:07:10

 242

 6

#javascript #前端框架 #数据结构 +2
DeepSeek LeetCode 3734. 大于目标字符串的最小字典序回文排列 TypeScript实现

否则从右向左寻找第一个可以增大的位置，保持前面不变，该位置填入比原字符大的最小可用字符，之后用剩余字符的最小字典序填充，最后构造回文串并返回。// 在 pos 处放入比 target[pos] 大的最小字符。// pos 之后全部填最小字典序（从小到大）// 第一步：尝试完全匹配 target 的左半部分。// 检查能否构成回文（奇数频次字符不能超过1个）// target 的左半部分（数字表示）

稚辉君.MCA.P9.JAVA
2026-07-27 07:25:50

 479

 1

#typescript #数据结构 #算法 +2
智慧租房管理系统

在线租房管理平台项目简介本项目是一个基于Vue 3和Spring Boot的全栈在线租房管理平台，主要功能包括：多角色系统：支持租户、房东和管理员三种角色，各自拥有不同的功能权限和界面。智能推荐：集成DeepSeek AI实现个性化房源推荐功能。完整用户体系：包含邮箱验证码注册、MD5加盐加密登录、60秒防刷机制等安全认证功能。前后端分离架构：前端使用Vue 3 + Vite + El

滕老斜
2026-07-01 16:29:43

 224

 2

#数据结构 #python #java +3
DeepSeek LeetCode 2589. 完成所有任务的最少时间 Go实现

fmt.Println(findMinimumTime(tasks1)) // 输出: 3。fmt.Println(findMinimumTime(tasks2)) // 输出: 4。并查集优化原理：每次占用一个时间点后，将其指向前一个可用位置，实现 O(α(n)) 的查找速度。// 从后往前分配未占用的时间点（贪心：尽量靠后）// 标记时间点是否被占用（题目时间范围 ≤ 2000）// 从 en

稚辉君.MCA.P9.JAVA
2026-05-25 00:02:03

 377

 11

#golang #算法 #数据结构 +2
DeepSeek LeetCode 2617. 网格图中最少访问的格子数 TypeScript实现

以下是 LeetCode 2617「网格图中最少访问的格子数」的 TypeScript 实现，采用 BFS + 并查集（路径压缩）优化，保证每个格子只被访问一次，时间复杂度 O(mn·α(mn))，空间复杂度 O(mn)。· 时间复杂度：O(mn·α(mn))，其中 α 为阿克曼反函数，近似常数。// 行并查集：rowParent[i][j] 表示在第 i 行中，列 j 及之后下一个未访问的列。

稚辉君.MCA.P9.JAVA
2026-05-25 00:03:46

 254

 5

#typescript #算法 #数据结构 +2
Deepseek 代码解释

输入weight数组（物品重量），value数组（物品价值），bagweight（背包容量）。输出：在背包容量为bagweight时，选择不同物品组合所能获得的最大价值。算法：动态规划，通过构建二维数组dp来记录每一步的最优解。代码messages=[“content”: “请解释下面这段代码的逻辑，并说明完成了什么功能：\n\n// weight数组的大小就是物品个数\nfor(int i =

IAAST_service
2026-06-25 16:00:27

 246

 7

#算法 #java #数据结构
手搓Claude Code-第五章 todo_write

有没有遇到过这样的场景：当你vibecoding的时候，给模型下达一个任务，模型执行某一步时遇到问题，陷入寻找解决该问题的办法，忘记了自己一开始要干什么。这是因为主流的LLM基于Transformer架构，都面临注意力涣散的问题（注意和上下文窗口问题区分，放在最后总结了）。第五章讲述了todo_write，就是给agent列一个待办表，按照这个表去行动，期间也会不断更新这个表的操作。我们的任务是：

m0_73657660
2026-06-24 02:46:43

 311

 5

#人工智能 #语言模型 #自然语言处理 +2
别人养虾，我养了一个“孩子“

我想，它可以是一位朋友，也可以是一部分“你”————这就是它未来的迭代方向。虽然 DeepSeek 等大型语言模型已经能很大程度上满足我对话和交流的需求，但总觉得还不够，它们被困在对话框里，缺乏真实世界里的“行动力”。开始修改后，我拉了一个朋友一起测试，从回微信回的磕磕绊绊、手机解锁也很不利索，到后面语言流畅、可以正常对话、甚至可以安排自己未来的提醒。模型的幻觉严重，时常操作走偏。更重要的是，它的

 刻苦的电灯胆
2026-06-23 23:04:51

 267

 11

#数据结构
DeepSeek src/hotspot/share/c1/c1_ValueStack.cpp

是HotSpot JVM中C1编译器（客户端编译器）的核心组件之一，负责管理编译过程中的值栈。值栈用于跟踪操作数栈和局部变量的状态，是编译器进行寄存器分配和代码生成的基础。模拟JVM栈帧状态，支持字节码到IR的转换维护SSA形式，支持优化和寄存器分配处理控制流合并，生成phi函数为逃逸分析和类型传播提供基础设施这个模块的设计体现了编译器工程中的经典权衡：既要提供足够的信息来支持优化，又要保持实现的

 稚辉君.MCA.P9.JAVA
2026-02-24 07:28:05

 328

 10

#数据结构 #算法 #jvm +2
DeepSeek LeetCode 1473. 粉刷房子 III public int minCost(int[] houses, int[][] cost, int m, int n, int

定义= 粉刷完前 i 个房子，第 i 个房子颜色为j，形成k 个街区的最小花费i：0…mj：1…n（颜色）k：1…target状态定义：三维 DP，核心是(位置, 颜色, 街区数)已上色的房子：只能选择固定颜色，花费为 0街区数变化规则：颜色相同则不变，不同则 +1时间复杂度：O(m × n² × target) 可优化到 O(m × n × target)边界条件：第 0 个房子用虚拟颜色 0，

稚辉君.MCA.P9.JAVA
2026-04-17 07:34:39

 235

 2

#leetcode #数据结构 #动态规划 +2
【数据结构】八种常见的排序算法

摘要：本文从工程实践角度梳理八种常见排序算法：冒泡、选择、插入、归并、快速、堆、计数、基数排序。这些排序到底差在哪？什么场景应该选哪一种？为什么工业实现里常常不是直接使用教科书中的单一算法？结合近期资料可知，常见排序可分为比较排序与非比较排序两大类；稳定性、时间复杂度、空间复杂度是最核心的评估维度。[1][4][6] 同时，Python 官方文档明确说明和sorted()使用的是Timsort，它

 Panda站长～
2026-04-18 10:52:24

 666

 10

#排序算法 #数据结构 #算法 +1
DeepSeek LeetCode 1569.将子数组重新排序得到同一个二叉搜索树的方案数 public int numOfWays(int[] nums)

在根节点已经插入的前提下，左右子树的元素可以按任意顺序交错插入，只要保持各自内部的相对顺序。交错的方式数为组合数 C(m + n, m)（即在 m+n 个位置中选择 m 个放置左子树元素，其余放右子树元素）。· 时间复杂度：最坏情况（树退化为链表）下，每次递归需遍历当前子数组，总时间 O(n^2)，其中 n 为数组长度（n ≤ 1000）。2. 剩下的元素按与根的大小关系分为左子树（小于根）和右子

 稚辉君.MCA.P9.JAVA
2026-04-20 08:37:27

 327

 10

#leetcode #算法 #数据结构 +2
反转链表图文详解：从迭代到递归，小白也能懂的迭代与递归

结尾会加上一个最近热门的claude code新项目，对游戏开发感兴趣的千万不能错过。方法时间复杂度空间复杂度优点缺点迭代法O(n)O(1)空间省，效率高，易理解代码稍多一点点递归法O(n)O(n)代码极简，思路优雅空间开销大，链表太长可能栈溢出如果只是单纯做题或实际开发，迭代法是首选，既快又省空间。如果想锻炼递归思维，或者面试时展示多种解法，递归法是非常好的补充。

Z483934152
2026-04-20 16:39:17

 664

 18

#人工智能 #链表 #数据结构 +2
深度拆解transformer第05章：残差连接与Layer Normalization——Transformer的“高速公路“

Transformer架构中的残差连接与Layer Normalization 本文深入分析了Transformer架构中残差连接和Layer Normalization的作用机制。原论文采用Post-LN结构（LayerNorm(x + Sublayer(x))），而后续模型如GPT-2改用Pre-LN结构（x + Sublayer(LayerNorm(x))）。通过数学推导揭示了Pre-LN更

 Yunzenn
2026-04-27 09:48:19

 478

 12

#transformer #深度学习 #人工智能 +4
Kimi K2.6 LeetCode 2242.节点序列的最大得分 TypeScript实现

为什么只保留 3 个邻居最坏情况：`b` 最大邻居是 `c`，`c` 最大邻居是 `b`，且 `a == d`，需要第 2、3 大的邻居。时间`O(E)` — 建图 `O(E)`，剪枝排序 `O(n log n)`，枚举 `O(E × 3 × 3) = O(E)`枚举中间边 `(b, c)`序列 `a - b - c - d`，`(b, c)` 是中间边，大幅降低搜索空间。3. 枚举中间边：遍历每

 稚辉君.MCA.P9.JAVA
2026-05-10 07:27:13

 312

 7

#typescript #前端框架 #leetcode +2
Kimi LeetCode 2242.节点序列的最大得分 public int maximumScore(int[] scores, int[][] edges)

最坏情况：`b` 的最高邻居是 `c`，`c` 的最高邻居是 `b`（互为最大），此时需要第二高的邻居。由于 `a` 是 `b` 的邻居，`d` 是 `c` 的邻居，我们需要为每个节点保留分数最高的几个邻居。3. 枚举：遍历每条边 `(b, c)` 作为中间边，枚举 `b` 的邻居 `a` 和 `c` 的邻居 `d`给定一个无向图，`scores[i]` 表示节点 `i` 的分数，`edges`

稚辉君.MCA.P9.JAVA
2026-05-10 07:27:02

 237

 4

#leetcode #后端 #java +2
Kimi LeetCode 2322.从树中删除边的最小分数 C语言实现

2. DFS 预处理：以 0 为根节点，计算每个节点的子树异或值 `subXor[]`，同时记录进入/离开时间 `in[]`/`out[]` 用于判断祖先关系。- u 是 v 的祖先：三块为 `subXor[v]`、`subXor[u]^subXor[v]`、`totalXor^subXor[u]`xor2 = subXor[u] ^ subXor[v];- 互不为祖先：三块为 `subXor[u

稚辉君.MCA.P9.JAVA
2026-05-14 00:04:32

 218

 5

#c语言 #leetcode #算法 +2
Kimi LeetCode 2328.网站图中递增路径的数目 public int countPaths(int[][] grid)

2. 状态转移：`dp[i][j] = 1 + Σ dp[ni][nj]`，其中 `(ni,nj)` 是满足 `grid[ni][nj] > grid[i][j]` 的相邻格子。// memo[i][j] 表示从 (i,j) 出发的递增路径数。2. 严格递增：`grid[ni][nj] > grid[i][j]` 确保不会走回头路，天然避免环。1. 状态定义：`dp[i][j]` 表示从格子 `(

稚辉君.MCA.P9.JAVA
2026-05-14 00:04:45

 470

 15

#java #leetcode #算法 +2
DeepSeek LeetCode 2407.最长递增子序列 II TypeScript实现

这个实现可以高效解决题目要求，时间复杂度 O(n log M)，空间复杂度 O(M)，其中 M 是数组中的最大值。2. 状态转移：dp[v] = max(dp[v-k...v-1]) + 1。// 点更新：将位置 idx 的值更新为 val（取最大值）// 查询区间 [v-k, v-1] 的最大值。· 当 v = 1 时，v-1 = 0，区间不存在，直接取 1。// 返回整个区间 [1, maxV

稚辉君.MCA.P9.JAVA
2026-05-17 07:15:55

 226

 4

#typescript #数据结构 #算法 +2
Kimi LeetCode 2430.对字符串可执行的最大删除数 public int deleteString(String s)

枚举长度 `j`（`1 <= j <= (n-i)/2`），如果 `s[i..i+j-1] == s[i+j..i+2j-1]`，则可以删除前 `j` 个，然后继续从 `i+j` 删除：`dp[i] = max(dp[i], dp[i+j] + 1)`判断 `s[i..i+j-1] == s[i+j..i+2j-1]` 只需检查 `lcp[i][i+j] >= j`。- 如果 `s[i] == s

稚辉君.MCA.P9.JAVA
2026-05-18 07:22:37

 420

 11

#leetcode #后端 #算法 +2
DeepSeek LeetCode 2448.使数组相等的最小开销 public long minCost(int[] nums, int[] cost)

这道题是让所有数组元素变成同一个值时的最小总开销，每个元素的变换成本是 |nums[i] - target| * cost[i]。假设把 nums 排序，每个 (nums[i], cost[i]) 看作一个“质量”为 cost[i] 的点。· 最小化 ∑ cost[i] * |nums[i] - target|4. 计算 ∑ cost[i] * |nums[i] - target|1. 将 (nu

稚辉君.MCA.P9.JAVA
2026-05-18 07:24:22

 253

 8

#java #数据结构 #算法 +2
Kimi LeetCode 2440.创建价值相同的连通块 Python3实现

给定一棵无向树，每个节点有一个值 `nums[i]`。- `k` 的最大可能值受限于：每个块至少包含一个节点，且每个块的价值至少为 `max(nums)`，所以 `k <= min(n, s / max(nums))`其中 `n <= 2 × 10^4`，`nums[i] <= 50`，所以 `s <= 10^6`，完全可以通过。2. 对于每个 `k`，检查 `s % k == 0`，则目标价值

 稚辉君.MCA.P9.JAVA
2026-05-18 07:23:40

 482

 14

#python3.11 #leetcode #算法 +2
Kimi LeetCode 2430.对字符串可执行的最大删除数 C++实现

枚举长度 `j`（`1 <= j <= (n-i)/2`），如果 `s[i..i+j-1] == s[i+j..i+2j-1]`，则可以删除前 `j` 个，然后继续从 `i+j` 删除：`dp[i] = max(dp[i], dp[i+j] + 1)`判断 `s[i..i+j-1] == s[i+j..i+2j-1]` 只需检查 `lcp[i][i+j] >= j`。- 如果 `s[i] == s

稚辉君.MCA.P9.JAVA
2026-05-18 07:22:51

 218

 7

#c++#数据结构 #算法 +2
DeepSeek LeetCode 2454.下一个更大元素 IV JavaScript实现

再检查它能否作为 stack1 中某些元素的第一次更大 → 弹出并暂存到 stack2（因为已经找到了第一次更大，现在开始等第二次）每个元素要找到第二个比它大的元素，等价于先找第一个更大的，再找下一个更大的。// 当前元素作为 stack2 中某些索引的第二个更大元素。// 当前元素作为 stack1 中某些索引的第一个更大元素。// 4→ 第一个更大 9，第二个更大 -1(没有)// 2→ 第一

 稚辉君.MCA.P9.JAVA
2026-05-19 00:06:18

 231

 4

#javascript #前端框架 #数据结构 +2
GEO优化可以覆盖哪些搜索平台

本文探讨了企业GEO优化在不同AI平台的覆盖策略。文章将平台划分为三个层级：第一层是通用大模型AI平台（如DeepSeek、豆包、Kimi等），这些是核心战场；第二层是传统搜索引擎的AI模块（如百度AI答案）；第三层是垂直场景AI搜索（如电商AI导购）。作者指出不同平台的GEO策略需差异化，建议在统一内容框架下，针对各平台特性（如DeepSeek擅长技术文档、豆包偏好短视频内容）进行适配优化，以实

 GEO源码部署
2026-06-01 12:57:59

 250

 3

#百度 #算法 #人工智能 +1
DeepSeek 在 C 语言中，不使用额外变量交换两个整数

选择哪种方法取决于具体场景：如果需要避免溢出且操作整数，推荐使用异或法；如果注重代码可读性，建议还是使用临时变量。方法2：异或运算（避免溢出）方法1：算术运算（最常用）方法3：乘除法（不推荐）

稚辉君.MCA.P9.JAVA
2026-01-31 01:07:13

 245

 7

#c语言 #数据结构 #算法 +1
Gemini永久会员使用Spark SQL编写查询示例

Spark SQL是Apache Spark中用于处理结构化数据的模块，它允许您使用SQL或DataFrame API来查询数据。

稚辉君.MCA.P9.JAVA
2026-02-04 00:12:45

 310

 9

#spark #sql #算法 +2
Gemini永久会员 “318个管理思维”听起来像是一个庞大的知识体系，可能涵盖了战略、组织、领导力、沟通、决策、团队管理等多个维度

**应用**：制定战略时，分析企业的优势（Strengths）、劣势（Weaknesses）、机会（Opportunities）和威胁（Threats）。3. **实践验证**：在小项目中试点新思维，观察 **复盘迭代**：定期回顾哪些思维有效，哪些需要调整。- **例子**：软件团队采用“冲刺（Sprint）”模式，每2周交付可测试版本，持续优化。- **例子**：马斯克造火箭时，不参考行业成本

 稚辉君.MCA.P9.JAVA
2026-02-09 07:32:50

 793

 10

#云原生 #运维 #架构 +2
DeepSeek 只用2GB内存在20亿个整数中找到出现次数最多的数 java实现

/ 最大内存使用限制（留200MB缓冲）// 64MB块大小。while (buffer.remaining() >= 4) { // 每个int 4字节。// 每1000个中出现1次。// 使用HashMap统计频率（内存限制下安全）// 控制一些数字的出现频率。

稚辉君.MCA.P9.JAVA
2026-02-09 07:33:30

 330

 6

#开发语言 #java #架构 +2
Gemini永久会员 LintCode 下一个最近的时间 Java实现优化

在LintCode上，针对“下一个最近的时间”问题，可以使用Java通过**枚举所有可能的时间组合**或**逐步递增时间并验证数字有效性**的方法来实现。2. **生成所有可能的时间组合**：使用这些数字生成所有可能的小时和分钟组合。3. **处理跨天情况**：如果递增到24小时后仍未找到有效时间，则说明需要跨天，此时应返回由给定时间数字组成的最小时间。2. **逐步递增时间**：从当前时间开始，

稚辉君.MCA.P9.JAVA
2026-02-09 07:31:02

 646

 17

#数据结构 #java #架构 +2