- 博客(88)
- 收藏
- 关注
RSS订阅原创 python 八大排序算法
选择排序是一种简单直观的排序算法，其工作原理是在未排序序列中找到最小（或最大）的元素，存放到排序序列的起始位置，然后继续寻找剩余未排序序列中的最小（或最大）元素，放到已排序序列的末尾，直至所有元素排序完毕。插入排序是一种简单直观的排序算法，其工作原理是把第一个元素看做已排序的圆度，然后将未排序的元素插入到已排序的部分中的合适位置，直到所有元素排好序。基数排序的基本思想是先将数字按照个位数上数字的大小进行排序，排序之后再将已经排过序的数字再按照十位数上数字的大小进行排序，依次类推。
2024-03-19 13:27:56
308
原创 Leetcode 24. 两两交换链表中的节点
给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。即让0号节点指向2，2号节点执行1，1号节点指向2。3、下一轮循环，让1成为0号节点，3成为1号节点。时间复杂度：O(n)，其中 n为链表长度。空间复杂度：O(1)。仅用到若干额外变量。输入：head = [1,2,3,4]1、创建1个节点0号节点，指向头结点。输入：head = [1]输出：[2,1,4,3]输入：head = []2、链表执行下面的交换。
2024-03-18 16:08:16
347
原创 Leetcode 19. 删除链表的倒数第 N 个结点
1、定义两个指针，右指针先走n步，然后左右指针一起走，可以发现左右指针之间的距离一直是n，就可以找到第n+1个指针。2、删除第n个节点，需要找到倒数第n+1个节点，然后让上一个指针的节点指向倒数第n+1个节点，即。给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。输入：head = [1,2,3,4,5], n = 2。输入：head = [1,2], n = 1。输入：head = [1], n = 1。输出：[1,2,3,5]**思路：**双指针。
2024-03-18 15:37:36
168
原创 Leetcode 75. 颜色分类
给定一个包含红色、白色和蓝色、共 n 个元素的数组 nums ，原地对它们进行排序，使得相同颜色的元素相邻，并按照红色、白色、蓝色顺序排列。我们使用整数 0、 1 和 2 分别表示红色、白色和蓝色。一开始在列表加了一个3，遇到3代表可以停止了，后面都是2。输入：nums = [2,0,2,1,1,0]遇到2删掉，放最右边，指针不加，因为删了一位。输入：nums = [2,0,1]输出：[0,0,1,1,2,2]遇到0删掉放最左边，指针+1。遇到1不操作，指针+1。输出：[0,1,2]
2024-03-15 14:06:27
242
原创 Leetcode 287. 寻找重复数
给定一个包含 n + 1 个整数的数组 nums ，其数字都在 [1, n] 范围内（包括 1 和 n），可知至少存在一个重复的整数。时间复杂度 O(N) ： 遍历数组使用 O(N)，HashSet 添加与查找元素皆为 O(1)。你设计的解决方案必须 不修改 数组 nums 且只用常量级 O(1) 的额外空间。空间复杂度 O(N) ： HashSet 占用 O(N)大小的额外空间。输入：nums = [1,3,4,2,2]输入：nums = [3,1,3,4,2]输入：nums = [3,3,3,3,3]
2024-03-15 11:30:46
278
原创 Leetcode 169. 多数元素
基本思想为：假设一个数为众数x（一个列表中出现次数最多的数），之后遍历该列表，列表中的数num=x时，votes+1,否则votes-1，两两消除，最后剩下的那个数为出现超过半数的数。给定一个大小为 n 的数组 nums ，返回其中的多数元素。当 num = x 时，票数 votes 自增 1；1、初始化： 票数统计 votes = 0 ， 众数 x。2、循环： 遍历数组 nums 中的每个数字 num。输入：nums = [2,2,1,1,1,2,2]输入：nums = [3,2,3]
2024-03-13 14:41:30
229
原创 Leetcode 136. 只出现一次的数字
给你一个 非空 整数数组 nums ，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。你必须设计并实现线性时间复杂度的算法来解决此问题，且该算法只使用常量额外空间。题目要求时间复杂度 O(N)，空间复杂度 O(1)输入：nums = [4,1,2,1,2]输入：nums = [2,2,1]输入：nums = [1]
2024-03-13 13:58:33
242
原创 Leetcode 118. 杨辉三角
题目描述：给定一个非负整数 numRows，生成「杨辉三角」的前 numRows 行。在「杨辉三角」中，每个数是它左上方和右上方的数的和。示例 1:输入: numRows = 5输出: [[1],[1,1],[1,2,1],[1,3,3,1],[1,4,6,4,1]]示例 2:输入: numRows = 1输出: [[1]]思路可以发现：从第三行开始：除了第一列，每个位置=上一行右上角位置+上一行上面位置dp[i][j] = dp[i-1][j-1] + dp[i-1][j]解题
2024-03-13 11:40:46
207
原创 Leetcode 70. 爬楼梯
由于 f[i] 只与 f[i−1] 和 f[i−2] 有关，因此我们可以只用两个变量 a 和 b 来维护当前的方法数，空间复杂度降低为 O(1)。初始条件为 f[0]=1，f[1]=1，即爬到第 0 阶楼梯的方法数为 1，爬到第 1 阶楼梯的方法数也为 1。每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？1、1 阶 + 1 阶 + 1 阶。解释：有两种方法可以爬到楼顶。解释：有三种方法可以爬到楼顶。1、1 阶 + 1 阶。2、1 阶 + 2 阶。3、2 阶 + 1 阶。
2024-03-13 10:51:25
233
原创 Leetcode 121. 买卖股票的最佳时机
解释：在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5。你只能选择 某一天 买入这只股票，并选择在 未来的某一个不同的日子 卖出该股票。给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格；解释：在这种情况下, 没有交易完成, 所以最大利润为 0。输入：prices = [7,6,4,3,1]输入：[7,1,5,3,6,4]
2024-03-13 10:32:15
249
原创 Leetcode 20. 有效的括号
字符串 s 以左括号结尾： 此情况下可以正常遍历完整个 s，但 stack 中遗留未出栈的左括号；栈先入后出特点恰好与本题括号排序特点一致，即若遇到左括号入栈，遇到右括号时将对应栈顶左括号出栈，则遍历完所有括号后 stack 仍然为空；否则通过哈希表判断括号对应关系，若 stack 栈顶出栈括号 stack.pop() 与当前遍历括号 i 不对应，则提前返回 false。给定一个只包括 ‘(’，‘)’，‘{’，‘}’，‘[’，‘]’ 的字符串 s ，判断字符串是否有效。左括号必须用相同类型的右括号闭合。
2024-03-12 22:54:41
353
原创 Leetcode 35. 搜索插入位置
bisect_right(bisect): 在L中查找x，x存在时返回x右侧的位置，x不存在返回应该插入的位置。bisect_left: 在L中查找x，x存在时返回x左侧的位置，x不存在返回应该插入的位置。insort_right(insort): 将x插入到列表L中，x存在时插入在右侧。输入: nums = [1,3,5,6], target = 5。输入: nums = [1,3,5,6], target = 2。insort_left: 将x插入到列表L中，x存在时插入在左侧。
2024-03-12 22:27:25
312
原创 Leetcode 108. 将有序数组转换为二叉搜索树
二叉搜索树满足两个条件：1）根比左子树大比右子树小；因此直接获取有序数组中值作为根就可以，递归生成左子树和右子树即可。给你一个整数数组 nums ，其中元素已经按 升序 排列，请你将其转换为一棵。解释：[1,null,3] 和 [3,1] 都是高度平衡二叉搜索树。输入：nums = [-10,-3,0,5,9]输出：[0,-3,9,-10,null,5]输入：nums = [1,3]
2024-03-12 15:46:12
181
原创 Leetcode 543. 二叉树的直径
先递归调用左儿子和右儿子求得它们为根的子树的深度 L 和 R ，则该节点为根的子树的深度即为max(L,R)+1，该节点的node值为L+R+1。对于该节点的左儿子向下遍历经过最多的节点数 L （即以左儿子为根的子树的深度） 和其右儿子向下遍历经过最多的节点数 R （即以右儿子为根的子树的深度），那么以该节点为起点的路径经过节点数的最大值即为 L+R+1。解释：3 ，取路径 [4,2,1,3] 或 [5,2,1,3] 的长度。输入：root = [1,2,3,4,5]输入：root = [1,2]
2024-03-12 15:19:59
335
原创 Leetcode 101. 对称二叉树
递推工作： 判断两节点 L.left 和 R.right 是否对称，即 recur(L.left, R.right)。判断两节点 L.right 和 R.left 是否对称，即recur(L.right, R.left)。终止条件： 当 L 和 R 同时越过叶节点： 此树从顶至底的节点都对称，因此返回 true。当 L 或 R中只有一个越过叶节点： 此树不对称，因此返回 false。输入：root = [1,2,2,null,3,null,3]输入：root = [1,2,2,3,4,4,3]
2024-03-12 14:38:12
210
原创 Leetcode 226. 翻转二叉树
执行完毕后， root.leftroot.leftroot.left 的值已经发生改变，此时递归左子节点 invertTree(root.left)invertTree(root.left)invertTree(root.left) 则会出问题。开启递归 右子节点 invertTree(root.right)invertTree(root.right)invertTree(root.right) ，并将返回值作为 rootrootroot 的 左子节点。输出：[4,7,2,9,6,3,1]
2024-03-12 11:43:55
329
原创 Leetcode 104. 二叉树的最大深度
3、返回值： 返回 此树的深度 ，即 max(maxDepth(root.left), maxDepth(root.right)) + 1。显然，此树的深度 等于 左子树的深度 与 右子树的深度中的 最大值 +1。时间复杂度 O(N) ： N 为树的节点数量，计算树的深度需要遍历所有节点。时间复杂度 O(N)： N为树的节点数量，计算树的深度需要遍历所有节点。每遍历一层，则计数器 +1+1+1 ，直到遍历完成，则可得到树的深度。二叉树的 最大深度 是指从根节点到最远叶子节点的最长路径上的节点数。
2024-03-11 22:00:24
389
原创 Leetcode 145. 二叉树的后序遍历
第二种解法：深度优先搜索（遍历一个节点，会把当前子节点的子节点遍历完成，直到不含有子节点，会去遍历上一层的节点）空间复杂度：空间复杂度：O(h)，h为树的高度。最坏情况下需要空间O(n)，平均情况为O(logn)题目描述：给定一个二叉树的根节点 root ，返回 它的 后序 遍历。时间复杂度：O(n)，n为节点数，访问每个节点恰好一次。输入：root = [1,null,2,3]输入：root = [1]输入：root = []输出：[1,3,2]
2024-03-11 21:30:06
239
原创 Leetcode 144. 二叉树的前序遍历
第二种解法：深度优先搜索（遍历一个节点，会把当前子节点的子节点遍历完成，直到不含有子节点，会去遍历上一层的节点）空间复杂度：空间复杂度：O(h)，h为树的高度。最坏情况下需要空间O(n)，平均情况为O(logn)题目描述：给定一个二叉树的根节点 root ，返回 它的 前序 遍历。时间复杂度：O(n)，n为节点数，访问每个节点恰好一次。输入：root = [1,null,2,3]输入：root = [1]输入：root = []输出：[1,3,2]
2024-03-11 21:24:22
182
原创 Leetcode 94. 二叉树的中序遍历
第二种解法：深度优先搜索（遍历一个节点，会把当前子节点的子节点遍历完成，直到不含有子节点，会去遍历上一层的节点）空间复杂度：空间复杂度：O(h)，h为树的高度。最坏情况下需要空间O(n)，平均情况为O(logn)题目描述：给定一个二叉树的根节点 root ，返回 它的 中序 遍历。时间复杂度：O(n)，n为节点数，访问每个节点恰好一次。输入：root = [1,null,2,3]输入：root = [1]输入：root = []输出：[1,3,2]
2024-03-11 21:18:22
242
原创 Leetcode 21. 合并两个有序链表
如何递归：我们判断 l1 和 l2 头结点哪个更小，然后较小结点的 next 指针指向其余结点的合并结果。将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。输入：l1 = [1,2,4], l2 = [1,3,4]终止条件：当两个链表都为空时，表示我们对链表已合并完成。输入：l1 = [], l2 = [0]两个链表的节点数目范围是 [0, 50]输入：l1 = [], l2 = []l1 和 l2 均按 非递减顺序 排列。输出：[1,1,2,3,4,4]
2024-03-11 20:36:59
246
原创 Leetcode 142. 环形链表 II
为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。设链表共有 a+b 个节点，其中 链表头部到链表入口 有 a 个节点（不计链表入口节点）， 链表环 有 b 个节点（这里需要注意，a和 b 是未知数，例如图解上链表 a=4, b=5）；当 fast 指针走到 f=a步时，slow 指针走到 s=a+nb 步。因为每走 1 轮，fast 与 slow 的间距+1，fast 一定会追上 slow。令 fast 每轮走 2 步，slow 每轮走 1步。
2024-03-11 15:02:28
381
原创 Leetcode 141. 环形链表
如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。输入：head = [3,2,0,-4], pos = 1。给你一个链表的头节点 head ，判断链表中是否有环。输入：head = [1,2], pos = 0。解释：链表中有一个环，其尾部连接到第二个节点。解释：链表中有一个环，其尾部连接到第一个节点。输入：head = [1], pos = -1。解释：链表中没有环。
2024-03-11 14:22:09
246
原创 Leetcode 234. 回文链表
结合python的特性，构建反转列表非常简单，即nums[::-1]，可以快速进行原数组与反转数组的比较，若两者相同，便是回文。给你一个单链表的头节点 head ，请你判断该链表是否为回文链表。熟悉 python中的数组实现，即列表list数据结构，其读取时间复杂度为O(1)；由于链表本身为读取带来一定困难，所以我们常常将链表内容复制入数组，再进行后续考虑；列表一般有两种实现，即数组或链表，此处代码中的预定义已明确是采用链表实现。输入：head = [1,2,2,1]输入：head = [1,2]
2024-03-11 11:55:08
298
原创 Leetcode 160. 相交链表
输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,6,1,8,4,5], skipA = 2, skipB = 3。输入：intersectVal = 2, listA = [1,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1。从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,6,1,8,4,5]。在 B 中，相交节点前有 3 个节点。在 B 中，相交节点前有 1 个节点。
2024-03-11 11:19:05
532
原创 Leetcode 240. 搜索二维矩阵 II
输入：matrix = [[1,4,7,11,15],[2,5,8,12,19],[3,6,9,16,22],[10,13,14,17,24],[18,21,23,26,30]], target = 20。输入：matrix = [[1,4,7,11,15],[2,5,8,12,19],[3,6,9,16,22],[10,13,14,17,24],[18,21,23,26,30]], target = 5。当 matrix[i][j] < target 时，执行 j++ ，即消去第 j 列元素。
2024-03-10 18:03:55
479
原创 Leetcode 54. 螺旋矩阵
根据题目示例 matrix = [[1,2,3],[4,5,6],[7,8,9]] 的对应输出 [1,2,3,6,9,8,7,4,5] 可以发现，顺时针打印矩阵的顺序是 “从左向右、从上向下、从右向左、从下向上” 循环。输入：matrix = [[1,2,3,4],[5,6,7,8],[9,10,11,12]]输入：matrix = [[1,2,3],[4,5,6],[7,8,9]]输出：[1,2,3,4,8,12,11,10,9,5,6,7]输出：[1,2,3,6,9,8,7,4,5]
2024-03-10 17:41:02
253
原创 Leetcode 73. 矩阵置零
给定一个 m x n 的矩阵，如果一个元素为0，则将其所在行和列的所有元素都设为 0。输入：matrix = [[0,1,2,0],[3,4,5,2],[1,3,1,5]]但是对于第一行,和第一列要设置一个标志位,为了防止自己这一行(一列)也有0的情况.输入：matrix = [[1,1,1],[1,0,1],[1,1,1]]输出：[[0,0,0,0],[0,4,5,0],[0,3,1,0]]两遍扫matrix,第一遍用集合记录哪些行,哪些列有0;输出：[[1,0,1],[0,0,0],[1,0,1]]
2024-03-09 15:57:54
819
原创 Leetcode 238. 除自身以外数组的乘积
给你一个整数数组 nums，返回 数组 answer ，其中 answer[i] 等于 nums 中除 nums[i] 之外其余各元素的乘积。时间复杂度 O(N)： 其中 N为数组长度，两轮遍历数组 nums ，使用 O(N) 时间。计算 ans[i] 的 上三角 各元素的乘积，记为 tmp ，并乘入 ans[i]。计算 ans[i] 的 下三角 各元素的乘积，直接乘入ans[i]。输入: nums = [-1,1,0,-3,3]输入: nums = [1,2,3,4]输出: [0,0,9,0,0]
2024-03-09 15:23:24
340
原创 Leetcode 189. 轮转数组
输入: nums = [1,2,3,4,5,6,7], k = 3。输入：nums = [-1,-100,3,99], k = 2。向右轮转 1 步: [7,1,2,3,4,5,6]向右轮转 2 步: [6,7,1,2,3,4,5]向右轮转 3 步: [5,6,7,1,2,3,4]向右轮转 1 步: [99,-1,-100,3]向右轮转 2 步: [3,99,-1,-100]输出: [5,6,7,1,2,3,4]输出：[3,99,-1,-100]
2024-03-08 16:12:06
195
原创 Leetcode 56. 合并区间
如果我们每次判断当前区间是否可以合并到当前的合并区间，那么最后一个区间无论是加入到原有的合并区间还是自己作为一个新的区间，最后一个合并区间都没有加入到结果列表中。可以则更新合并区间的终点，不可以这个区间作为新的一个合并区间去合并后面的区间。输入：intervals = [[1,3],[2,6],[8,10],[15,18]]解释：区间 [1,3] 和 [2,6] 重叠, 将它们合并为 [1,6].输入：intervals = [[1,4],[4,5]]输出：[[1,6],[8,10],[15,18]]
2024-03-08 15:49:33
191
原创 Leetcode 53. 最大子数组和
为何定义最大和 dp[i] 中必须包含元素 nums[i] ：保证 dp[i] 递推到 dp[i+1] 的正确性；转移方程： 若 dp[i−1]≤0 ，说明 dp[i−1] 对 dp[i] 产生负贡献，即 dp[i−1]+nums[i]还不如 nums[i] 本身大。初始状态： dp[0]=nums[0]，即以 nums[0]结尾的连续子数组最大和为 nums[0]。输入：nums = [-2,1,-3,4,-1,2,1,-5,4]解释：连续子数组 [4,-1,2,1] 的和最大，为 6。
2024-03-08 14:36:18
278
1
原创 Leetcode 206. 反转链表
考虑使用递归法遍历链表，当越过尾节点后终止递归，在回溯时修改各节点的 next 引用指向。空间复杂度 O(N)： 遍历链表的递归深度达到 N ，系统使用 O(N)大小额外空间。终止条件：当 cur 为空，则返回尾节点 pre （即反转链表的头节点）；给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。时间复杂度 O(N) ： 遍历链表使用线性大小时间。时间复杂度 O(N) ： 遍历链表使用线性大小时间。输入：head = [1,2,3,4,5]输出：[5,4,3,2,1]
2024-03-06 17:49:09
354
原创 Leetcode 239：滑动窗口最大值
想象一下，如果要进来的是个值大的元素，那一定会比之前早进去的值小的元素晚离开队列，而且值大的元素在，都没值小的元素啥事，所以值小的元素直接弹出队列即可。首先窗口向右滑动的过程就是将窗口最左侧的元素删除，同时在窗口的最右侧添加一个新的元素，这就要用到双端队列，然后找双端队列中的最大元素。，所有队列里的元素都是按递增（递减）的顺序队列，这个队列的头是最小（最大）的元素。输入：nums = [1,3,-1,-3,5,3,6,7], k = 3。输出：[3,3,5,5,6,7]返回滑动窗口的最大值。
2024-03-06 17:07:06
398
原创 Leetcode 560. 和为 K 的子数组
枚举前缀和数组，当枚举到sums[j]时，假设有键值对sums[j]−k:v,可知存在v个值满足要求，把v加入最终答案即可，并将sums[i]更新到字典当中。假设nums的前缀和数组为sums，问题转化为：求使得sums[j]−sums[i]=k的下标对(i,j)个数，其中i<j。给你一个整数数组 nums 和一个整数 k ，请你统计并返回 该数组中和为 k 的子数组的个数。输入：nums = [1,1,1], k = 2。输入：nums = [1,2,3], k = 3。
2024-03-05 14:38:54
229
原创 Leetcode 3. 无重复字符的最长子串
请注意，你的答案必须是 子串 的长度，“pwke” 是一个子序列，不是子串。给定一个字符串 s ，请你找出其中不含有重复字符的最长子串的长度。解释: 因为无重复字符的最长子串是 “abc”，所以其长度为 3。解释: 因为无重复字符的最长子串是 “wke”，所以其长度为 3。解释: 因为无重复字符的最长子串是 “b”，所以其长度为 1。输入: s = “abcabcbb”输入: s = “pwwkew”输入: s = “bbbbb”
2024-03-05 11:58:42
228
原创 Leetcode 11. 盛最多水的容器
设两指针 i , j，指向的水槽板高度分别为 h[i] , h[j]，此状态下水槽面积为 S(i,j)。解释：图中垂直线代表输入数组 [1,8,6,2,5,4,8,3,7]。若向内 移动短板 ，水槽的短板 min(h[i],h[j]) 可能变大，因此下个水槽的面积 可能增大。若向内 移动长板 ，水槽的短板 min(h[i],h[j])不变或变小，因此下个水槽的面积 一定变小。空间复杂度 O(1)： 变量 i , j, res 使用常数额外空间。输入：[1,8,6,2,5,4,8,3,7]
2024-03-01 11:51:46
275
原创 Leetcode 128. 最长连续序列
答案是当前数num的后一个数nunm + 1不存在于数组中，因此我们需要能够快速判断当前数num的后一个数num + 1是否存在于数组中。对于数组中存在的连续序列，为了统计每个连续序列的长度，我们希望直接定位到每个连续序列的起点，从起点开始遍历每个连续序列，从而获得长度。答案是这个数的前一个数不存在于数组中，因为我们需要能够快速判断当前数num的前一个数num - 1是否存在于数组中。输入：nums = [0,3,7,2,5,8,4,6,0,1]输入：nums = [100,4,200,1,3,2]
2024-03-01 11:05:44
254
原创 Leetcode 283.移动零
if nums[i]：判断nums[i]是否不为0，if里面是当前不为0的时候，需要将数值与nums[j]交换(j为指向数值为0的指针)，这样循环直到i=len((nums))-1的情况走完。给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。请注意 ，必须在不复制数组的情况下原地对数组进行操作。输入: nums = [0,1,0,3,12]输出: [1,3,12,0,0]输入: nums = [0]思路：双指针同时移动。
2024-02-29 22:15:35
253
1
原创 leetcode 49. 字母异位词分组
因此，空间复杂度为 O(n * k)，其中 n 是字符串列表 strs 中单词的总数，k 是单词中的字符数（最长单词的字符数）。这个算法的时间复杂度是 O(n * k * log k)，其中 n 是字符串列表 strs 中单词的总数，k 是单词中的字符数（最长单词的字符数）。排序部分的时间复杂度是 O(k * log k)：对每个单词进行排序需要的时间复杂度是 O(k * log k)，其中 k 是单词中的字符数。遍历部分的时间复杂度是 O(n)：遍历整个字符串列表 strs 的时间复杂度是 O(n)。
2024-02-29 21:48:25
473
空空如也
空空如也
TA创建的收藏夹 TA关注的收藏夹
TA关注的人