- 博客(81)
- 资源 (2)
- 收藏
- 关注
RSS订阅原创 [Java恶补day63-day64] 整理模板·考点十四【动态规划（LCS）】
本文系统讲解了最长公共子序列（LCS）问题的动态规划解法。主要内容包括：问题定义：LCS指两个序列中最长的非连续公共子序列。解题思路：通过比较字符串末尾字符，分为四种情况处理推导出核心状态转移方程：当字符匹配时dp[i][j]=dp[i-1][j-1]+1，否则取左/上最大值三种实现方式：记忆化搜索（自顶向下）标准二维DP（自底向上）空间优化版（滚动数组或单数组）
2025-10-10 11:57:17
268
原创 [Java恶补day60-day62] 整理模板·考点十三【动态规划（01背包、完全背包）】
文章系统介绍了0-1背包和完全背包问题的动态规划解法，通过"回溯→记忆化搜索→递推"的三步法进行讲解。对于0-1背包问题，重点分析了状态转移方程dfs(i,c)=max(dfs(i-1,c),dfs(i-1,c-w[i])+v[i])的实现过程，并给出了Java代码示例。针对打家劫舍问题，详细阐述了动态规划解法，包括记忆化搜索和递推两种实现方式，时间复杂度均为O(n)。特别地，通过空间优化将空间复杂度从O(n)降至O(1)。文章列举了背包问题的常见变形，如"至多"、"恰好"、"至少"约束条件下的不同求解目标
2025-09-27 14:04:11
428
原创 [Java恶补day54-59] 整理模板·考点十二【回溯】
本文介绍了回溯算法的基本概念和应用场景，重点讲解了三种回溯类型：子集型、组合型和排列型回溯。针对字符串生成问题，提出递归解法思路，即从原问题分解为相似的子问题通过递归解决。文章给出了回溯问题的通用模板（回溯三问）和时间复杂度分析公式，并强调是否需要恢复现场的两种情况。通过LeetCode 78（子集）、17（电话号码字母组合）和131（分割回文串）三道典型题目，展示了回溯算法的具体实现，包括递归边界条件处理、路径记录和恢复现场等关键步骤。所有解法均附有详细的时间复杂度分析和参考来源，为理解回溯提供了范例。
2025-09-10 23:27:51
652
原创 [Java恶补day53] 45. 跳跃游戏Ⅱ
本文介绍了如何计算从数组起点跳到终点的最小跳跃次数。通过贪心算法，每次在当前可移动区间内选择能跳最远的位置，逐步扩展右边界直至到达终点。时间复杂度O(n)，空间复杂度O(1)。示例展示了该算法的具体应用过程，代码实现简洁高效。
2025-09-09 14:03:48
749
原创 [Java恶补day52] 55. 跳跃游戏
摘要 本文介绍了跳跃游戏问题的解法，判断能否从数组起点跳到终点。使用贪心算法，维护一个变量mx记录当前能到达的最远位置。遍历数组时，若当前位置超过mx则返回false，否则更新mx为当前位置加跳跃长度。若遍历完成则返回true。该方法时间复杂度O(n)，空间复杂度O(1)。示例代码展示了Java实现，包含关键步骤解释。
2025-09-06 19:38:18
299
原创 [Java恶补day51] 46. 全排列
题目要求返回不含重复数字数组的所有全排列。使用回溯算法，通过记录访问状态和路径来生成所有排列。时间复杂度为O(n*n!)，空间复杂度为O(n)。核心步骤包括：遍历未访问节点，递归生成排列，回溯恢复状态。Java实现中利用布尔数组标记访问状态，列表存储路径，当路径长度等于数组长度时保存结果。
2025-08-25 22:48:09
161
原创 [Java恶补day50] 174. 地下城游戏
本文探讨了骑士拯救公主的路径规划问题。给定一个二维网格表示的地下城，骑士需要从左上角出发到达右下角拯救公主，路径中可能增减生命值。采用动态规划方法，从终点逆向计算每个位置所需最小初始生命值。关键点在于：1)终点生命值至少为1；2)每个位置的生命值取决于右边或下边格子的最小值与当前房间影响的差值。时间复杂度O(mn)，空间复杂度O(mn)。示例代码展示了Java实现，通过逆向DP确保骑士以最低初始生命值成功拯救公主。
2025-08-17 16:13:43
395
原创 [Java恶补day49] 整理模板·考点十一【贪心算法】
摘要： 本题考察股票买卖问题，要求在某天买入并在之后某天卖出，获取最大利润。核心思路是维护当前最小值，遍历数组时计算当前价格与最小值的差值，更新最大利润。时间复杂度O(n)，空间复杂度O(1)。示例输入[7,1,5,3,6,4]输出5（第2天买入，第5天卖出）。若无利润则返回0。关键代码：遍历时更新最小值和最大利润差。
2025-08-16 10:51:32
929
原创 [Java恶补day48] 20. 有效的括号
本文介绍了如何判断由括号组成的字符串是否有效。有效字符串需满足：左括号必须用相同类型的右括号闭合，且顺序正确。核心解法是使用栈结构：遇到左括号入栈，遇到右括号时检查是否与栈顶元素匹配。若遍历后栈为空则有效，否则无效。算法时间复杂度为O(n)，空间复杂度为O(n)。文中给出了Java实现代码，并附示例说明。
2025-08-02 14:24:19
278
原创 [Java恶补day47] 整理模板·考点十【二叉树层序遍历】
本文总结了二叉树层序遍历的核心考点和两种实现方法。关键点包括：1) 使用!运算符进行布尔取反和Collections.reverse()翻转列表；2) 层序遍历可以计算二叉树最大深度；3) 比较递归(栈结构)和层序遍历(队列实现)的差异。针对102题(普通层序遍历)和103题(锯齿形层序遍历)，文章详细分析了BFS和队列两种解法，时间复杂度均为O(n)。103题在102题基础上，通过翻转偶数层节点值实现锯齿形遍历。展示两种实现：法1使用cur/nxt双列表，法2采用队列结构更高效。空间复杂度最坏情况O(n)
2025-07-26 16:40:21
749
原创 [Java恶补day46] 整理模板·考点九【二叉树最近公共祖先】
本文总结了二叉树的最近公共祖先问题。对于普通二叉树（236题），通过递归分类讨论：若当前节点是p/q/空则直接返回；否则递归左右子树，根据左右子树结果判断公共祖先位置。对于二叉搜索树（235题），利用BST有序性质，通过比较节点值确定p/q的位置关系，只在左/右子树递归或直接返回当前节点。两题的时间复杂度均为O(n)，空间复杂度O(n)（最坏情况）。核心思路都是对当前节点进行分类讨论，结合树的性质进行优化。
2025-07-25 20:17:09
456
原创 [Java恶补day44-day45] 整理模板·考点八【二叉树】
本文总结了二叉树相关考点的核心思路和解题技巧，主要包括递归思想和常见题型解法。 递归核心在于思考整棵树与左右子树关系，用栈保存当前处理节点。关键技巧包括确认递归边界和返回值类型。 提供了四道典型题目的详解： 104题：两种方法求二叉树最大深度（递归返回深度/全局变量维护） 100题：递归判断两棵树是否完全相同 101题：递归判断二叉树是否对称 110题：递归判断平衡二叉树（左右子树高度差≤1） 所有题目均采用递归解法，时间复杂度为O(n)，空间复杂度最坏O(n)。
2025-07-20 11:21:07
1018
原创 [Java恶补day44] 98. 验证二叉搜索树（已归档）
本文介绍了如何验证一个二叉树是否为有效的二叉搜索树(BST)。BST需满足左子树节点值均小于根节点，右子树节点值均大于根节点，且左右子树也必须是BST。通过递归方法，传入当前子树的取值范围边界，判断节点值是否在合法范围内，并递归检查左右子树。解法时间复杂度O(n)，空间复杂度O(n)。提供了Java实现代码示例，通过前序遍历方式高效验证BST的有效性。
2025-07-20 10:44:41
360
原创 [Java恶补day43] 108. 将有序数组转换为二叉搜索树
题目要求将升序数组转换为平衡二叉搜索树。核心思路是递归分治，每次选取数组中间元素作为根节点，左半部分构建左子树，右半部分构建右子树。时间复杂度O(n)，空间复杂度O(n)。示例表明，不同的中间节点选择可能产生多个正确答案，但都能保证树的高度平衡。Java实现通过递归方法，在给定数组范围内不断找到中间节点并构建子树，直到子数组为空。
2025-07-19 13:09:21
531
原创 [Java恶补day42] 102. 二叉树的层序遍历
本文介绍了二叉树的层序遍历算法。层序遍历需要按层级从左到右访问每个节点，使用队列实现这一过程。算法步骤如下：1)若根节点为空则返回空列表；2)初始化队列并将根节点入队；3)当队列不为空时，获取当前层级节点数，遍历这些节点，将其值存入列表，并将非空子节点入队；4)将当前层级结果加入最终列表。该算法时间复杂度为O(n)，空间复杂度为O(n)（最坏情况下队列存储约n/2个节点）。文章提供了Java实现代码，使用队列进行广度优先搜索，逐层处理节点并保存结果。
2025-07-16 20:34:19
255
原创 [Java恶补day41] 101. 对称二叉树（已归档）
本题要求检查二叉树是否轴对称。通过递归方法解决：首先判断左右子树是否均为空，若一个为空另一个不为空则不对称；然后比较左右节点值是否相等；最后递归检查外侧和内侧子树是否对称。时间复杂度O(n)，空间复杂度O(n)。示例说明该方法能正确判断对称性。进阶建议可尝试迭代解法。
2025-07-13 20:10:56
197
原创 [Java恶补day41] 226. 翻转二叉树
本文介绍了如何翻转一棵二叉树。通过递归方法实现：先翻转左右子树，再交换当前节点的左右子树。时间复杂度为O(n)，空间复杂度在最坏情况下为O(n)。示例展示了输入输出结果，代码提供了Java实现方案。要点包括处理空节点、递归获取翻转子树、以及避免错误交换顺序。这是二叉树基础操作的典型例题。
2025-07-13 20:06:43
243
原创 [Java恶补day41] 543. 二叉树的直径
本文介绍了计算二叉树直径的算法。二叉树的直径是指树中任意两节点间最长路径的长度（以边数计算）。通过递归方法，从叶子节点向上计算每个节点的链长（到子树叶子节点的最长路径），并更新直径值（左右链长之和）。关键点在于：空节点链长为-1，叶子节点链长为0，递归过程中维护最大值。该算法时间复杂度为O(n)，空间复杂度为O(n)（最坏情况）。示例代码展示了Java实现，利用深度优先搜索递归计算链长并更新直径。
2025-07-13 19:50:00
266
原创 [Java恶补day40] 104. 二叉树的最大深度（已归档）
本文介绍了如何计算二叉树的最大深度。最大深度是指从根节点到最远叶子节点的最长路径上的节点数。采用递归解法：若节点为空返回0，否则返回左右子树的最大深度加1。时间复杂度为O(n)，空间复杂度最坏为O(n)。示例展示了输入输出情况，如输入[3,9,20,null,null,15,7]时输出3。代码简洁高效，适合处理树形结构问题。
2025-07-12 15:18:21
205
原创 [Java恶补day40、day46] 整理模板·考点七【二叉树遍历】
本文总结了二叉树的三种遍历方式（前序、中序、后序）及其在验证二叉搜索树中的应用。前序遍历顺序为"根左右"，中序为"左根右"，后序为"左右根"。在验证二叉搜索树时，可采用三种方法：1）前序遍历通过开区间范围判断节点值合法性；2）中序遍历利用升序特性验证；3）后序遍历通过比较子树极值判断。所有方法时间复杂度均为O(n)，空间复杂度最坏为O(n)。文中提供了完整的前中后序遍历代码实现，以及验证二叉搜索树的前序遍历解法。
2025-07-12 15:10:34
405
原创 [Java恶补day39-day40] 整理模板·考点六【反转链表】
本文总结了链表反转相关算法题的核心解法。主要包括三个问题：反转整个链表(#206)、反转链表区间(#92)和K个一组反转链表(#25)。对于基础反转操作，关键步骤是保存下一个节点、反转当前指针、移动前驱和当前指针。对于区间反转问题，使用哨兵节点处理边界，并注意连接反转区间前后的节点。对于分组反转，需要计算链表长度，按组处理并处理剩余不足一组的节点。所有解法的时间复杂度均为O(n)，空间复杂度为O(1)。
2025-07-06 23:02:31
571
原创 [Java恶补day38] 整理模板·考点五【前后指针】
1、删除指定节点（237题）：通过将下个节点的值复制到当前节点，再删除下个节点来实现。2、删除倒数第N个节点（19题）：使用前后指针法，前指针先走N步，然后同步移动直到前指针到达末尾，后指针即指向待删节点的前驱。3、删除重复元素：1）保留重复元素中的第一个（83题）：直接遍历删除后续重复节点2）删除所有重复元素（82题）：需要哨兵节点，遍历时删除所有重复值的节点
2025-07-05 21:36:35
625
原创 [Java恶补day37-day38] 整理模板·考点四【快慢指针】
快慢指针的核心思想是通过两个指针的不同移动速度解决链表问题。在链表中点查找中，当fast指向空或fast.next指向空时，slow正指向中间节点。环形链表检测利用快慢指针相遇判断环的存在，而环形链表入口定位则通过数学推导确定相遇点与入口的关系。重排链表问题可以结合快慢指针找到中点后进行链表反转和合并操作。
2025-07-03 22:48:44
850
原创 [Java恶补day36] 148. 排序链表
本文介绍了如何对链表进行升序排序。采用归并排序算法，通过快慢指针找到链表中点进行分治，然后合并两个有序链表。时间复杂度为O(n log n)，空间复杂度为O(1)。示例代码展示了具体实现，包括链表分割、递归排序和合并过程。适用于节点数在0到5×10^4范围内的链表排序需求。
2025-06-30 22:26:50
674
原创 [Java恶补day35] 138. 随机链表的复制
本文解决带随机指针的链表深拷贝问题。通过哈希表存储原节点与拷贝节点的映射关系，第一次遍历创建所有新节点，第二次遍历设置新节点的next和random指针。该方法时间复杂度O(n)，空间复杂度O(n)，能正确复制链表的完整结构。关键点在于利用哈希表保存节点对应关系，确保新链表的指针正确指向新节点而非原节点。
2025-06-29 21:24:35
798
原创 [Java恶补day34] 24. 两两交换链表中的节点
这篇文章介绍了如何两两交换链表中的相邻节点。通过使用哨兵节点和迭代方法，在不修改节点值的情况下实现交换。当链表为空或只有一个节点时直接返回。算法使用三个指针(p1,p2,p3)进行节点交换操作，时间复杂度O(n)，空间复杂度O(1)。关键步骤包括：创建哨兵节点，指针重新指向完成交换，然后移动指针继续处理后续节点。这种方法简洁高效地解决了链表节点交换问题。
2025-06-27 23:06:47
254
原创 [Java恶补day33] 19. 删除链表的倒数第N个结点（已归档）
本文介绍了如何删除链表的倒数第n个节点。关键点在于使用哨兵节点简化边界条件处理，并采用前后指针法进行单次遍历。前指针先移动n+1步，然后前后指针同步移动，这样后指针将指向倒数第n+1个节点，便于执行删除操作。该方法时间复杂度为O(m)，空间复杂度为O(1)，其中m为链表长度。文中还提供了Java实现代码，并解释了每个步骤的作用。
2025-06-26 13:06:39
312
原创 [Java恶补day32] 2. 两数相加
这篇文章解析了如何将两个逆序存储的非负整数链表相加。通过维护一个进位变量和哨兵节点构建结果链表，每次计算对应节点值之和并处理进位。时间复杂度为O(max(m,n))，空间复杂度O(1)。关键点在于：迭代处理链表节点、正确计算进位、以及最后处理剩余进位。给出了Java实现代码，包含详细的注释说明每个步骤的功能。特别适合需要理解链表操作和进位处理机制的读者参阅。
2025-06-24 23:33:36
984
原创 Anaconda虚拟环境安装torch-gpu
成功在conda虚拟环境中安装匹配的CUDA和PyTorch。首先通过nvidia-smi确认CUDA 12.8版本，选择cudatoolkit 11.8.0安装。使用阿里源加速下载PyTorch（14MB/s），最终测试torch.cuda.is_available()返回True。关键点：确保Python 3.11.X与CUDA版本兼容，并通过镜像源提升下载速度。
2025-06-24 20:19:30
751
原创 [Java恶补day31] 21. 合并两个有序链表
本文介绍了如何合并两个升序链表为一个新的升序链表。通过迭代法，比较两个链表的节点值，将较小的节点依次拼接至新链表。使用哨兵节点简化处理逻辑，最终时间复杂度为O(m+n)，空间复杂度为O(1)。代码示例展示了Java实现，包括特殊情况处理和剩余节点拼接。
2025-06-23 23:50:26
380
原创 Anaconda虚拟环境的切换
解决VSCode虚拟环境中pip识别问题的有效方案： 创建并激活conda虚拟环境 通过pip版本命令验证环境状态 在VSCode右下角选择目标虚拟环境 关键步骤：关闭并新建终端后重新激活环境 使用python -m pip方式安装依赖库 该方法成功解决了VSCode终端无法正确识别虚拟环境pip的问题，确保依赖安装在正确环境中。
2025-06-23 21:10:01
362
原创 [Java恶补day30] 142.环形链表Ⅱ（已归档）
给定链表头节点，要求返回环的入口节点（无环则返回null）。使用快慢指针法，当快慢指针相遇时，将慢指针和头节点同步移动，再次相遇点即为环入口。该方法时间复杂度O(n)，空间复杂度O(1)。核心思路基于数学推导：相遇点到入口的距离等于头节点到入口的距离。参考灵神题解图示解释原理。
2025-06-22 23:37:10
536
原创 [Java恶补day29] 141. 环形链表（已归档）
本文介绍了如何判断链表是否存在环的问题。通过快慢指针法，设置两个指针同时从头节点出发，快指针每次移动两步，慢指针每次移动一步。若两指针相遇则存在环，否则快指针到达链表末端时返回false。该方法时间复杂度O(n)，空间复杂度O(1)。示例和代码演示了如何实现这一算法，适用于处理节点数达10^4规模的链表。核心要点是必须在指针移动后再进行相遇判断，避免初始状态的误判。
2025-06-21 23:13:04
391
原创 [Java恶补day28] 234. 回文链表
判断单链表是否为回文链表的问题可以通过反转后半部分链表实现。先找到链表中间节点（使用遍历或快慢指针），反转后半部分链表，然后同时遍历前半部分和反转后的后半部分进行比较。时间复杂度O(n)，空间复杂度O(1)。两种实现方式：普通方法先计算链表长度再定位中间节点；快慢指针方法更高效，无需计算长度直接定位中间节点。两种方法都能满足线性时间复杂度和常数空间复杂度要求。
2025-06-19 20:57:42
348
原创 [Java恶补day27] 206.反转链表（已归档）
这篇题解介绍了反转链表的两种方法：迭代法和递归法。迭代法采用头插法，依次将节点插入新链表，时间复杂度O(n)，空间复杂度O(1)。递归法从最后一个节点开始处理，每次返回新链表头节点前需断开原有连接，时间复杂度O(n)，空间复杂度O(n)（递归栈）。两种方法都处理了空链表或单节点链表的特殊情况，并通过注释说明了核心思想和关键步骤。
2025-06-18 21:44:06
311
原创 [Java恶补day26] 160.相交链表
本文介绍了如何找出两个无环单链表的相交起始节点。通过双指针法，让指针分别遍历两个链表后交换遍历顺序，最终会在交点相遇。该方法时间复杂度O(m+n)，空间复杂度O(1)。示例演示了指针移动过程，Java代码实现了这一算法。关键点在于指针走过相同路径长度后必在交点相遇，若无交点则同时到达null节点。
2025-06-17 21:38:57
621
原创 [Java恶补day25] 153. 寻找旋转排序数组中的最小值
题目要求在一个旋转后的有序数组中寻找最小元素，需设计O(log n)算法。核心思路是利用二分查找，将中间元素与数组末尾比较：若中间值大于末尾值，说明最小值在右半段；否则在左半段。例如，数组[3,4,5,1,2]的最小值是1。通过不断缩小搜索范围，最终定位最小值位置。该算法高效且满足时间复杂度要求。
2025-06-16 21:42:22
843
原创 [Java恶补day24-day25] 33. 搜索旋转排序数组
题目要求在旋转后的有序数组中查找目标值target，要求时间复杂度为O(log n)。核心思路是利用二分查找，通过比较中间元素x与数组末尾元素的关系，确定x所在段（第一段或第二段），并结合target的位置关系缩小搜索范围。关键判断条件是x的位置与target的匹配情况，最终返回目标值下标或-1。示例代码展示了如何通过一次二分查找实现该算法，确保高效性。
2025-06-16 21:22:35
872
原创 [Java恶补day24] 整理模板·考点三【二分查找】
本文总结了二分查找的核心知识点和实现模板，重点介绍了红蓝染色法及其四种区间实现方式（闭区间、开区间、左开右闭、左闭右开）。关键点在于根据区间类型正确处理边界更新，避免溢出问题。通过LeetCode 34题（查找目标值范围）和2529题（统计正负数个数）的详细解析，展示了二分查找的实际应用。文章提供了完整的Java代码实现，强调时间复杂度为O(log n)的算法设计，并涵盖了数组基本操作的方法。
2025-06-13 22:33:24
1475
原创 [Java恶补day24] 74. 搜索二维矩阵
本文介绍了在满足特定条件的二维矩阵中查找目标值的三种方法。该矩阵每行元素非严格递增，且每行首元素大于前一行末元素。第一种暴力解法将矩阵转为一维数组后二分查找，时间复杂度O(mn)；第二种排除法从右上角开始逐步排除行列，时间复杂度O(m+n)；第三种二分查找将矩阵虚拟为一维数组进行查找，时间复杂度最优为O(log(mn))。三种方法分别展示了不同的空间-时间权衡，其中第三种方法既高效又节省空间。
2025-06-13 20:51:00
1019
Dev-Cpp 5.11 TDM-GCC 4.9.2 Setup.zip
2020-03-01
空空如也
TA创建的收藏夹 TA关注的收藏夹
TA关注的人