dm菜鸟编程-CSDN博客

原创 LeetCode-找出字符串中第一个匹配项的下标（028）

长度为 m，则时间复杂度为 O((n−m)×m)，空间复杂度 O(1)。字符串的第一个匹配项的下标（下标从 0 开始）。进行比较，若发现能够匹配的索引，直接返回即可。的每一个字符为起点与字符串。

2025-01-10 08:36:09 413

原创 LeetCode-移除元素（027）

遍历数组 nums，如果当前元素 x 不等于 val，则将 x 赋值给 nums[k]，并将 k 自增 1。时间复杂度 O(n)，空间复杂度 O(1)。其中 n 为数组 nums 的长度。我们用变量 k 记录当前不等于 val 的元素个数。元素的顺序可能发生改变。如果所有的断言都通过，你的解决方案将会。最后返回 k 即可。

2025-01-10 08:32:09 357

然后我们从左到右遍历数组，对于遍历到的每个元素 x，如果 k=0 或者 x≠nums[k−1]，我们就将 x 放到 nums[k] 的位置，然后 k 自增 1。否则，$x$ 与 nums[k−1] 相同，我们直接跳过这个元素。这样，当遍历结束时，$nums$ 中前 k 个元素就是我们要求的答案，且 k 就是答案的长度。原问题要求最多相同的数字最多出现 1 次，我们可以扩展至相同的数字最多保留 k 个。我们用一个变量 k 记录当前已经处理好的数组的长度，初始时 k=0，表示空数组。，返回删除后数组的新长度。

2025-01-09 11:16:48 475

原创 LeetCode-K 个一组翻转链表（025）

二.示例输入：head = [1,2,3,4,5], k = 2输出：[2,1,4,3,5]输入：head = [1,2,3,4,5], k = 3输出：[3,2,1,4,5]链表中的节点数目为n。

2025-01-09 11:11:58 523

原创 LeetCode-两两交换链表中的节点（024）

否则，我们递归交换链表 head.next.next，记交换后的头节点为 t，然后我们记 head 的下一个节点为 p，然后令 p 指向 head，而 head 指向 t，最后返回 p。给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。递归的终止条件是链表中没有节点，或者链表中只有一个节点，此时无法进行交换，直接返回该节点。时间复杂度 O(n)，空间复杂度 O(n)，其中 n 是链表的长度。

2025-01-07 08:32:46 328

原创 LeetCode-合并 K 个升序链表（023）

我们可以创建一个小根堆来 pq 维护所有链表的头节点，每次从小根堆中取出值最小的节点，添加到结果链表的末尾，然后将该节点的下一个节点加入堆中，重复上述步骤直到堆为空。时间复杂度 O(n×log⁡k)，空间复杂度 O(k)。其中 n 是所有链表节点数目的总和，而 k 是题目给定的链表数目。请你将所有链表合并到一个升序链表中，返回合并后的链表。给你一个链表数组，每个链表都已经按升序排列。

2025-01-07 08:28:50 412

原创 LeetCode-括号生成（022）

我们设计一个函数 dfs(l,r,t)，其中 l 和 r 分别表示左括号和右括号的数量，而 t 表示当前的括号序列。题目中 n 的范围为 [1,8]，因此我们直接通过“暴力搜索 + 剪枝”的方式通过本题。代表生成括号的对数，请你设计一个函数，用于能够生成所有可能的并且。时间复杂度 O(2n×2×n)，空间复杂度 O(n)。

2025-01-06 08:35:35 312

原创 LeetCode-合并两个有序链表（021）

我们先判断链表 l1 和 l2 是否为空，若其中一个为空，则返回另一个链表。时间复杂度 O(m+n)，空间复杂度 O(m+n)。其中 m 和 n 分别为两个链表的长度。新链表是通过拼接给定的两个链表的所有节点组成的。将两个升序链表合并为一个新的。

2025-01-06 08:30:40 447

原创 LeetCode-有效的括号（020）

遍历括号字符串 s，遇到左括号时，压入当前的左括号；遇到右括号时，弹出栈顶元素（若栈为空，直接返回。也可以选择遇到左括号时，将右括号压入栈中；遇到右括号时，弹出栈顶元素（若栈为空，直接返回。时间复杂度 O(n)，空间复杂度 O(n)。其中 n 为括号字符串 s 的长度。两者的区别仅限于括号转换时机，一个是在入栈时，一个是在出栈时。遍历结束，若栈为空，说明括号字符串有效，返回。），判断是否是相等。），判断是否匹配，若不匹配，直接返回。，判断字符串是否有效。

2025-01-04 20:10:36 689

原创 LeetCode-删除链表的倒数第 N 个结点（019）

时间复杂度 O(n)，其中 n 为链表的长度。空间复杂度 O(1)。个结点的前驱结点，将其删除即可。给你一个链表，删除链表的倒数第。，初始时都指向链表的虚拟头结点。指针先向前移动 n 步，然后。个结点，并且返回链表的头结点。指针到达链表的末尾。指针指向的结点就是倒数第。指针同时向前移动，直到。

2025-01-04 20:06:45 242

原创 LeetCode-四数之和（018）

接下来，我们枚举四元组的前两个元素 nums[i] 和 nums[j]，其中 i

2025-01-03 11:33:15 703

原创 LeetCode-电话号码的字母组合（017）

我们先用一个数组或者哈希表存储每个数字对应的字母，然后遍历每个数字，将其对应的字母与之前的结果进行组合，得到新的结果。时间复杂度 O(4n)。空间复杂度 O(4n)。其中 n 是输入数字的长度。

2025-01-03 11:28:07 262

原创 LeetCode-最接近的三数之和（016）

我们将数组排序，然后遍历数组，对于每个元素 nums[i]，我们使用指针 j 和 k 分别指向 i+1 和 n−1，计算三数之和，如果三数之和等于 target，则直接返回 target，否则根据与 target 的差值更新答案。如果三数之和大于 target，则将 k 向左移动一位，否则将 j 向右移动一位。时间复杂度 O(n2)，空间复杂度 O(log⁡n)。其中 n 为数组长度。

2025-01-02 11:59:00 386

原创 LeetCode-三数之和（015）

接下来，我们枚举三元组的第一个元素 nums[i]，其中 0≤i0 并且 nums[i]=nums[i−1]，则说明当前枚举的元素与上一个元素相同，我们可以直接跳过，因为不会产生新的结果。如果 nums[i]>0，则说明当前枚举的元素大于 0，则三数之和必然无法等于 0，结束枚举。枚举结束后，我们即可得到三元组的答案。

2025-01-02 11:55:20 734

原创 LeetCode-最长公共前缀（014）

我们以第一个字符串 strs[0] 为基准，依次比较后面的字符串的第 i 个字符是否与 strs[0] 的第 i 个字符相同，如果相同则继续比较下一个字符，否则返回 strs[0] 的前 i 个字符。时间复杂度 (n×m)，其中 n 和 m 分别为字符串数组的长度以及字符串的最小长度。空间复杂度 O(1)。遍历结束，说明所有字符串的前 i 个字符都相同，返回 strs[0] 即可。编写一个函数来查找字符串数组中的最长公共前缀。如果不存在公共前缀，返回空字符串。

2025-01-01 10:22:37 572

原创 LeetCode-罗马数字转整数（013）

我们先用哈希表 d 记录每个字符对应的数值，然后从左到右遍历字符串 s，如果当前字符对应的数值小于右边字符对应的数值，则减去当前字符对应的数值，否则加上当前字符对应的数值。数字 1 在数字 5 的左边，所表示的数等于大数 5 减小数 1 得到的数值 4。时间复杂度 (n)，空间复杂度 O(m)。其中 n 和 m 分别为字符串 s 的长度和字符集的大小。通常情况下，罗马数字中小的数字在大的数字的右边。但也存在特例，例如 4 不写做。给定一个罗马数字，将其转换成整数。，即为两个并列的 1。

2025-01-01 10:17:50 631

原创 LeetCode-整数转罗马数字（012）

我们可以先将所有可能的符号 cs 和对应的数值 vs 列出来，然后从大到小枚举每个数值 vs[i]，每次尽可能多地使用该数值对应的符号 cs[i]，直到数字 num 变为 0。罗马数字是通过添加从最高到最低的小数位值的转换而形成的。时间复杂度为 O(m)，空间复杂度为 O(m)。其中 m 为符号的个数。给定一个整数，将其转换为罗马数字。

2024-12-31 11:42:26 406

原创 LeetCode-盛最多水的容器（011）

然后，我们开始进行循环，每次循环中，我们计算当前容器的容量，即 min(height[l],height[r])×(r−l)，并将其与 ans 进行比较，将较大值赋给 ans。然后，我们判断 height[l] 和 height[r] 的大小，如果 height[l]

2024-12-31 11:36:52 334

原创 LeetCode-正则表达式匹配（010）

我们设计一个函数 dfs(i,j)，表示从 s 的第 i 个字符开始，和 p 的第 j 个字符开始是否匹配。那么答案就是 dfs(0,0)。时间复杂度 O(m×n)，空间复杂度 O(m×n)。其中 m 和 n 分别是 s 和 p 的长度。过程中，我们可以使用记忆化搜索，避免重复计算。的，而不是部分字符串。，请你来实现一个支持。

2024-12-30 09:42:33 552

原创 LeetCode-回文数（009）

对于数字 1221，如果执行 1221mod10，我们将得到最后一位数字 1，要得到倒数第二位数字，我们可以先通过除以 10 将最后一位数字从 1221 中移除，$1221 / 10 = 122$，再求出上一步结果除以 10 的余数，$122 \bmod 10 = 2$，就可以得到倒数第二位数字。在代码实现上，我们可以反复“取出” x 的最后一位数字，并将其“添加”到 y 的后面，循环直到 y≥x，如果此时 x=y，或者 x=y/10，那么 x 就是回文数。如果继续这个过程，我们将得到更多位数的反转数字。

2024-12-30 09:37:57 280

原创 LeetCode-字符串转换整数（008）

接着遍历后面的字符，如果是数字，我们判断添加该数字是否会导致整数溢出，如果会，我们根据正负号返回结果。否则我们将数字添加到结果中。继续遍历后面的字符，直到遇到非数字字符或者遍历结束。时间复杂度 O(n)，其中 n 为字符串的长度。我们只需要依次处理所有字符。否则，我们需要遍历字符串，跳过前导空格，判断第一个非空格字符是否为正负号。加粗的字符串为已经读入的字符，插入符号是当前读取的字符。我们首先判断字符串是否为空，如果是，直接返回 0。读取在第一个非数字字符“w”处停止。遍历结束后，我们根据正负号返回结果。

2024-12-28 11:25:45 659

原创 LeetCode-整数反转（007）

因此，我们可以通过判断 ans 是否在 [⌊mi10⌋,⌊mx10⌋] 的范围内来判断 ans 是否溢出。否则，将 y 添加到 ans 的末尾，然后将 x 的最后一位数字去除，即 x←⌊x10⌋。我们可以通过不断地对 x 取余来获取 x 的最后一位数字 y，并将 y 添加到 ans 的末尾。若 x>0，那么需要满足 ans×10+y≤mx，即 ans×10+y≤⌊mx10⌋×10+7。我们不妨记 mi 和 mx 分别为 −231 和 231−1，则 x 的反转结果 ans 需要满足 mi≤ans≤mx。

2024-12-28 11:18:01 879

原创 LeetCode-Z 字形变换（006）

我们从左到右遍历字符串 s，每次遍历到一个字符 c，将其追加到 g[i] 中，如果此时 i=0 或者 i=numRows−1，说明当前字符位于 Z 字形排列的拐点，我们将 k 的值反转，即 k=−k。继续遍历下一个字符，直到遍历完字符串 s，我们返回 g 中所有行拼接后的字符串即可。我们用一个二维数组 g 来模拟 Z 字形排列的过程，其中 g[i][j] 表示第 i 行第 j 列的字符。初始时 i=0，另外我们定义一个方向变量 k，初始时 k=−1，表示向上走。其中 n 为字符串 s 的长度。

2024-12-27 09:11:52 277

原创 LeetCode-最长回文子串（005）

考虑 f[i][j]，如果 s[i]=s[j]，那么 f[i][j]=f[i+1][j−1]；否则 f[i][j]=false。如果 f[i][j]=true 并且 mx

2024-12-27 09:06:03 719

原创 LeetCode-寻找两个正序数组的中位数（004）

如果 m+n 是偶数，那么中位数就是第 ⌊m+n+12⌋ 和第 ⌊m+n+22⌋ 个数的平均数。实际上，我们可以统一为求第 ⌊m+n+12⌋ 个数和第 ⌊m+n+22⌋ 个数的平均数。因此，我们可以设计一个函数 f(i,j,k)，表示在数组 nums1 的区间 [i,m) 和数组 nums2 的区间 [j,n) 中，求第 k 小的数。那么中位数就是 f(0,0,⌊m+n+12⌋) 和 f(0,0,⌊m+n+22⌋) 的平均数。时间复杂度 O(log⁡(m+n))，空间复杂度 O(log⁡(m+n))。

2024-12-26 09:21:30 371

原创 LeetCode-无重复字符的最长子串（003）

的每个字符 s[j]，我们记为 c。若 s[i..j−1] 窗口内存在 c，则 i 循环向右移动，更新哈希表，直至 s[i..j−1] 窗口不存在。定义一个哈希表记录当前窗口内出现的字符，记 i 和 j 分别表示不重复子串的开始位置和结束位置，无重复字符子串的最大长度记为。加入哈希表中，此时 s[i..j] 窗口内不含重复元素，更新。时间复杂度 O(n)，其中 n 表示字符串。，请你找出其中不含有重复字符的。

2024-12-26 09:14:15 303

原创 LeetCode-两数相加（002）

时间复杂度 O(max(m,n))，其中 m 和 n 分别为两个链表的长度。我们需要遍历两个链表的全部位置，而处理每个位置只需要 O(1) 的时间。忽略答案的空间消耗，空间复杂度 O(1)。每次遍历时，我们取出对应链表的当前位，计算它们与进位 carry 的和，然后更新进位的值，最后将当前位的值加入答案链表。如果两个链表都遍历完了，并且进位为 0 时，遍历结束。我们同时遍历两个链表 l1 和 l2，并使用变量 carry 表示当前是否有进位。最后我们返回答案链表的头节点即可。

2024-12-25 15:56:25 515

原创 LeetCode-两数之和（001）

遍历数组 nums，对于当前元素 nums[i]，我们首先判断 target−nums[i] 是否在哈希表 d 中，如果在 d 中，说明 target 值已经找到，返回 target−nums[i] 的索引和 i 即可。时间复杂度 O(n)，空间复杂度 O(n)，其中 n 为数组 nums 的长度。我们可以使用一个哈希表 d 来存储每个元素及其对应的索引。

2024-12-25 15:48:28 496

原创 Java中常用算法之桶排序算法

/ 创建桶i < n;i++) {// 将元素分配到桶中// 对每个桶进行排序// 合并所有桶中的数据桶排序是一种高效的分布式排序算法，适用于均匀分布的数据。它的时间复杂度为O(n + k)，在元素均匀分布时非常高效。然而，当数据分布不均匀时，某些桶可能会包含过多的元素，导致效率下降。桶排序的稳定性使其适合于需要保持相同元素相对顺序的场合。

2024-12-19 09:42:06 322

原创 Java中常用算法之计数排序算法

计数排序是一种高效的非比较排序算法，适用于元素为非负整数且范围不大的数组。它的时间复杂度为O(n + k)，在元素范围较小时非常高效。然而，当元素范围较大时，计数排序的空间复杂度会增加，可能不如其他排序算法（如快速排序）高效。计数排序的稳定性使其适合于需要保持相同元素相对顺序的场合。

2024-12-19 09:41:47 376

原创 Java中常用算法之堆排序算法

堆排序是一种高效的排序算法，适合于大规模数据集的排序。它的时间复杂度为O(n log n)，并且具有良好的空间效率。然而，堆排序是不稳定的排序算法，且在某些情况下（如数据接近有序时）性能可能不如其他排序算法（如快速排序）。

2024-12-18 19:37:51 425

原创 Java中常用算法之快速排序算法

快速排序是一种高效的排序算法，适合于大规模数据集的排序。它的平均时间复杂度为O(n log n)，但在最坏情况下为O(n²)。快速排序的不稳定性和最坏情况下的时间复杂度是其主要缺点。通过选择合适的基准（如随机选择）可以在一定程度上避免最坏情况。

2024-12-18 19:37:28 553

原创 Java中常用算法之归并排序算法

归并排序是一种高效的排序算法，适合于大规模数据集的排序。它的时间复杂度为O(n log n)，并且是稳定的排序算法。归并排序的缺点是需要额外的空间来存储临时数组。

2024-12-17 10:49:29 416

原创 Java中常用算法之插入排序算法

插入排序的时间复杂度为O(n²)，因为在最坏情况下需要进行n²次比较和移动。然而，对于小规模数据集或部分有序的数据集，插入排序可能比其他O(n²)排序算法（如选择排序、冒泡排序）更有效。插入排序的优点是它的实现简单，并且在排序过程中可以保持相同元素的相对顺序（稳定性）。

2024-12-17 10:48:54 536

原创 Java中常用算法之冒泡排序算法

冒泡排序的时间复杂度为O(n²)，因为在最坏情况下需要进行n²次比较和交换。虽然冒泡排序不是最有效的排序算法，但它的实现简单，适合用于教学和理解基本的排序概念。通过优化，可以在某些情况下减少不必要的比较和交换。

2024-12-16 17:53:53 660

原创 Java中常用算法之选择排序算法

选择排序的时间复杂度为O(n²)，因为在最坏情况下需要进行n²次比较。选择排序的优点是它的实现简单，并且在某些情况下（如内存写入次数较少时）可能比其他O(n²)排序算法更有效。然而，它的效率不如更复杂的排序算法（如快速排序、归并排序）高。选择排序适合用于小规模数据集或对稳定性要求不高的场合。

2024-12-16 17:53:27 416

原创 Kotlin设计模式之访问者模式

访问者接口定义了访问不同元素的方法。元素接口定义了接受访问者的方法。具体元素类实现了元素接口，并在接受访问者时调用访问者的方法。具体访问者实现了访问者接口，并在访问元素时执行具体操作。访问者模式的核心在于将作用于某种数据结构中的各元素的操作分离出来，使得可以在不改变数据结构的前提下定义作用于这些元素的新操作。通过这种方式，可以在不修改元素类的情况下，添加新的操作。根据具体需求，可以扩展访问者和元素类以支持更多的操作和元素类型。

2024-12-14 09:28:38 404 1

原创 Kotlin设计模式之模板方法模式

抽象类定义了模板方法和基本操作。模板方法定义了算法的骨架，而基本操作由子类实现。// 模板方法// 基本操作，由子类实现具体类实现了抽象类中的基本操作。3. 使用示例// Usage// Output:// Output:模板方法模式的核心在于定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。通过这种方式，可以在不改变算法结构的情况下，重新定义算法中的某些步骤。根据具体需求，可以扩展具体类以支持更多的操作实现。

2024-12-14 09:28:20 339

原创 Kotlin设计模式之策略模式

策略接口定义了一个方法，所有具体策略类都需要实现这个接口。具体策略类实现了策略接口，并在方法中执行具体操作。上下文类维护一个策略实例，并在请求时委托给当前策略处理。4. 使用示例// Usage策略模式的核心在于定义一系列算法，将每个算法封装起来，并使它们可以相互替换。通过这种方式，可以将算法的实现与使用它的客户端分离开来。根据具体需求，可以扩展策略类以支持更多的算法。

2024-12-13 16:41:27 630

原创 Kotlin设计模式之状态模式

状态接口定义了一个方法，所有具体状态类都需要实现这个接口。具体状态类实现了状态接口，并在方法中执行具体操作。上下文类维护一个状态实例，并在请求时委托给当前状态处理。状态模式的核心在于允许对象在内部状态改变时改变其行为。通过这种方式，可以将状态相关的行为局部化到特定的状态类中，并通过上下文类来管理状态的切换。根据具体需求，可以扩展状态类以支持更多的状态和行为。

2024-12-13 16:41:08 410