m0_62645012的博客

这个算法的时间复杂度是 O(n)，其中 n 是字符串 s 的长度，因为需要遍历整个字符串一次。空间复杂度也是 O(n)，因为需要存储哈希表和结果集合。这个算法的思路是使用一个哈希表来记录每个长度为10的子串的出现次数。，返回所有在 DNA 分子中出现不止一次的。时，识别 DNA 中的重复序列非常有用。的序列(子字符串)。由一系列核苷酸组成，缩写为。

给定二叉树如图 A 所示，你的函数应该填充它的每个 next 指针，以指向其下一个右侧节点，如图 B 所示。这道题希望我们把二叉树各个层的点组织成链表，一个非常直观的思路是层次遍历。树的层次遍历基于广度优先搜索，它按照层的顺序遍历二叉树，在遍历第 iii 层前，一定会遍历完第 i−1 层。当队列不为空的时候，记录当前队列大小为 n，从队列中以此取出 n 个元素并通过这 n 个元素拓展新节点。填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为。

这个问题可以看作是n个排列成一行的空格，我们需要从左向右填入给定的n个数，每个只能使用一次，那么很直接的可以想到穷举法，从左向右依次填入，看能不能填完这个n个空格，在这个过程可以使用回溯来模拟。first现在指向2，之后2和2自己进行交换，有人可能回想为什么2还要与自己进行交换，因为1 2 3 4 5 6 本身也是一种排列，难道不是吗？然后first指向3，同理，自身与自身交换一次，然后一直回溯，。这个情况就表示已经填完了n个位置，可以进行一次排列的收集。之后first左边的固定了，右边的还在回溯。

通过使用滑动窗口和哈希表的方法，我们能够高效地解决寻找最长无重复子串的问题。这种方法的时间复杂度是 O(n)，其中 n 是输入字符串的长度。我们的解决方案在处理大量数据时表现良好，能够在短时间内找到最长无重复子串，并返回其长度。为了解决这个问题，我们可以使用滑动窗口和哈希表的方法。给定一个字符串，我们需要找到该字符串中的最长无重复子串的长度。最长无重复子串是 "abc"，它的长度为 3。

由于B树的每一个节点都包含key和value，因此我们根据key查找value时，只需要找到key所在的位置，就能找到value，但B+树只有叶子结点存储数据，索引每一次查找，都必须一次一次，一直找到树的最大深度处，也就是叶子结点的深度，才能找到value。b树在内存存储数据时，减少了在页间的查询次数，增加了页内的查询次数，页内查询比页间查询更耗时，所以内存使用红黑树。1.由于B+树在非叶子结点上不包含真正的数据，只当做索引使用，因此在内存相同的情况下，能够存放更多的key；

每次取出堆顶元素 xxx，则 xxx 是堆中最小的丑数，由于 2x,3x,5x 也是丑数，因此将 2x,3x,5x 加入堆。为了避免重复元素，可以使用哈希集合去重，避免相同元素多次加入堆。[1, 2, 3, 4, 5, 6, 8, 9, 10, 12] 是由前 10 个丑数组成的序列。在排除重复元素的情况下，第 n 次从最小堆中取出的元素即为第 n 个丑数。要得到从小到大的第 nnn 个丑数，可以使用最小堆实现。首先将最小的丑数 111 加入堆。时间复杂度：O(nlogn)

动态规划概念适用性适用动态规划的问题必须满足最优化原理和无后效性。最优化原理可这样阐述：一个最优化策略具有这样的性质，不论过去状态和决策如何，对前面的决策所形成的状态而言，余下的诸决策必须构成最优策略。简而言之，一个最优化策略的子策略总是最优的。一个问题满足最优化原理又称其具有最优子结构性质。将各阶段按照一定的次序排列好之后，对于某个给定的阶段状态，它以前各阶段的状态无法直接影响它未来的决策，而只能通过当前的这个状态。换句话说，每个状态都是过去历史的一个完整总结。这就是无后向性，又称为无后效性。

对于两个长度相同的字符串，最左边不同的字符决定了其字典序大小，例如，对于 A = xxaxxx，B = xxbxxx，如果 a > b， 则 A > B。如果删除k个字符使其删除后字典序最小，等同与先删除1个字符使其字典序最小，删除后的新字符串便形成了一个【子问题】，继续同样策略。哪个字符串大取决于两个字符串中第1个对应不相等的字符，所以我们应该将最小的字符尽可能的放在前面。如果选择要一个字符，是否可以入栈，还需要判断之前是否已经选择过该字符：该字符是否存在单调栈中。（要求不能打乱其他字符的相对位置）。

找到链表的中点，以中点为分界，将链表拆分成两个子链表。寻找链表的中点可以使用快慢指针的做法，快指针每次移动 2 步，慢指针每次移动 1 步，当快指针到达链表末尾时，慢指针指向的链表节点即为链表的中点。递归的终止条件是链表的节点个数小于或等于 111，即当链表为空或者链表只包含 111 个节点时，不需要对链表进行拆分和排序。将两个排序后的子链表合并，得到完整的排序后的链表。可以使用「21. 合并两个有序链表」的做法，将两个有序的子链表进行合并。对链表自顶向下归并排序的过程如下。对两个子链表分别排序。

仔细看下题目的 输入 和 输出，输出的左右子树的位置跟输入正好是相反的，于是我们可以递归的交换左右子树来完成这道题。交换当前节点的左右节点，再递归的交换当前节点的左节点，递归的交换当前节点的右节点。我们在做二叉树题目时候，第一想到的应该是用 递归 来解决。其实就是交换一下左右节点，然后再递归的交换左节点，右节点。时间复杂度：每个元素都必须访问一次，所以是O(n)根据动画图我们可以总结出递归的两个条件如下：.终止条件：当前节点为 null 时返回。，翻转这棵二叉树，并返回其根节点。给你一棵二叉树的根节点。

如果两个二叉树都不为空，那么首先判断它们的根节点的值是否相同，若不相同则两个二叉树一定不同，若相同，再分别判断两个二叉树的左子树是否相同以及右子树是否相同。对两个二叉树同时进行深度优先搜索，只有当两个二叉树中的对应节点都不为空时才会访问到该节点，因此被访问到的节点数不会超过较小的二叉树的节点数。空间复杂度取决于递归调用的层数，递归调用的层数不会超过较小的二叉树的最大高度，最坏情况下，二叉树的高度等于节点数。如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。给你两棵二叉树的根节点。

二叉树的中序遍历即按照访问左子树——根结点——右子树的方式遍历二叉树；在访问其左子树和右子树时，我们也按照同样的方式遍历；因为二叉搜索树和中序遍历的性质，所以二叉搜索树的中序遍历是按照键增加的顺序进行的。于是，我们可以通过中序遍历找到第 k个最小元素。所有左子树和右子树自身必须也是二叉搜索树。结点的左子树只包含小于当前结点的数。结点的右子树只包含大于当前结点的数。时间复杂度：O(H),h是树的高度。，请你设计一个算法查找其中第。个最小元素（从 1 开始计数）。给定一个二叉搜索树的根节点。

创建一个新的子节点，记录在children 数组的对应位置上，然后沿着指针移动到子节点，继续搜索下一个字符。若搜索到了前缀的末尾，就说明字典树中存在该前缀。此外，若前缀末尾对应节点的 isEnd为真，则说明字典树中存在该字符串。重复以上步骤，直到处理字符串的最后一个字符，然后将当前节点标记为字符串的结尾。说明字典树中不包含该前缀，返回空指针。

在中序遍历中对根节点进行定位时，一种简单的方法是直接扫描整个中序遍历的结果并找出根节点，但这样做的时间复杂度较高。由于同一颗子树的前序遍历和中序遍历的长度显然是相同的，因此我们就可以对应到前序遍历的结果中，对上述形式中的所有左右括号进行定位。在「递归」地遍历某个子树的过程中，我们也是将这颗子树看成一颗全新的树，按照上述的顺序进行遍历。这样以来，我们就知道了左子树的前序遍历和中序遍历结果，以及右子树的前序遍历和中序遍历结果，我们就可以递归地对构造出左子树和右子树，再将这两颗子树接到根节点的左右位置。

首先需要遍历环形字符串 s，然后记录每个位置开始的子字符串中 'o' 字符出现的次数。为了处理环形的情况，我们可以将字符串复制一次并连接起来，这样就可以处理环形的情况了。然后，我们可以从每个位置开始，向前或向后遍历，统计 'o' 字符出现的次数，并记录下来。最后，我们找到出现偶数次 'o' 字符的最长子字符串的长度。给你一个字符串 s，字符串s首尾相连成一个环形 ，请你在环中找出 'o' 字符出现了偶数次最长子字符串的长度。输入是一串小写字母组成的字符串。

组合问题，相对于排列问题而言，不计较一个组合内元素的顺序性（即 [1, 2, 3] 与 [1, 3, 2] 认为是同一个组合），因此很多时候需要按某种顺序展开搜索，这样才能做到不重不漏。每一个结点递归地在做同样的事情，区别在于搜索起点，因此需要一个变量 start ，表示在区间 [begin, n] 里选出若干个数的组合；叶子结点的信息体现在从根结点到叶子结点的路径上，因此需要一个表示路径的变量 path，它是一个列表，特别地，path 是一个栈；回溯算法首先需要画出递归树，不同的树决定了不同的代码实现。

被围绕的区间不会存在于边界上，换句话说，任何边界上的 'O' 都不会被填充为 'X'。任何不在边界上，或不与边界上的 'O' 相连的 'O'时间复杂度：O(n×m)，其中 n 和 m 分别为矩阵的行数和列数。那么想直接找被X包围O很难，因为被X包围的O不知有一个，可能连成片，所以想直接找上下左右判断不切时间，pass。那就想到用边缘的O,来做深度优先遍历，这样，一路上所有的O都是不符合条件的，让他改为其他字符。体中要求把所有被x包围的O换成X,没有被X包围的O不用理会。围绕的区域，并将这些区域里所有的。

当我们 i 个元素时，计算 nums[i]+nums[i+1] 的值，并判断该值是否已经出现过即可。子数组 [nums[0],nums[1]] 和 [nums[1],nums[2]] 的和相等，都为 0。注意即使子数组的元素相同，这两个子数组也视为不相同的子数组，因为它们在原数组中的起始位置不同。元素为 [4,2] 和 [2,4] 的子数组有相同的和 6。判断的操作可以使用一个哈希表，记录已经出现过的值。注意，这两个子数组起始位置的下标必须。没有长度为 2 的两个子数组和相等。空间复杂度：O(n)。

[3,2,1,6,0,5] 中的最大值是 6 ，左边部分是 [3,2,1] ，右边部分是 [0,5]。- [3,2,1] 中的最大值是 3 ，左边部分是 [] ，右边部分是 [2,1]。- [2,1] 中的最大值是 2 ，左边部分是 [] ，右边部分是 [1]。用递归实现，construct(int[] nums,int left,int right)。- [0,5] 中的最大值是 5 ，左边部分是 [0] ，右边部分是 []。- 只有一个元素，所以子节点是一个值为 1 的节点。

对于格子 (r, c) 来说（r 和 c 分别代表行坐标和列坐标），四个相邻的格子分别是 (r-1, c)、(r+1, c)、(r, c-1)、(r, c+1)。每走过一个陆地格子，就把格子的值改为 2，这样当我们遇到 2 的时候，就知道这是遍历过的格子了。网格结构的 DFS 与二叉树的 DFS 最大的不同之处在于，遍历中可能遇到遍历过的结点。这是因为，网格结构本质上是一个「图」，我们可以把每个格子看成图中的结点，每个结点有向上下左右的四条边。（水）组成的的二维网格，请你计算网格中岛屿的数量。

具体代码中，当检查第i位时，我们可以让 n 与 1左移i位 进行与运算，当且仅当 n 的第 i 位为 1 时，运算结果不为 0。编写一个函数，输入是一个无符号整数（以二进制串的形式），返回其二进制表达式中数字位数为 '1' 的个数（也被称为。们可以直接循环检查给定整数 nnn 的二进制位的每一位是否为 111。中，共有 31 位为 '1'中，共有三位为 '1'。中，共有一位为 '1'。

在算法实现中，可以使用递归或栈来实现深度优先搜索。递归是DFS的一种自然表达方式，但在实践中可能会导致栈溢出。另一种方法是使用显式的栈来模拟递归过程，这样可以避免栈溢出的问题，并允许更大规模的数据处理。岛屿总是被水包围，并且每座岛屿只能由水平方向和/或竖直方向上相邻的陆地连接形成。（水）组成的的二维网格，请你计算网格中岛屿的数量。此外，你可以假设该网格的四条边均被水包围。

📝。

dp[][]表示从三角形顶部走到(i , j)的最小路径和，这个i和j指定是三角形中第i行第j列(下标从0开始）

它的基本思路是逐步构建解决方案，当发现当前方案不可行时，进行回溯（撤销上一步的选择），并尝试其他的选择，直到找到问题的解决方案或者确定不存在解决方案为止。将问题转化为一个决策树，每个节点代表一个决策点，通过递归的方式遍历这棵决策树，尝试所有可能的选择。在递归函数中，首先检查当前索引是否越界，如果越界，则将当前生成的组合字符串加入结果列表中，并返回。遍历这个字母列表，每次取出一个字母，将其加入当前生成的组合字符串中，并调用递归函数处理下一个数字。首先，创建一个映射表，将数字与字母的对应关系存储起来。

层次遍历的特点是，它保证了在遍历过程中，同一层的节点会先于下一层的节点被访问。这种遍历方式对于需要按层级处理树节点的情况非常有用，例如在解决本问题中，需要计算每一层节点的元素之和，因此使用层次遍历能够很方便地实现这个目标。树的层次遍历是一种按照树的层级顺序逐层遍历节点的方法。在层次遍历中，首先访问树的根节点，然后依次访问每一层的节点，从上到下、从左到右地顺序访问。所以我们返回第 2 层的层号，它的层内元素之和最大。第 3 层各元素之和为 7 + -8 = -1，层，而根节点的子节点位于第。

可以发现的是，我们将数组从中间分开成左右两部分的时候，一定有一部分的数组是有序的。拿示例来看，我们从 6 这个位置分开以后数组变成了 [4, 5, 6] 和 [7, 0, 1, 2] 两个部分，其中左边 [4, 5, 6] 这个部分的数组是有序的，其他也是如此。如果不是升序序列，即处于旋转点右侧，则判断目标值是否在右半部分的升序序列中。如果是升序序列，则判断目标值是否在该升序序列中，如果在，则将右边界移动到中间元素的左侧；数组本身不是有序的，进行旋转后只保证了数组的局部是有序的，这还能进行二分查找吗？

创建一个虚拟节点 dummy，并将其 next 指向 head，这样做是为了简化边界情况的处理。找到左边界的前一个节点 prev。遍历链表，移动 prev 指针到第 left - 1 个节点处。从 prev 开始，遍历链表直到达到右边界的位置 right。在遍历过程中，依次将当前节点的 next 指针指向其后继节点的后继节点（即跳过当前节点

先检查头节点和头节点的下一个节点是否为null，如果是，则返回false。然后使用快慢指针方法，初始化快指针为头节点的下一个节点，慢指针为头节点，然后在一个while循环中，快慢指针分别向前移动。如果快指针或快指针的下一个节点为null，说明链表无环，返回false；然后，我们从头节点开始遍历链表，对于每个节点，我们检查它是否已经在HashSet中存在，如果存在则说明链表有环，返回true；快指针每次移动两步，慢指针每次移动一步，如果存在环，快指针最终会追上慢指针。链表中有一个环，其尾部连接到第二个节点。

针对包含Unicode字符的情况，我们需要一种通用的方法来记录字符频率。一种简单有效的方法是使用一个哈希表，其中键是字符，值是该字符在字符串中出现的次数。我们可以遍历字符串，将字符及其出现的次数记录在哈希表中。然后，我们比较两个字符串的哈希表，如果它们相同，则说明两个字符串是字母异位词。这种方法可以处理包含Unicode字符的情况，因为哈希表可以处理任何字符类型的键。首先判断两个字符串长度是否相等，不相等则直接返回 false。如果哈希表的值都为 0，则二者是字母异位词。中每个字符出现的次数都相同，则称。

从根到叶子节点路径 4->9->5 代表数字 495从根到叶子节点路径 4->9->1 代表数字 491从根到叶子节点路径 4->0 代表数字 40。在树的情境下，递归特别适用，因为树的结构本身就是递归定义的。从根到叶子节点路径 1->2 代表数字 12从根到叶子节点路径 1->3 代表数字 13因此，数字总和 = 12 + 13 = 25。我们就能够递归地计算出从根节点到每个叶子节点的路径所代表的数字之和。时，将路径所代表的数字加到总和中。计算从根节点到叶节点生成的。是指没有子节点的节点。

循环，但由于每个字符最多只会进入窗口两次（一次进入，一次出去），整体的时间复杂度仍然是 O(n1)，其中 n1 为字符串。t 中两个字符 'a' 均应包含在 s 的子串中，因此没有符合条件的子字符串，返回空字符串。最小覆盖子串 "BANC" 包含来自字符串 t 的 'A'、'B' 和 'C'。这个算法通过滑动窗口的方式，优化了暴力搜索的复杂度，使得算法在时间上更为高效。所有不同字符，因此空间复杂度为 O(n2)，其中 n2 为字符串。所有字符的子串，则返回空字符串。所有字符的最小子串。

因为无重复字符的最长子串是 "abc"，所以其长度为 3。因为无重复字符的最长子串是 "b"，所以其长度为 1。在哈希集合中，说明出现了重复字符。因为无重复字符的最长子串是 "wke"，分别表示当前子串的起始和结束位置。，请你找出其中不含有重复字符的。指针右移，更新最长子串的长度。为 0，然后开始遍历字符串。不在哈希集合中，说明可以将。）来存储当前窗口内的字符。使用一个哈希集合（例如。加入当前窗口，然后将。指针遍历完整个字符串。返回最长子串的长度。

无论怎样，总会到达下标为 3 的位置。但该下标的最大跳跃长度是 0 ， 所以永远不可能到达最后一个下标。使用动态规划来维护一个数组，记录到达每个位置是否可行。如果最终数组的最后一个元素为。可以先跳 1 步，从下标 0 到达下标 1, 然后再从下标 1 跳 3 步到达最后一个下标。使用贪心算法来维护能够到达的最远位置 (数组中的每个元素代表你在该位置可以跳跃的最大长度。判断你是否能够到达最后一个下标，如果可以，返回。大于等于数组的最后一个位置，返回。，则表示可以到达最后一个下标。贪心算法：时间复杂度O(n)

函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4。注意这五个元素可为任意顺序。你不需要考虑数组中超出新长度后面的元素。元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。不要使用额外的数组空间，你必须仅使用。的元素，并返回移除后数组的新长度。函数应该返回新的长度 2。

给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。但这里有一个细节需要处理，当我们第二轮迭代的时候，p 指向 3，q 指向 4。我们通过 a.next = b.next，以及b.next=a就把两个指针的位置反转了，于是1->2就变成2->1。用来记录上一轮 p 的位置，然后下一轮迭代的时候，将原先的 p(也就是节点 1)指向 4。第二轮的时候 p 指向 3，q 指向 4。在迭代的时候，每次处理两个节点，于是第一轮 p指向 1，q 指向 2。这里我们需要三个指针，p，q，temp。

双指针是一种常用的算法技巧，通常用于数组或链表等数据结构的遍历和搜索。在数组中找两个数的和等于目标值的问题中，就可以使用左右指针的方法。，则找到了满足条件的两个数，返回它们的下标（注意下标是从1开始的）。初始化两个指针，一个指向数组的起始位置，另一个指向数组的末尾。重复步骤2-5，直到找到满足条件的两个数或者指针相遇。如果和小于目标值，将左指针向右移动一位，以增大和。如果和大于目标值，将右指针向左移动一位，以减小和。如果和等于目标值，找到了答案，返回相应的结果。常见的双指针模式有两种：快慢指针和左右指针。

遍历单词数组，从最后一个单词开始向前遍历，将每个单词追加到一个新的字符串中。返回的结果字符串中，单词间应当仅用单个空格分隔，且不包含任何额外的空格。将会根据一个或多个空白字符将字符串分割成一个字符串数组，其中数组的每个元素就是一个单词。时间复杂度： O(n + m)，其中 n 是输入字符串的长度，m 是单词的总数。如果两个单词间有多余的空格，反转后的字符串需要将单词间的空格减少到仅有一个。这个思路通过逐步操作字符串来实现单词顺序的反转，同时确保处理了额外的空格。反转后的字符串中不能存在前导空格和尾随空格。

因此，可以对二叉树进行前序遍历，获得各节点被访问到的顺序。由于将二叉树展开为链表之后会破坏二叉树的结构，因此在前序遍历结束之后更新每个节点的左右子节点的信息，将二叉树展开为单链表。由于是先序访问，所以节点的顺序是没有问题的。算法使用迭代的方式，通过一个循环遍历二叉树的每个节点。先展开右子树，再展开左子树，最后处理当前节点。移动指针到下一个节点，继续上述过程，直到所有节点都被处理。指针为当前节点，以便在下一次递归回溯时正确连接右子树。，直接返回，因为空树已经是展开的形式。方法接收一个二叉树的根节点。

取出队列中队头的值，然后遍历出它的所有子节点，然后装入队列，之后一直到这一层的结束为止。然后将所有的值装入集合，集合装入大集合。