2301_80071187的博客

该题解使用深度优先搜索(DFS)在二维字符网格中查找给定单词。算法首先遍历网格每个位置，作为搜索起点。对于每个起点，通过DFS递归检查四个方向(上、下、左、右)是否能匹配单词后续字符。为避免重复使用同一单元格，搜索时临时将访问过的字符标记为空字符，搜索结束后恢复原值。若找到完整匹配路径则返回true，否则继续搜索其他起点。这种方法通过回溯遍历所有可能路径，确保正确判断单词是否存在网格中。

本文介绍了一种通过回溯算法生成所有有效括号组合的方法。给定n对括号，通过深度优先搜索(DFS)递归构建合法组合：维护当前左括号与右括号的平衡状态，确保任何前缀中左括号数量不少于右括号。算法使用一个路径数组记录左括号位置，当填满所有括号后将其转换为字符串存入结果列表。关键步骤包括枚举可能的右括号数量并递归处理后续选择，最后回溯移除当前选择。该方法高效地生成了所有可能的有效括号组合，时间复杂度为O(4^n/√n)，空间复杂度为O(n)。

给你一个 无重复元素 的整数数组 candidates 和一个目标整数 target ，找出 candidates 中可以使数字和为目标数 target 的 所有 不同组合 ，并以列表形式返回。你可以按 任意顺序 返回这些组合。candidates 中的 同一个 数字可以 无限制重复被选取 。如果至少一个数字的被选数量不同，则两种组合是不同的。 对于给定的输入，保证和为 target 的不同组合数少于 150 个。

该题解使用回溯算法解决电话号码字母组合问题。通过建立数字到字母的映射关系，递归遍历每个数字对应的所有字母可能性，逐步构建字母组合。当组合长度等于输入数字串长度时，将结果加入最终列表。算法时间复杂度为O(3^N×4^M)，其中N是3字母数字个数，M是4字母数字个数。空间复杂度为O(N)，主要用于存储递归栈和结果列表。

该问题要求返回给定整数数组的所有可能子集（幂集）。采用位掩码法解决：对于长度为n的数组，遍历0到2^n-1的所有掩码值，每个掩码对应一个子集。通过检查掩码的二进制位是否为1来决定是否包含对应元素。这种方法可以高效生成所有不重复的子集。例如，输入[1,2,3]时，会输出8个子集，包括空集和全集。算法时间复杂度为O(n*2^n)，空间复杂度为O(n)。

本文介绍了使用回溯算法生成数组所有排列的Java实现。通过深度优先搜索(DFS)递归遍历，维护当前路径(path)和已使用数字标记(used)。每次递归处理未使用的数字，创建新路径和标记数组以避免引用问题。当路径长度等于数组长度时，保存结果。算法时间复杂度为O(n*n!)，空间复杂度为O(n)。该实现能正确处理所有输入情况，包括空数组和单元素数组。

摘要： Trie（前缀树）是一种高效存储和检索字符串的数据结构，支持自动补全和拼写检查功能。本文实现了一个Trie类，包含插入(insert)、查找(search)和前缀匹配(startsWith)三个核心方法。通过节点数组存储子节点和结束标记来构建树形结构，其中insert方法构建路径，search检查完整单词，startsWith验证前缀存在性。算法采用二十六叉树结构，每个节点对应一个字母，时间复杂度为O(L)(L为单词长度)，空间复杂度O(N*26)(N为节点数)。示例演示了插入"apple

这道题目考察课程安排的可行性，本质上是检测有向图中是否存在环。我们可以使用拓扑排序来解决： 构建入度数组和邻接表，记录每门课程的先修关系 将所有入度为0的课程入队 通过BFS逐步处理课程，将处理完的课程从图中"移除" 检查最终处理的课程数是否等于总课程数 如果存在环，则某些课程的入度永远不会降为0，导致无法完成所有课程。时间复杂度为O(V+E)，空间复杂度为O(V+E)，其中V是课程数，E是先修关系数。

这是一道关于网格中橘子腐烂过程的广度优先搜索(BFS)问题。给定一个m×n网格，其中0表示空单元格，1表示新鲜橘子，2表示腐烂橘子。每分钟腐烂橘子会感染周围4个方向的新鲜橘子。算法使用队列来存储所有初始腐烂橘子位置，然后逐一处理它们对周围新鲜橘子的影响，每轮处理代表1分钟。如果最终仍有新鲜橘子剩余则返回-1，否则返回所需最小分钟数。关键点在于使用BFS模拟腐烂过程，并准确统计剩余新鲜橘子数量。

文章摘要： 该题要求计算二维网格中由相邻'1'（陆地）组成的岛屿数量。解题思路是遍历网格，遇到'1'时通过BFS或DFS将其相邻陆地标记为已访问，避免重复计数。示例代码使用BFS实现：当发现新岛屿时增加计数，并扩散标记所有相连陆地。例如，输入网格1输出1个岛屿，网格2输出3个岛屿。时间复杂度为O(M×N)，空间复杂度最坏情况下为O(M×N)。（字数：149）

本文介绍了如何寻找二叉树中两个节点的最近公共祖先(LCA)。通过递归方法，从根节点开始遍历左右子树，当找到目标节点或遍历到叶子节点时返回。如果左右子树均找到目标节点，则当前节点即为LCA；若仅单侧找到，则返回该侧结果。算法时间复杂度为O(n)，空间复杂度为O(n)。关键点在于利用递归和条件判断来定位LCA的位置。

该题目要求在二叉树中找出路径和等于目标值的路径数目，路径方向必须向下（父节点到子节点）。解法采用深度优先搜索(DFS)结合前缀和思路，使用哈希表记录路径和出现次数。算法从根节点开始递归遍历，维护当前路径和，查找是否存在满足条件的子路径。时间复杂度为O(n)，空间复杂度为O(n)，其中n为节点数。通过递归处理左右子树并维护哈希表状态，最终统计所有符合条件的路径数目。

这篇文章介绍了如何根据二叉树的前序遍历和中序遍历结果重建二叉树。通过递归方法，利用前序遍历确定根节点，在中序遍历中划分左右子树范围，逐步构建整棵树。文章提供了Java代码实现，包括使用HashMap存储中序遍历索引以提高查找效率，以及递归函数的详细解释。该方法的时间复杂度为O(n)，空间复杂度为O(n)，适用于处理给定的两种遍历序列来还原原始二叉树结构。

本文介绍了将二叉树展开为单链表的算法。通过修改指针指向，将二叉树按先序遍历顺序转换为右指针单向链接的链表。关键步骤是：当左子树存在时，找到其最右节点，将原右子树接在其后，再将左子树移到右子树位置并清空左指针。算法时间复杂度为O(n)，空间复杂度O(1)，采用原地修改的方式逐步将二叉树转为链表结构。

该题目要求返回二叉树的右视图，即从右侧看树时每层最右边的节点值。解题采用深度优先搜索(DFS)方法，先递归右子树再左子树，确保每层首次访问的节点就是最右侧节点。当当前深度等于结果列表长度时，将该节点值加入列表。对于空树返回空列表。时间复杂度为O(n)，空间复杂度为O(h)，h为树高。

文章摘要： 题目要求在二叉搜索树中查找第k小的元素。解题思路是利用二叉搜索树中序遍历的特性（节点值按升序排列），通过深度优先搜索（DFS）遍历树结构。代码实现中定义了一个Solution类，包含递归遍历方法dfs和主方法kthSmallest。当遍历到第k个节点时记录结果并返回。该方法的时间复杂度为O(n)，空间复杂度为O(h)，其中n是节点数，h是树高度。示例显示对于输入[3,1,4,null,2]和k=1，输出为1；输入[5,3,6,2,4,null,null,1]和k=3，输出为3。

摘要：本文介绍了如何判断一个二叉树是否为有效的二叉搜索树(BST)。BST需满足：左子树所有节点小于当前节点，右子树所有节点大于当前节点，且左右子树本身也是BST。通过递归方法实现，每个节点检查其值是否在允许范围内，并递归验证左右子树。给出的Java解法使用上下界约束，初始范围为Long的最小/最大值，逐步缩小范围进行验证。示例表明该方法能正确识别有效和无效的BST结构。

本文将升序数组转换为平衡二叉搜索树(BST)。通过递归算法，每次取数组中间元素作为根节点，左半部分构建左子树，右半部分构建右子树，确保树的高度平衡。时间复杂度O(n)需访问每个元素一次，空间复杂度O(logn)由递归栈深度决定。关键点在于分治策略和中间元素的选择，保证左右子树节点数差不超过1，从而自动满足平衡条件。

本文介绍了二叉树的层序遍历实现方法。核心思路是使用队列进行广度优先搜索，每次处理一层节点。算法步骤如下：1)初始化队列，若根节点非空则入队；2)循环直到队列为空，每次记录当前层节点数；3)处理当前层节点，将其值存入临时列表，同时将子节点入队；4)将当前层结果加入最终结果列表。该方法保证节点按层级顺序输出，时间复杂度为O(n)，空间复杂度为O(n)。示例代码展示了Java实现，清晰演示了如何逐层遍历二叉树并收集结果。

该题要求计算二叉树的直径，即树中任意两节点间最长路径的长度。采用深度优先搜索（DFS）方法，递归遍历每个节点，计算其左右子树高度。关键步骤是：空节点返回-1；计算左右子树高度并加1；更新最大直径为左右高度之和；返回当前节点最大高度。时间复杂度O(n)，空间复杂度O(n)。通过后序遍历，可在遍历过程中高效获取树的最大直径。

这道题目要求检查给定的二叉树是否轴对称。解决方法是使用递归的方式，比较左右子树的对称性。主方法首先处理根节点为空的情况，然后调用辅助递归函数比较左子树和右子树。递归函数判断三种情况：两子树都为空返回true；只有一个子树为空返回false；节点值不相等返回false。否则继续递归比较左子树的左孩子与右子树的右孩子，以及左子树的右孩子与右子树的左孩子。只有当所有对应节点都满足镜像条件时，才返回true，表明二叉树是对称的。

摘要：本文介绍如何翻转二叉树。通过递归方法，先交换当前节点的左右子树，然后递归处理左右子树。对于空树直接返回null。时间复杂度为O(n)，空间复杂度为O(h)，其中n是节点数，h是树的高度。示例展示了输入[4,2,7,1,3,6,9]翻转后得到[4,7,2,9,6,3,1]的过程。

本文介绍了如何计算二叉树的最大深度。最大深度定义为从根节点到最远叶子节点的最长路径上的节点数。解决方案采用递归方法：若根节点为空返回0；否则递归计算左右子树的最大深度，取较大值加1（当前节点）作为结果。算法时间复杂度为O(n)，需要遍历所有节点。示例代码展示了Java实现，清晰地体现了分治思想：将问题分解为左右子树的子问题，合并结果得到最终解。

摘要：本文介绍了二叉树中序遍历的实现方法。通过递归方式，先遍历左子树，再访问根节点，最后遍历右子树。代码使用Java编写，定义了一个辅助函数inorder()进行递归遍历，主函数inorderTraversal()初始化结果列表并调用递归函数。当节点为空时递归终止，否则按照左-根-右顺序处理节点值。该方法能正确输出示例的中序遍历结果[1,3,2]。

请你设计并实现一个满足 LRU (最近最少使用) 缓存 约束的数据结构。函数 get 和 put 必须以 O(1) 的平均时间复杂度运行。// 缓存是 {1=1}// 缓存是 {1=1, 2=2}// 返回 1// 该操作会使得关键字 2 作废，缓存是 {1=1, 3=3}// 返回 -1 (未找到)// 该操作会使得关键字 1 作废，缓存是 {4=4, 3=3}// 返回 -1 (未找到)// 返回 3// 返回 4。

本文介绍了如何对链表进行升序排序。使用分治法，先通过快慢指针找到链表中点并断开连接，然后递归排序左右两部分，最后合并两个有序链表。关键点包括：1) middleNode方法使用快慢指针找中点并断开连接；2) mergeTwoLists方法通过哨兵节点合并两个有序链表；3) sortList方法递归实现分治排序。时间复杂度为O(nlogn)，空间复杂度为O(logn)。这种方法将链表排序问题分解为876题（找中点）和21题（合并有序链表）的组合。

本文介绍了如何深度复制带有随机指针的链表。通过三次遍历：第一次在原节点后插入复制节点，第二次设置复制节点的random指针，第三次将新旧链表拆分。这种方法保证了复制链表中的节点都是全新的，且不指向原链表节点。时间复杂度为O(n)，空间复杂度为O(1)（不包括返回的新链表）。关键点在于巧妙利用原链表结构来建立新旧节点间的映射关系，从而高效地完成深度复制。

本文介绍了如何通过递归方法两两交换链表中的相邻节点。题解给出了一个Java实现，当链表为空或只有一个节点时直接返回；否则递归处理后续节点，并将当前两个节点交换位置。该方法时间复杂度为O(n)，空间复杂度为O(1)，仅使用常数个额外变量完成节点交换。关键步骤包括获取第二个节点、递归处理后续节点对，以及调整节点指针完成交换。

本文介绍了删除链表倒数第n个节点的算法。通过创建虚拟头节点处理边界情况，先遍历链表获取长度，再计算目标位置索引。使用双指针法定位到目标节点的前驱节点后执行删除操作。该算法时间复杂度为O(N)，空间复杂度O(1)，适用于单链表结构。示例代码展示了完整的实现过程，包括链表长度计算、目标节点定位和删除操作等关键步骤。

本文介绍了如何将两个升序链表合并为一个新的升序链表。通过递归方法，比较两个链表头节点的值，将较小的节点连接到剩余部分的链表上，最终返回合并后的链表。示例代码展示了在Java中的实现，解析部分详细说明了递归的逻辑和每一步的作用。该方法适用于处理两个已排序链表的合并问题，确保最终结果仍保持升序。

题目要求检测链表中是否存在环，并返回环的起始节点。如果链表无环，则返回 null。通过使用哈希集合（HashSet）存储已访问的节点，可以在遍历链表时判断是否遇到重复节点，从而检测环的存在。具体实现步骤如下：初始化一个指针指向链表头节点，并创建一个空哈希集合。遍历链表，检查当前节点是否已在集合中。如果存在，则说明链表有环，返回该节点；否则，将节点加入集合并继续遍历。如果遍历结束后未发现重复节点，则返回 null 表示链表无环。该方法的时间复杂度为 O(n)，空间复杂度为 O(n)。

题目要求判断一个链表中是否存在环。通过使用快慢指针（Floyd判圈算法）可以高效解决该问题。快指针每次移动两步，慢指针每次移动一步，如果链表中存在环，快慢指针最终会相遇；如果不存在环，快指针会先到达链表末尾。示例中展示了不同情况下的链表结构及判断结果。代码实现中，通过循环遍历链表，比较快慢指针的位置来判断是否存在环。该方法时间复杂度为O(n)，空间复杂度为O(1)，是一种高效的解决方案。

本文介绍了一种判断单链表是否为回文链表的方法。通过将链表的值复制到数组中，然后使用双指针从数组两端向中间遍历，比较对应位置的值是否相等。如果所有对应位置的值都相等，则链表为回文链表，返回 true；否则返回 false。该方法的时间复杂度和空间复杂度均为 O(n)，其中 n 是链表中的节点数。代码实现简洁，适用于处理单链表的回文判断问题。

题目要求反转单链表，并返回反转后的链表。通过示例可以看出，输入链表的节点顺序将被完全颠倒。题解提供了一个Java实现，使用迭代方法反转链表。具体步骤包括：初始化两个指针pre和cur，分别指向前一个节点和当前节点；在循环中，保存当前节点的下一个节点，将当前节点的指针指向前一个节点，然后更新pre和cur继续遍历链表；最终返回pre作为反转后的链表头节点。该算法的时间复杂度为O(n)，空间复杂度为O(1)，适用于原地修改链表指针的场景。

给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点，返回 null 。图示两个链表在节点 c1 开始相交：

编写一个高效的算法来搜索 m x n 矩阵 matrix 中的一个目标值 target。该矩阵具有以下特性：每行的元素从左到右升序排列。每列的元素从上到下升序排列。

给定一个 n × n 的二维矩阵 matrix 表示一个图像。请你将图像顺时针旋转 90 度。你必须在 原地 旋转图像，这意味着你需要直接修改输入的二维矩阵。请不要 使用另一个矩阵来旋转图像。示例 1：输入：matrix = [[1,2,3],[4,5,6],[7,8,9]]输出：[[7,4,1],[8,5,2],[9,6,3]]示例 2：输入：matrix = [[5,1,9,11],[2,4,8,10],[13,3,6,7],[15,14,12,16]]

给你一个 m 行 n 列的矩阵 matrix ，请按照 顺时针螺旋顺序 ，返回矩阵中的所有元素。示例 1：输入：matrix = [[1,2,3],[4,5,6],[7,8,9]]输出：[1,2,3,6,9,8,7,4,5]示例 2：输入：matrix = [[1,2,3,4],[5,6,7,8],[9,10,11,12]]输出：[1,2,3,4,8,12,11,10,9,5,6,7]

给定一个 m x n 的矩阵，如果一个元素为 0 ，则将其所在行和列的所有元素都设为 0。请使用 原地 算法。示例 1：输入：matrix = [[1,1,1],[1,0,1],[1,1,1]]输出：[[1,0,1],[0,0,0],[1,0,1]]示例 2：输入：matrix = [[0,1,2,0],[3,4,5,2],[1,3,1,5]]输出：[[0,0,0,0],[0,4,5,0],[0,3,1,0]]

给你一个整数数组 nums，返回 数组 answer ，其中 answer[i] 等于 nums 中除 nums[i] 之外其余各元素的乘积。题目数据 保证 数组 nums之中任意元素的全部前缀元素和后缀的乘积都在 32 位 整数范围内。请 不要使用除法，且在 O(n) 时间复杂度内完成此题。示例 1:输入: nums = [1,2,3,4]输出: [24,12,8,6]示例 2:输入: nums = [-1,1,0,-3,3]输出: [0,0,9,0,0]