sysu63的博客

为了解决这个问题，我们可以使用深度优先搜索（DFS）的方法来遍历二叉树，并在遍历过程中计算从根节点到每个叶节点所代表的数字。这种方法的时间复杂度是 O(n)，其中 n 是树中节点的数量，因为每个节点都被访问一次。给你一个二叉树的根节点 root ，树中每个节点都存放有一个 0 到 9 之间的数字。例如，从根节点到叶节点的路径 1 -> 2 -> 3 表示数字 123。从根到叶子节点路径 4->9->5 代表数字 495。从根到叶子节点路径 4->9->1 代表数字 491。叶节点 是指没有子节点的节点。

这种方法的时间复杂度为 O(n)，因为每个数字最多只会被访问两次（一次是作为序列起点，另一次是在后续序列的扩展中）。这种方法的基本思想是利用集合快速查找的特点，对于每个数字，检查它是否是一个序列的起点（即没有前驱数字），然后从这个起点开始向后计数直到序列结束。解释：最长数字连续序列是 [1, 2, 3, 4]。输入：nums = [0,3,7,2,5,8,4,6,0,1]输入：nums = [100,4,200,1,3,2]输入：nums = [1,0,1,2]

输入：beginWord = “hit”, endWord = “cog”, wordList = [“hot”,“dot”,“dog”,“lot”,“log”,“cog”]输入：beginWord = “hit”, endWord = “cog”, wordList = [“hot”,“dot”,“dog”,“lot”,“log”]解释：一个最短转换序列是 “hit” -> “hot” -> “dot” -> “dog” -> “cog”, 返回它的长度 5。时，立即返回当前的层级数加一，表示从。

输入：beginWord = “hit”, endWord = “cog”, wordList = [“hot”,“dot”,“dog”,“lot”,“log”,“cog”]输入：beginWord = “hit”, endWord = “cog”, wordList = [“hot”,“dot”,“dog”,“lot”,“log”]输出：[[“hit”,“hot”,“dot”,“dog”,“cog”],[“hit”,“hot”,“lot”,“log”,“cog”]]这有助于快速找到只相差一个字符的单词。

这种方法的时间复杂度为 O(n)，其中 n 是字符串的长度，因为我们只遍历了字符串两次（一次用于过滤和转换，另一次用于比较）。如果在将所有大写字符转换为小写字符、并移除所有非字母数字字符之后，短语正着读和反着读都一样。给你一个字符串 s，如果它是 回文串 ，返回 true；解释：“amanaplanacanalpanama” 是回文串。解释：在移除非字母数字字符之后，s 是一个空字符串 “”。由于空字符串正着反着读都一样，所以是回文串。解释：“raceacar” 不是回文串。输入：s = " "

这种方法的时间复杂度为 O(n)，其中 n 是树中节点的数量，因为我们只需要遍历每个节点一次。空间复杂度取决于递归栈的深度，在最坏情况下是 O(n)（对于完全不平衡的树），但在平均情况下是 O(log n)（对于平衡树）。解释：最优路径是 15 -> 20 -> 7 ，路径和为 15 + 20 + 7 = 42。解释：最优路径是 2 -> 1 -> 3 ，路径和为 2 + 1 + 3 = 6。输入：root = [-10,9,20,null,null,15,7]路径和 是路径中各节点值的总和。

解释：在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4。随后，在第 7 天（股票价格 = 1）的时候买入，在第 8 天 （股票价格 = 4）的时候卖出，这笔交易所能获得利润 = 4-1 = 3。解释：在第 4 天（股票价格 = 0）的时候买入，在第 6 天（股票价格 = 3）的时候卖出，这笔交易所能获得利润 = 3-0 = 3。输入：prices = [3,3,5,0,0,3,1,4]将包含我们可以获得的最大利润。

解释：在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5 - 1 = 4。解释：在第 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5 - 1 = 4。随后，在第 4 天（股票价格 = 3）的时候买入，在第 5 天（股票价格 = 6）的时候卖出, 这笔交易所能获得利润 = 6 - 3 = 3。输入：prices = [7,1,5,3,6,4]返回 你能获得的 最大 利润。

这种方法的时间复杂度为 O(n)，空间复杂度为 O(1)，非常高效。解释：在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5。你只能选择 某一天 买入这只股票，并选择在 未来的某一个不同的日子 卖出该股票。同时，由于只使用了有限的额外变量，空间复杂度也非常低。给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。输入：prices = [7,6,4,3,1]输入：[7,1,5,3,6,4]

给定一个三角形 triangle ，找出自顶向下的最小路径和。每一步只能移动到下一行中相邻的结点上。相邻的结点 在这里指的是 下标 与 上一层结点下标 相同或者等于 上一层结点下标 + 1 的两个结点。也就是说，如果正位于当前行的下标 i ，那么下一步可以移动到下一行的下标 i 或 i + 1 。输入：triangle = [[2],[3,4],[6,5,7],[4,1,8,3]]输出：11解释：如下面简图所示：23 46 5 74 1 8 3自顶向下的最小路径和为 11（即，2 + 3 +

要解决这个问题，我们可以利用杨辉三角的性质：每一行的生成依赖于上一行的数据。为了达到 O(rowIndex) 的空间复杂度，我们只需要维护当前行的数据，并通过更新这一行的数据来生成下一行。给定一个非负索引 rowIndex，返回「杨辉三角」的第 rowIndex 行。这个方法巧妙地利用了单个数组的空间，在不增加额外空间复杂度的情况下完成了任务。你可以优化你的算法到 O(rowIndex) 空间复杂度吗？输入: rowIndex = 3。输入: rowIndex = 1。输出: [1,3,3,1]

这种方法的时间复杂度是 O(numRows^2)，因为我们需要生成 numRows 行，每行最多需要进行 numRows 次操作。空间复杂度也是 O(numRows^2)，因为我们需要存储所有的行数据。每一行的数字是基于上一行的数字计算得出的：每个数是它左上方和右上方的数之和。输出: [[1],[1,1],[1,2,1],[1,3,3,1],[1,4,6,4,1]]给定一个非负整数 numRows，生成「杨辉三角」的前 numRows 行。在「杨辉三角」中，每个数是它左上方和右上方的数的和。

解释：给定二叉树如图 A 所示，你的函数应该填充它的每个 next 指针，以指向其下一个右侧节点，如图 B 所示。填充它的每个 next 指针，让这个指针指向其下一个右侧节点。与之前提到的完美二叉树不同，这里的二叉树可能不是完美的，即某些节点可能只有一个子节点或者没有子节点。指针，使其指向同一层中的下一个右侧节点。的属性，并且保证了每次都能正确地找到下一层的起点，从而防止了潜在的。输入：root = [1,2,3,4,5,null,7]输出：[1,#,2,3,#,4,5,7,#]你只能使用常量级额外空间。

解释：给定二叉树如图 A 所示，你的函数应该填充它的每个 next 指针，以指向其下一个右侧节点，如图 B 所示。由于题目要求只能使用常量级额外空间（不包括递归调用栈的空间），我们需要避免使用额外的数据结构如队列来进行层次遍历。这种方法利用了完美二叉树的结构特点，通过简单的递归实现了高效的连接操作。这种方法利用了完美二叉树的特性，并且只使用了递归调用栈作为额外空间，符合题目的进阶要求。输入：root = [1,2,3,4,5,6,7]输出：[1,#,2,3,#,4,5,6,7,#]首先定义二叉树节点的类。

给你两个字符串 s 和 t ，统计并返回在 s 的 子序列 中 t 出现的个数，结果需要对 109 + 7 取模。这种方法的时间复杂度是 O(m * n)，空间复杂度也是 O(m * n)，其中。如下所示, 有 3 种可以从 s 中得到 “rabbit” 的方案。如下所示, 有 5 种可以从 s 中得到 “bag” 的方案。输入：s = “rabbbit”, t = “rabbit”输入：s = “babgbag”, t = “bag”我们可以定义一个二维的DP表。个字符的子序列出现的次数。

要将二叉树展开为一个单链表，并且该链表遵循先序遍历的顺序，我们可以采用原地算法来实现。这里我们将使用迭代的方法，因为它可以有效地利用常数空间复杂度（不包括输入和输出所需的空间）。这种方法利用栈来进行先序遍历，并在遍历过程中重构树结构，使其成为一个单链表。通过这种方式，我们能够在 O(n) 时间复杂度内完成任务，并且只使用 O(1) 额外空间（不计输入和输出所需的空间）。输出：[1,null,2,null,3,null,4,null,5,null,6]输入：root = [1,2,5,3,4,null,6]

具体来说，通过递归遍历树的每个节点，并在遍历过程中记录当前路径及其累积和，当到达叶子节点时检查累积和是否等于目标和。给你二叉树的根节点 root 和一个整数目标和 targetSum ，找出所有 从根节点到叶子节点 路径总和等于给定目标和的路径。输入：root = [5,4,8,11,null,13,4,7,2,null,null,5,1], targetSum = 22。输入：root = [1,2,3], targetSum = 5。输出：[[5,4,11,2],[5,8,4,5]]

判断该树中是否存在 根节点到叶子节点 的路径，这条路径上所有节点值相加等于目标和 targetSum。这种方法的时间复杂度是 O(n)，其中 n 是树中节点的数量，因为每个节点都被访问一次。输入：root = [5,4,8,11,null,13,4,7,2,null,null,null,1], targetSum = 22。要判断二叉树中是否存在从根节点到叶子节点的路径，使得路径上所有节点值之和等于目标和。解释：由于树是空的，所以不存在根节点到叶子节点的路径。叶子节点 是指没有子节点的节点。

使用广度优先搜索可以确保我们找到的第一个叶子节点就是最短路径上的节点，因为BFS是逐层探索的。通过递归的方式也可以解决问题，但需要注意的是，如果只简单地取左右子树深度的最小值，可能会误判。对于这个问题，它特别有用，因为它能保证第一次遇到的叶子节点就是距离根节点最近的那个。输入：root = [2,null,3,null,4,null,5,null,6]输入：root = [3,9,20,null,null,15,7]最小深度是从根节点到最近叶子节点的最短路径上的节点数量。树中节点数的范围在 [0,

判断一棵二叉树是否为平衡二叉树，主要是检查对于树中的每一个节点，其左右子树的高度差不超过1。平衡二叉树的定义是：一个二叉树每个节点的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。这个方法的时间复杂度接近 O(n)，其中 n 是树中节点的数量，因为每个节点只会被访问一次。输入：root = [1,2,2,3,3,null,null,4,4]输入：root = [3,9,20,null,null,15,7]树中的节点数在范围 [0, 5000] 内。输入：root = []