- 博客(73)
- 收藏
- 关注
RSS订阅原创 python-leetcode 72.柱形图中的最大矩形
要找到柱状图中的最大矩形面积，可以理解为对于每一个柱子，找到以它的高度为矩形高度的最大宽度，这个宽度由柱子左右两边第一个比它矮的柱子的位置决定。以heights[i]为高度的最大矩形面积为heights[i]*(right-left-1)向右找到第一个比hseights[i]小的柱子的位置right。向左找到第一个比heights[i]小的柱子的位置left。求在该柱状图中，能够勾勒出来的矩形的最大面积。对于柱子i，其高度为height[i]时间复杂度：O(n)空间复杂度：O(n)
2025-05-21 11:09:11
244
原创 python-leetcode 71.每日温度
可以理解为对于数组中的每一个元素，找到下一个比它大的元素的位置，并计算他们的距离，如果不存在这样的元素，则距离为0。弹出栈顶索引j，并设置answer[j]=[i-j]天，下一个更高温度出现在几天后。如果气温在这之后都不会升高，请在该位置用。将当前索引i压入栈中。，表示每天的温度，返回一个数组。answer：初始化为全0的数组。stack:用于存储温度的索引。时间复杂度：O(n)空间复杂度：O(n)
2025-05-21 10:50:16
244
原创 python-leetcode 70.字符串解码
遇到数字时，需要解析出完整的数字，因为数字可能不止一位。遇到 [ 时，开始记录需要重复的字符串。遇到 ] 时，将栈顶的数字和字符串弹出，进行重复操作，并将结果和前面的字符串合并。输入字符串中没有额外的空格，且输入的方括号总是符合格式要求的。如果是 ] 弹出栈顶的字符串和数字，将字符串重复num次并于之前的字符串进行拼接。初始化：存储之前的字符串和数字，字符串正在解析的字符串，以及正在解析的数字。此外，你可以认为原始数据不包含数字，所有的数字只表示重复的次数。给定一个经过编码的字符串，返回它解码后的字符串。
2025-05-21 10:31:46
244
原创 python-leetcode 69.最小栈
2: 每次push时，将元素压入主栈，同时比较当前元素与辅助栈顶元素，将较小者压入辅助栈。设计一个支持push,pop,top,操作，并能在常数时间内检索到最小元素的栈。1：使用两个栈，一个主栈用于存储所有元素，另一个辅助栈用于存储当前元素的最小值。4：getmin,直接返回辅助栈最小的栈顶元素。3:每次pop时，同时从主栈和辅助栈弹出元素。
2025-05-20 17:26:39
203
原创 python-leetcode 68.有效的括号
如果遇到右括号，检查栈顶的元素是否是对应的左括号。如果不是，或者栈为空，即没有对应的左括号，则字符串无效。3：遍历结束后，检查栈是否为空：如果栈为空，说明所有括号都正确闭合，字符串有效。如果栈不为空，说明有未闭合的左括号，字符串无效。有效字符串需满足：左括号必须用相同类型的右括号闭合；左括号必须以正确的顺序闭合，每个右括号都有一个对应相同类型的左括号。栈的特点是后进后出，即最后放入的元素会被最先取出，这与括号的闭合顺序是吻合的。时间复杂度：O(n) n是字符串的长度，每个字符的入栈和出栈操作都是O(1)
2025-05-20 17:04:24
219
原创 python-leetcode 67.寻找两个正序数组中的中位数
比较nums1[new_i]和nums2[new_j],如果nums1[new_i]<=nums2[new_j],说明nums1的前mid个元素可以排除，他们不可能是第k小的元素，因此更新，i和j。偶数长度：如果total是偶数，就返回第total//2和total.//2+1的平均值。如果j到达nums2的末尾，则返回nums1中从i开始的第k个元素。如果i到达nums1的末尾，返回nums2中从j开始的第k个元素。如果k==1,则返回nums[i]和nums[j]中较小的值。空间复杂度：O(1)
2025-05-19 22:37:36
390
原创 python-leetcode 66.寻找旋转排序数组中的最小值
因此可以通过二分查找的方法找出最小值。在二分查找的每一步中，左边界为 low，右边界为 high，区间的中点为 pivot，最小值就在该区间内。如下图所示，这说明 nums[pivot] 是最小值左侧的元素，因此我们可以忽略二分查找区间的左半部分。给定一个元素互不相同的数组nums,它原来是一个升序排列的数组，并按上述情形进行了多次旋转，找出并返回数组中的最小元素。其中横轴表示数组元素的下标，纵轴表示数组元素的值。已知一个长度为n的数组，预先按照升序排列，经由1到n次旋转后，得到输入数组，例如，原数组。
2025-04-08 22:51:23
281
原创 python-Leetcode 65.搜索旋转排序数组
在传递给函数之前，nums在预先未知的某个小标K上进行了旋转，使数组变为[nums[k], nums[k+1], ..., nums[n-1], nums[0], nums[1], ..., nums[k-1]]，小标从0开始计数。如果 [mid, r] 是有序数组，且 target 的大小满足 (nums[mid+1],nums[r]]，则我们应该将搜索范围缩小至 [mid + 1, r]，否则在 [l, mid - 1] 中寻找。这道题中，数组本身不是有序的，进行旋转后只保证了数组的局部是有序的。
2025-04-08 22:10:17
382
原创 python-leetcode 64.在排序数组中查找元素的第一个和最后一个位置
二分查找中，寻找 leftIdx 即为在数组中寻找第一个大于等于 target 的下标，寻找 rightIdx 即为在数组中寻找第一个大于 target 的下标，然后将下标减一。两者的判断条件不同，定义binarySearch(nums, target, lower) 表示在 nums 数组中二分查找 target 的位置，如果 lower 为 true，则查找第一个大于等于 target 的下标，否则查找第一个大于 target 的下标。时间复杂度： O(logn) ，其中 n 为数组的长度。
2025-04-02 22:27:20
433
原创 python-leetcode 63.搜索二维矩阵
由于每行的第一个元素大于前一行的最后一个元素，且每行元素是升序的，所以每行的第一个元素大于前一行的第一个元素，因此矩阵第一列的元素是升序的。对矩阵的第一列元素二分查找，找到最后一个不大于目标值的元素，然后在该元素所在行中二分查找目标是否存在。若将矩阵每一行拼接在上一行的末尾，则会得到一个升序数组，我们可以在该数组上二分找到目标元素。时间复杂度：O(logm+logn)=O(logmn),其中mn分别是矩阵的行数和列数。时间复杂度：O(logm+logn)=O(logmn),其中mn分别是矩阵的行数和列数。
2025-04-02 21:52:19
635
原创 python-leetcode 62.搜索插入位置
问题转化到这个，直接套用二分法即可，即不断用二分法逼近查找第一个大于等于target的下标，ans初始设置为数组长度可以省略边界条件的判断，因为存在一种情况是target大于数组中的所有数，此时需要插入到数组长度的位置。假设题意是在排序数组中寻找是否存在一个目标值，则可以利用二分法在Ologn的时间内找到是否存在目标值，但这题还有个额外条件，即如果不存在数组中的时候需要返回按顺序插入的位置。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。时间复杂度:O(logn)其中n为数组的长度。
2025-04-01 21:05:04
235
原创 python-leetcode 61.N皇后
每次新放置的皇后都不能和已经放置的皇后之间有攻击：即新放置的皇后不能和任何一个已经放置的皇后在同一列以及同一条斜线上，并更新数组中的当前行的皇后列下标。其中，第 4 列为其前两行的第 2 列的皇后往右下移动两步的位置，第 5 列为其前一行的第 4 列的皇后往右下移动一步的位置。其中，第 0 列为其前两行的第 2 列的皇后往左下移动两步的位置，第 3 列为其前一行的第 4 列的皇后往左下移动一步的位置。每次放置皇后时，三个整数的按位或运算的结果即为不能放置皇后的位置，其余位置即为可以放置皇后的位置。
2025-03-31 22:15:04
751
原创 python-leetcode 59.单词搜索
设函数 check(i,j,k) 表示判断以网格的 (i,j) 位置出发，能否搜索到单词 word[k..]，其中 word[k..] 表示字符串 word 从第 k 个字符开始的后缀子串。对每一个位置 (i,j) 都调用函数 check(i,j,0) 进行检查：只要有一处返回 true，就说明网格中能够找到相应的单词，否则说明不能找到。单词必须按照字母顺序，通过相邻的单元格内的字母构成，其中相邻单元格是那些水平相邻或者垂直相邻的单元格，同一个单元格的字母不允许被重复使用。空间复杂度：O(MN)。
2025-03-31 21:02:43
353
原创 python-leetcode 60.分割回文串
给定一个字符串S,请将S分割成一些子串，使每个子串都是回文串，返回S所有可能的分割方案。时间复杂度：O(n2n)，其中 n 为 s 的长度。空间复杂度：O(n)
2025-03-20 21:53:52
337
原创 python-leetcode 58.括号生成
可以只在序列仍然保持有效时才添加 ‘(’ 或 ‘)’，通过跟踪到目前为止放置的左括号和右括号的数目来做到这一点，如果左括号数量不大于 n，我们可以放一个左括号。任何一个括号序列都一定是由 ‘(’ 开头，并且第一个 ‘(’ 一定有一个唯一与之对应的 ‘)’，每一个括号序列可以用 (a)b 来表示，其中 a 与 b 分别是一个合法的括号序列（可以为空）。时间复杂度：O(4*n/n**1/2)，在回溯过程中，每个答案需要 O(n) 的时间复制到答案数组中。时间复杂度：O(4*n/n**1/2)
2025-03-19 22:04:08
353
原创 python-leetcode 57.组合总和
给一个无重复元素的整数数组candidates和一个目标整数target,找出candidates中可以使数字和为目标数target所有不同组合，并以列表形式返回，可以按任意顺序返回这些组合。candidates中的同一个数字可以无限制重复被选取，如果至少一个数字的被选数量不同，则两种组合是不同的。对于给定的输入，保证和为target的不同组合数少于150个。
2025-03-18 22:03:46
195
原创 python-leetcode 56.电话号码的字母组合
首先使用哈希表存储每个数字对应的所有可能的字母，然后进行回溯操作。回溯过程中维护一个字符串，表示已有的字母排列,该字符串初始为空。每次取电话号码的一位数字，从哈希表中获得该数字对应的所有可能的字母，并将其中的一个字母插入到已有的字母排列后面，继续处理电话号码的后一位数字，直到处理完电话号码中的所有数字，即得到一个完整的字母排列。给定一个仅包含数字的2-9的字符串，返回所有它可能表示的字母组合，答案可以按任意顺序返回。给出数字到字母的映射如下（与电话按键相同），注意1不对应任何字母。
2025-03-18 21:15:38
278
原创 python-leetcode 55.子集
我们用 1 表示「在子集中」，0 表示不在子集中，，那么每一个子集可以对应一个长度为 n 的 0/1 序列，第 i 位表示 ai 是否在子集中。│ │ │ └── dfs(3) → 添加 [1, 2, 3]│ │ └── dfs(3) → 添加 [1, 2]│ │ └── dfs(3) → 添加 [1, 3]│ │ └── dfs(3) → 添加 [2, 3]└── dfs(3) → 添加 []
2025-03-17 22:48:30
995
原创 python-leetcode 54.全排列
具体来说，假设已经填到第 first 个位置，那么 nums 数组中 [0,first−1] 是已填过的数的集合，[first,n−1] 是待填的数的集合，尝试用 [first,n−1] 里的数去填第 first 个数，假设待填的数的下标为 i，么填完以后将第 i 个数和第 first 个数交换，即能使得在填第 first+1 个数的时候 nums 数组的 [0,first] 部分为已填过的数，[first+1,n−1] 为待填的数，回溯的时候交换回来即能完成撤销操作。)，其中 n 为序列的长度。
2025-03-17 21:28:36
338
原创 python-leetcode 53.实现Trie(前缀树）
推广到 26 种字母，其实就是一棵 26 叉树，对于 26 叉树的每个节点，可以用哈希表，或者长为 26 的数组来存储子节点。search：例如查找字符串 aab，相当于查找二叉树中是否存在一条移动方向为「左-左-右」的路径，且最后一个节点是终止节点。空间复杂度：O(∣T∣⋅Σ)，其中 ∣T∣ 为所有插入字符串的长度之和，Σ 为字符集的大小，本题 Σ=26。时间复杂度：初始化为 O(1)，其余操作为 O(∣S∣)，其中 ∣S∣ 是每次插入或查询的字符串的长度。从字典树的根开始，插入字符串。
2025-03-14 21:53:36
374
原创 python-leetcode 52.课程表
新建一个数组，课程序号作为索引，先修课程的数目入度作为值，入度为0表示先修课程已经完成，或者没有先修课程，现在可以学习这门课程。先学习C1，则以C1为入度的课程值可以减1，C3和C8的入度值减1，此时C8的值为0，将其加入带学习的对列。开始学习C2，C2学习完后，C3,C5减去1，C3,C5的入度为0，加入待学习的对列。如果某一门课程的出度为0表示为相对高阶的课程，出度不为0表示它一定是其他某些课程的先修课程，由浅入深，优先寻找高阶的课程，引入三个状态，依次寻找高阶课程。请判断是否可能完成所有课程的学习？
2025-03-14 20:47:40
489
原创 python-leetcode 51.腐烂的橘子
为了确认是否所有新鲜橘子都被腐烂，可以记录一个变量 cnt 表示当前网格中的新鲜橘子数，广度优先搜索的时候如果有新鲜橘子被腐烂，则 cnt=cnt−1 ，最后搜索结束时如果 cnt 大于 0 ，说明有新鲜橘子没被腐烂，返回 −1 ，否则返回所有新鲜橘子被腐烂的时间的最大值即可，也可以在广度优先搜索的过程中把已腐烂的新鲜橘子的值由 1 改为 2，最后看网格中是否有值为 1 即新鲜的橘子即可。最后的答案就是所有新鲜橘子被腐烂的最短时间的最大值，如果是无限大，说明有新鲜橘子没有被腐烂，输出 −1 即可。
2025-03-14 10:22:03
540
原创 python-leetcode 50.岛屿数量
为了求出岛屿的数量，可以扫描整个二维网格。在深度优先搜索的过程中，每个搜索到的 1 都会被重新标记为 0。为了求出岛屿的数量，我们可以扫描整个二维网格，如果一个位置为 1，则将其加入队列，开始进行广度优先搜索。在广度优先搜索的过程中，每个搜索到的 1 都会被重新标记为 0。空间复杂度：O(min(M,N))，在最坏情况下，整个网格均为陆地，队列的大小可以达到 min(M,N)给定一个由“1”陆地和“0”水组成的网格，请计算网格中岛屿的数量。最终岛屿的数量就是我们进行广度优先搜索的次数。
2025-03-12 22:16:09
366
原创 python-leetcode 49.二叉树中的最大路径和
对于二叉树中的一个节点，该节点的最大路径和取决于该节点的值与该节点的左右子节点的最大贡献值，如果子节点的最大贡献值为正，则计入该节点的最大路径和，否则不计入该节点的最大路径和。首先，考虑实现一个简化的函数 maxGain(node)，该函数计算二叉树中的一个节点的最大贡献值，具体而言，就是在以该节点为根节点的子树中寻找以该节点为起点的一条路径，使得该路径上的节点值之和最大。非空节点的最大贡献值等于节点值与其子节点中的最大贡献值之和（对于叶节点而言，最大贡献值等于节点值），即可得到每个节点的最大贡献值。
2025-03-12 20:58:17
263
原创 python-leetcode 48.二叉树的最近公共祖先
其中 lson 和 rson 分别代表 x 节点的左孩子和右孩子，flson && frson 说明左子树和右子树均包含 p 节点或 q 节点，如果左子树包含的是 p 节点，那么右子树只能包含 q 节点，反之亦然，因为 p 节点和 q 节点都是不同且唯一的节点，因此如果满足这个判断条件即可说明 x 就是我们要找的最近公共祖先。递归调用的栈深度取决于二叉树的高度，二叉树最坏情况下为一条链，此时高度为 N，因此空间复杂度为 O(N)，哈希表存储每个节点的父节点也需要 O(N) 的空间复杂度。
2025-03-04 22:14:27
455
原创 python-leetcode 47.路径总和III
假设当前的节点 p 的值为 val，对左子树和右子树进行递归搜索，对节点 p 的左孩子节点 pi求出rootSum(pl,targetSum-val).以l及对右孩子节点P求出rootSum(pr,targetSum-val),节点 p 的root(p.targetSum)即等于rootSum(pl,targetSum-val)与rootSum(pr,targetSum-val)之和同时我们还需要判断一下当前节点 p 的值是否刚好等于 targetSum。时间复杂度：O(N2)N 为该二叉树节点的个数。
2025-03-04 20:05:43
831
原创 python-leetcode 46.从前序与中序遍历序列构造二叉树
在中序遍历中对根节点进行定位时，一种简单的方法是直接扫描整个中序遍历的结果并找出根节点，但这样做的时间复杂度较高。由于同一颗子树的前序遍历和中序遍历的长度显然是相同的，因此我们就可以对应到前序遍历的结果中，对上述形式中的所有。这样以来，就知道了左子树的前序遍历和中序遍历结果，以及右子树的前序遍历和中序遍历结果，我们就可以递归地对构造出左子树和右子树，再将这两颗子树接到根节点的左右位置。[ 根节点, [左子树的前序遍历结果], [右子树的前序遍历结果] ]前序遍历：0[root[左子树][右子树]]n-1。
2025-02-27 22:44:25
326
原创 python-leetcode 45.二叉树转换为链表
如果一个节点的左子节点不为空，则该节点的左子树中的最后一个节点被访问之后，该节点的右子节点被访问。该节点的左子树中最后一个被访问的节点是左子树中的最右边的节点，也是该节点的前驱节点。对于当前节点，如果其左子节点不为空，则在其左子树中找到最右边的节点，作为前驱节点,，将当前节点的右子节点赋给前驱节点的右子节点，然后将当前节点的左子节点赋给当前节点的右子节点，并将当前节点的左子节点设为空。前序遍历的时间复杂度是 O(n)，前序遍历之后，需要对每个节点更新左右子节点的信息，时间复杂度也是 O(n)。
2025-02-27 20:20:50
475
原创 python-leetcode 44.二叉树的右视图
执行广度优先搜索，左结点排在右结点之前，这样，我们对每一层都从左到右访问。因此，只保留每个深度最后访问的结点，我们就可以在遍历完整棵树后得到每个深度最右的结点。以对二叉树进行层次遍历，那么对于每层来说，最右边的结点一定是最后被遍历到的。每个节点最多进队列一次，所以队列长度最大不不超过 n，所以这里的空间代价为 O(n)。空间复杂度：O(n)最坏情况下，栈内会包含接近树高度的结点数量，占用 O(n) 的空间。可以存储在每个深度访问的第一个结点，一旦知道了树的层数，就可以得到最终的结果数组。
2025-02-26 21:27:47
356
原创 python-leetcode 43.二叉搜索树中第K小的元素
如果 node 的左子树的结点数 left 小于 k−1，则第 k 小的元素一定在 node 的右子树中，令 node 等于其的右子结点，k 等于 k−left−1，并继续搜索；搜索的时间复杂度为 O(H)，其中 H 是树的高度；如果 node 的左子树的结点数 left 大于 k−1，则第 k 小的元素一定在 node 的左子树中，令 node 等于其左子结点，并继续搜索。如果 node 的左子树的结点数 left 等于 k−1，则第 k 小的元素即为 node ，结束搜索并返回 node 即可。
2025-02-25 21:25:55
409
原创 python-leetcode 42.验证二叉搜索树
根据二叉搜索树的性质，在递归调用左子树时，我们需要把上界 upper 改为 root.val，即调用 helper(root.left, lower, root.val)，因为左子树里所有节点的值均小于它的根节点的值。而我们二叉搜索树保证了左子树的节点的值均小于根节点的值，根节点的值均小于右子树的值，因此中序遍历以后得到的序列一定是升序序列。二叉搜索树「中序遍历」得到的值构成的序列一定是升序的，这启示我们在中序遍历的时候实时检查当前节点的值是否大于前一个中序遍历到的节点的值即可。空间复杂度：O(n)
2025-02-24 21:55:54
511
原创 python-leetcode 41.将有序数组转换为二叉搜索树
如果数组长度是奇数，则根节点的选择是唯一的，如果数组长度是偶数，则可以选择中间位置左边的数字作为根节点或者选择中间位置右边的数字作为根节点，选择不同的数字作为根节点则创建的平衡二叉搜索树也是不同的。确定平衡二叉搜索树的根节点之后，其余的数字分别位于平衡二叉搜索树的左子树和右子树中，左子树和右子树分别也是平衡二叉搜索树，因此可以通过递归的方式创建平衡二叉搜索树。二叉搜索树的中序遍历是升序序列，题目给定的数组是按照升序排序的有序数组，因此可以确保数组是二叉搜索树的中序遍历序列。
2025-02-24 20:21:49
354
原创 python-leetcode 40.二叉树的层序遍历
给定二叉树的根节点root,返回其节点值得层序遍历（即逐层从左到右访问所有节点）时间复杂度：O(n)空间复杂度：O(n)时间复杂度：O(n)空间复杂度：O(n)
2025-02-20 22:04:09
251
原创 python-leetcode 39.二叉树的直径
先递归调用左儿子和右儿子求得它们为根的子树的深度L和R，则该节点为根的子树的深度即为max(L,R)+1该节点的d node值为L+R+1递归搜索每个节点并设一个全局变量ans记录dnode的最大值，最后返回ans-1即为树的直径。假设知道对于该节点的左儿子向下遍历经过最多的节点数L（即以左儿子为根的子树的深度） 和其右儿子向下遍历经过最多的节点数R（即以右儿子为根的子树的深度），那么以该节点为起点的路径经过节点数的最大值即为L+R+1。二叉树的直径是指中间任意两个节点之间最长路径的长度。
2025-02-20 21:26:05
386
原创 python-leetcode 38.翻转二叉树
每次提取两个结点并比较它们的值（队列中每两个连续的结点应该是相等的，而且它们的子树互为镜像），然后将两个结点的左右子结点按相反的顺序插入队列中。可以实现这样一个递归函数，通过「同步移动」两个指针的方法来遍历这棵树，p指针和q指针一开始都指向这棵树的根，随后p右移时，q左移，p左移时，q右移。互为镜像的条件：他们的两个根结点具有相同的值，每棵树的右子树都与另一个树的左子树镜像对称。如果一个树的左子树与右子树镜像对称，那么这个树是对称的。时间复杂度：O(n)空间复杂度：O(n)空间复杂度：O(n)
2025-02-20 21:04:40
345
原创 python-leetcode 37.翻转二叉树
从根节点开始，递归地对树进行遍历，并从叶子节点先开始翻转。如果当前遍历到的节点root的左右两棵子树都已经翻转，那么我们只需要交换两棵子树的位置，即可完成以root为根节点的整棵子树的翻转。给定一颗二叉树的根节点root,翻转这棵二叉树，并返回根节点。时间复杂度：O(n)遍历二叉树中的每一个节点。空间复杂度：O(n)
2025-02-19 21:34:54
330
原创 python-leetcode 36.二叉树的最大深度
因此可以用「深度优先搜索」的方法来计算二叉树的最大深度。具体而言，在计算当前二叉树的最大深度时，可以先递归计算出其左子树和右子树的最大深度，然后在O(1)时间内计算出当前二叉树的最大深度。广度优先搜索的队列里存放的是「当前层的所有节点」。每次拓展下一层的时候，用一个变量ans来维护拓展的次数，该二叉树的最大深度即为ans。知道了左子树和右子树的最大深度l和r，那么该二叉树的最大深度即为:max(l,r)+1。每个节点在递归中只被遍历一次。二叉树的最大深度是指从根节点到最远叶子节点的最长路径上的节点数。
2025-02-19 21:19:49
281
原创 python-leetcode 35.二叉树的中序遍历
给定一个二叉树的根节点root,返回它的中序遍历。二叉树的中序遍历：按照访问左子树——根节点——右子树的方式遍历这棵树，而在访问左子树或者右子树的时候我们按照同样的方式遍历，直到遍历完整棵树。因此整个遍历过程天然具有递归的性质。
2025-02-19 20:39:55
545
原创 python-leetcode 34.合并K个升序链表
一个巧妙的思路是，把lists一分为二（尽量均分），先合并前一半的链表，再合并后一半的链表，然后把这两个链表合并成最终的链表。如此分下去直到只有一个链表，此时无需合并。维护当前每个链表没有被合并的元素的最前面一个，k个链表就最多有k个满足这样条件的元素，每次在这些元素里面选取val属性最小的元素合并到答案中。给定一个链表数组，每个链表都已经按升序排序，请将所有链表合并到一个升序链表中，返回合并后的链表。按照方法一先合并前两个链表，再把得到的新链表和第三个链表合并，再和第四个链表合并，依此类推。
2025-02-18 20:04:54
446
原创 python-leetcode 33.排序链表
每次将链表拆分成若干个长度为 subLength 的子链表（最后一个子链表的长度可以小于 subLength）按照每两个子链表一组进行合并，合并后即可得到若干个长度为subLength×2 的有序子链表（最后一个子链表的长度可以小于 subLength×2）。合并两个子链表仍然使用[合并两个有序链表]的做法。寻找链表的中点可以使用快慢指针的做法，快指针每次移动 2 步，慢指针每次移动 1 步，当快指针到达链表末尾时，慢指针指向的链表节点即为链表的中点。3.将两个排序后的子链表合并，得到完整的排序后的链表。
2025-02-18 11:26:23
373
空空如也
空空如也
TA创建的收藏夹 TA关注的收藏夹
TA关注的人