From b971fca4d598de793800a7dd71f53fa12fa4cd16 Mon Sep 17 00:00:00 2001 From: lucifer Date: Fri, 27 Nov 2020 13:06:10 +0800 Subject: [PATCH] feat: latex $ -> $$ --- 91/binary-search.md | 26 ++++----- daily/2019-08-09.md | 6 +- problems/1.two-sum.md | 4 +- problems/100.same-tree.md | 12 ++-- problems/101.symmetric-tree.md | 4 +- ...capacity-to-ship-packages-within-d-days.md | 4 +- problems/1014.best-sightseeing-pair.md | 4 +- .../1019.next-greater-node-in-linked-list.md | 6 +- .../102.binary-tree-level-order-traversal.md | 4 +- problems/1020.number-of-enclaves.md | 10 ++-- problems/1023.camelcase-matching.md | 4 +- problems/1032.stream-of-characters.md | 2 +- problems/104.maximum-depth-of-binary-tree.md | 4 +- ...vert-sorted-array-to-binary-search-tree.md | 8 +-- ...nvert-Sorted-List-to-Binary-Search-Tree.md | 8 +-- problems/11.container-with-most-water.md | 8 +-- ...104.path-in-zigzag-labelled-binary-tree.md | 4 +- ...31.maximum-of-absolute-value-expression.md | 4 +- ....maximum-subarray-sum-with-one-deletion.md | 4 +- .../121.best-time-to-buy-and-sell-stock.md | 4 +- ...thmetic-subsequence-of-given-difference.md | 8 +-- .../122.best-time-to-buy-and-sell-stock-ii.md | 4 +- ...27.airplane-seat-assignment-probability.md | 8 +-- problems/124.binary-tree-maximum-path-sum.md | 4 +- problems/125.valid-palindrome.md | 4 +- ...5.maximum-score-words-formed-by-letters.md | 4 +- problems/1260.shift-2d-grid.md | 4 +- .../1262.greatest-sum-divisible-by-three.md | 8 +-- problems/128.longest-consecutive-sequence.md | 4 +- problems/129.sum-root-to-leaf-numbers.md | 4 +- ...um-number-of-occurrences-of-a-substring.md | 4 +- problems/130.surrounded-regions.md | 4 +- problems/1310.xor-queries-of-a-subarray.md | 4 +- .../1332.remove-palindromic-subsequences.md | 4 +- ...er-of-neighbors-at-a-threshold-distance.md | 6 +- problems/136.single-number.md | 4 +- ...ing-containing-vowels-in-even-counts.en.md | 16 ++--- ...string-containing-vowels-in-even-counts.md | 14 ++--- ...design-a-stack-with-increment-operation.md | 18 +++--- problems/139.word-break.md | 4 +- problems/140.word-break-ii.md | 10 ++-- problems/142.Linked-List-Cycle-II.md | 8 +-- .../144.binary-tree-preorder-traversal.md | 4 +- ...teger-with-digits-that-add-up-to-target.md | 4 +- .../145.binary-tree-postorder-traversal.md | 4 +- problems/146.lru-cache.md | 4 +- problems/147.insertion-sort-list.md | 4 +- problems/15.3sum.md | 2 +- problems/152.maximum-product-subarray.md | 8 +-- ...-of-function-calls-to-make-target-array.md | 4 +- .../160.Intersection-of-Two-Linked-Lists.md | 8 +-- problems/1631.path-with-minimum-effort.md | 6 +- .../167.two-sum-ii-input-array-is-sorted.md | 4 +- problems/169.majority-element.md | 4 +- problems/172.factorial-trailing-zeroes.md | 4 +- problems/19.removeNthNodeFromEndofList.md | 4 +- problems/190.reverse-bits.md | 4 +- problems/191.number-of-1-bits.md | 4 +- problems/198.house-robber.md | 4 +- problems/2.add-two-numbers.md | 8 +-- problems/20.valid-parentheses.md | 10 ++-- problems/200.number-of-islands.md | 4 +- problems/201.bitwise-and-of-numbers-range.md | 4 +- problems/203.remove-linked-list-elements.md | 4 +- problems/206.reverse-linked-list.md | 8 +-- problems/209.minimum-size-subarray-sum.md | 4 +- problems/21.merge-two-sorted-lists.md | 4 +- ...d-and-search-word-data-structure-design.md | 2 +- problems/212.word-search-ii.md | 2 +- problems/219.contains-duplicate-ii.md | 4 +- problems/221.maximal-square.md | 4 +- problems/226.invert-binary-tree.md | 4 +- problems/229.majority-element-ii.md | 4 +- problems/23.merge-k-sorted-lists.md | 4 +- problems/230.kth-smallest-element-in-a-bst.md | 4 +- problems/232.implement-queue-using-stacks.md | 4 +- ...lowest-common-ancestor-of-a-binary-tree.md | 4 +- problems/238.product-of-array-except-self.md | 4 +- problems/239.sliding-window-maximum.md | 4 +- problems/24.swapNodesInPairs.md | 4 +- problems/240.search-a-2-d-matrix-ii.md | 4 +- problems/25.reverse-nodes-in-k-groups.md | 4 +- .../26.remove-duplicates-from-sorted-array.md | 4 +- problems/263.ugly-number.md | 8 +-- problems/279.perfect-squares.md | 4 +- problems/283.move-zeroes.md | 4 +- problems/29.divide-two-integers.md | 4 +- ...7.serialize-and-deserialize-binary-tree.md | 4 +- ...-substring-without-repeating-characters.md | 4 +- ...bstring-with-concatenation-of-all-words.md | 4 +- problems/312.burst-balloons.md | 4 +- problems/32.longest-valid-parentheses.md | 12 ++-- problems/322.coin-change.md | 8 +-- problems/328.odd-even-linked-list.md | 4 +- problems/33.search-in-rotated-sorted-array.md | 4 +- .../334.increasing-triplet-subsequence.md | 4 +- problems/335.self-crossing.md | 12 ++-- problems/337.house-robber-iii.md | 4 +- problems/342.power-of-four.md | 4 +- problems/349.intersection-of-two-arrays.md | 4 +- problems/365.water-and-jug-problem.md | 8 +-- problems/371.sum-of-two-integers.md | 4 +- ...kth-smallest-element-in-a-sorted-matrix.md | 4 +- problems/380.insert-delete-getrandom-o1.md | 16 ++--- problems/394.decode-string.md | 8 +-- problems/4.median-of-two-sorted-arrays.md | 8 +-- problems/416.partition-equal-subset-sum.md | 4 +- problems/42.trapping-rain-water.en.md | 8 +-- problems/42.trapping-rain-water.md | 8 +-- problems/437.path-sum-iii.md | 4 +- problems/445.add-two-numbers-ii.md | 4 +- problems/454.4-sum-ii.md | 4 +- problems/48.rotate-image.md | 4 +- problems/488.zuma-game.md | 4 +- problems/49.group-anagrams.md | 4 +- problems/493.reverse-pairs.md | 6 +- problems/494.target-sum.md | 4 +- problems/5.longest-palindromic-substring.md | 4 +- problems/50.pow-x-n.md | 6 +- problems/513.find-bottom-left-tree-value.md | 8 +-- .../516.longest-palindromic-subsequence.md | 4 +- problems/518.coin-change-2.md | 8 +-- problems/53.maximum-sum-subarray-cn.md | 20 +++---- problems/547.friend-circles.md | 8 +-- problems/55.jump-game.md | 4 +- problems/56.merge-intervals.md | 4 +- problems/57.insert-interval.md | 8 +-- problems/575.distribute-candies.md | 4 +- problems/60.permutation-sequence.md | 4 +- problems/61.Rotate-List.md | 4 +- problems/611.valid-triangle-number.md | 14 ++--- problems/62.unique-paths.md | 10 ++-- problems/63.unique-paths-ii.md | 8 +-- problems/686.repeated-string-match.md | 4 +- ...718.maximum-length-of-repeated-subarray.md | 6 +- problems/721.accounts-merge.md | 8 +-- problems/73.set-matrix-zeroes.md | 4 +- problems/75.sort-colors.md | 12 ++-- problems/768.max-chunks-to-make-sorted-ii.md | 12 ++-- problems/785.is-graph-bipartite.md | 4 +- ....remove-duplicates-from-sorted-array-ii.md | 4 +- problems/816.ambiguous-coordinates.md | 4 +- problems/820.short-encoding-of-words.md | 4 +- .../821.shortest-distance-to-a-character.md | 12 ++-- problems/84.largest-rectangle-in-histogram.md | 18 +++--- problems/85.maximal-rectangle.md | 4 +- problems/86.partition-list.md | 4 +- problems/874.walking-robot-simulation.md | 8 +-- problems/875.koko-eating-bananas.md | 6 +- problems/88.merge-sorted-array.md | 4 +- problems/886.possible-bipartition.md | 4 +- problems/887.super-egg-drop.md | 4 +- problems/895.maximum-frequency-stack.md | 4 +- problems/91.decode-ways.md | 4 +- problems/92.reverse-linked-list-ii.md | 4 +- problems/935.knight-dialer.md | 8 +-- problems/96.unique-binary-search-trees.md | 4 +- problems/978.longest-turbulent-subarray.md | 4 +- problems/98.validate-binary-search-tree.md | 4 +- ...rtical-order-traversal-of-a-binary-tree.md | 6 +- problems/binode-lcci.md | 4 +- problems/get-kth-magic-number-lcci.md | 4 +- selected/LCS.md | 14 ++--- selected/LIS.md | 16 ++--- selected/a-deleted.md | 24 ++++---- selected/atMostK.md | 32 +++++----- selected/byte-dance-algo-ex-2017.md | 24 ++++---- selected/byte-dance-algo-ex.md | 8 +-- selected/construct-binary-tree.md | 12 ++-- selected/mother-01.md | 58 +++++++++---------- selected/schedule-topic.md | 8 +-- selected/serialize.md | 8 +-- selected/zuma-game.md | 4 +- thinkings/GCD.md | 8 +-- thinkings/balanced-tree.md | 16 ++--- thinkings/basic-data-structure.md | 4 +- thinkings/binary-tree-traversal.md | 2 +- thinkings/bit.md | 18 +++--- thinkings/greedy.md | 12 ++-- thinkings/linked-list.md | 4 +- thinkings/monotone-stack.md | 4 +- thinkings/prefix.md | 32 +++++----- thinkings/tree.md | 7 ++- 183 files changed, 630 insertions(+), 629 deletions(-) diff --git a/91/binary-search.md b/91/binary-search.md index 14cc76dee..fecf5fa43 100644 --- a/91/binary-search.md +++ b/91/binary-search.md @@ -54,12 +54,12 @@ **复杂度分析** -- 平均时间复杂度： $O(logN)$ -- 最坏时间复杂度： $O(logN)$ -- 最优时间复杂度： $O(1)$ +- 平均时间复杂度： $$O(logN)$$ +- 最坏时间复杂度： $$O(logN)$$ +- 最优时间复杂度： $$O(1)$$ - 空间复杂度 - - 迭代: $O(1)$ - - 递归： $O(logN)$（无尾调用消除） + - 迭代: $$O(1)$$ + - 递归： $$O(logN)$$（无尾调用消除） > 后面的复杂度也是类似的，不再赘述。 @@ -467,8 +467,8 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(log N)$ -- 空间复杂度：$O(1)$ +- 时间复杂度：$$O(log N)$$ +- 空间复杂度：$$O(1)$$ ### 二维数组 @@ -553,8 +553,8 @@ class Solution: **复杂度分析** -- 时间复杂度：最坏的情况是只有一行或者只有一列，此时时间复杂度为 $O(M * N)$。更多的情况下时间复杂度为 $O(M + N)$ -- 空间复杂度：$O(1)$ +- 时间复杂度：最坏的情况是只有一行或者只有一列，此时时间复杂度为 $$O(M * N)$$。更多的情况下时间复杂度为 $$O(M + N)$$ +- 空间复杂度：$$O(1)$$ 力扣 [240. 搜索二维矩阵 II](https://leetcode-cn.com/problems/search-a-2d-matrix-ii/) 发生了一点变化，不再是`每行的第一个整数大于前一行的最后一个整数`，而是 `每列的元素从上到下升序排列`。我们仍然可以选择左下进行二分。 @@ -633,8 +633,8 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(log N)$ -- 空间复杂度：$O(1)$ +- 时间复杂度：$$O(log N)$$ +- 空间复杂度：$$O(1)$$ ##### 另一种二分法 @@ -712,8 +712,8 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(log N)$ -- 空间复杂度：$O(1)$ +- 时间复杂度：$$O(log N)$$ +- 空间复杂度：$$O(1)$$ ### 二叉树 diff --git a/daily/2019-08-09.md b/daily/2019-08-09.md index bd899be98..98414e2ec 100644 --- a/daily/2019-08-09.md +++ b/daily/2019-08-09.md @@ -24,7 +24,7 @@ 我们新建一个额外的dp数组，与原矩阵大小相同。在这个矩阵中,dp(i,j)表示从原点到坐标(i,j)的最小路径和。我们初始化dp值为对应的原矩阵值，然后去填整个矩阵，对于每个元素考虑从上方移动过来还是从左方移动过来，因此获得最小路径和我们有如下递推公式：`dp(i,j)=grid(i,j)+min(dp(i-1,j),dp(i,j-1))` -我们可以使用原地算法，这样就不需要开辟dp数组，空间复杂度可以降低到$O(1)$。 +我们可以使用原地算法，这样就不需要开辟dp数组，空间复杂度可以降低到$$O(1)$$。 ```c++ class Solution { @@ -62,8 +62,8 @@ public: **复杂度分析** -- 时间复杂度：$O(M * N)$ -- 空间复杂度：$O(1)$ +- 时间复杂度：$$O(M * N)$$ +- 空间复杂度：$$O(1)$$ ## 其他优秀解答 > 暂缺 diff --git a/problems/1.two-sum.md b/problems/1.two-sum.md index 303145cba..be543ca51 100644 --- a/problems/1.two-sum.md +++ b/problems/1.two-sum.md @@ -92,8 +92,8 @@ func twoSum(nums []int, target int) []int { **复杂度分析** -- 时间复杂度：$O(N)$ -- 空间复杂度：$O(N)$ +- 时间复杂度：$$O(N)$$ +- 空间复杂度：$$O(N)$$ 更多题解可以访问我的LeetCode题解仓库：https://github.com/azl397985856/leetcode 。 目前已经37K star啦。 diff --git a/problems/100.same-tree.md b/problems/100.same-tree.md index 167a86e6e..942ea4bf2 100644 --- a/problems/100.same-tree.md +++ b/problems/100.same-tree.md @@ -114,8 +114,8 @@ class Solution **复杂度分析** -- 时间复杂度：$O(N)$，其中 N 为树的节点数。 -- 空间复杂度：$O(h)$，其中 h 为树的高度。 +- 时间复杂度：$$O(N)$$，其中 N 为树的节点数。 +- 空间复杂度：$$O(h)$$，其中 h 为树的高度。 ## 层序遍历 @@ -174,8 +174,8 @@ function isSameNode(nodeA, nodeB) { **复杂度分析** -- 时间复杂度：$O(N)$，其中 N 为树的节点数。 -- 空间复杂度：$O(Q)$，其中 Q 为队列的长度最大值，在这里不会超过相邻两层的节点数的最大值。 +- 时间复杂度：$$O(N)$$，其中 N 为树的节点数。 +- 空间复杂度：$$O(Q)$$，其中 Q 为队列的长度最大值，在这里不会超过相邻两层的节点数的最大值。 ## 前中序确定一棵树 @@ -226,5 +226,5 @@ function inorder(root, arr) { **复杂度分析** -- 时间复杂度：$O(N)$，其中 N 为树的节点数。 -- 空间复杂度：使用了中序遍历的结果数组，因此空间复杂度为 $O(N)$，其中 N 为树的节点数。 +- 时间复杂度：$$O(N)$$，其中 N 为树的节点数。 +- 空间复杂度：使用了中序遍历的结果数组，因此空间复杂度为 $$O(N)$$，其中 N 为树的节点数。 diff --git a/problems/101.symmetric-tree.md b/problems/101.symmetric-tree.md index b84bb5e72..74b8af6d1 100644 --- a/problems/101.symmetric-tree.md +++ b/problems/101.symmetric-tree.md @@ -191,8 +191,8 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(N)$，其中 N 为节点数。 -- 空间复杂度：递归的深度最高为节点数，因此空间复杂度是 $O(N)$，其中 N 为节点数。 +- 时间复杂度：$$O(N)$$，其中 N 为节点数。 +- 空间复杂度：递归的深度最高为节点数，因此空间复杂度是 $$O(N)$$，其中 N 为节点数。 大家对此有何看法，欢迎给我留言，我有时间都会一一查看回答。更多算法套路可以访问我的 LeetCode 题解仓库：https://github.com/azl397985856/leetcode 。 目前已经 37K star 啦。 大家也可以关注我的公众号《力扣加加》带你啃下算法这块硬骨头。 diff --git a/problems/1011.capacity-to-ship-packages-within-d-days.md b/problems/1011.capacity-to-ship-packages-within-d-days.md index 18be649b9..61ab3c242 100644 --- a/problems/1011.capacity-to-ship-packages-within-d-days.md +++ b/problems/1011.capacity-to-ship-packages-within-d-days.md @@ -176,5 +176,5 @@ var shipWithinDays = function(weights, D) { **复杂度分析** -- 时间复杂度：$O(logN)$ -- 空间复杂度：$O(N)$ +- 时间复杂度：$$O(logN)$$ +- 空间复杂度：$$O(N)$$ diff --git a/problems/1014.best-sightseeing-pair.md b/problems/1014.best-sightseeing-pair.md index d2ad2fbf9..c120bd753 100644 --- a/problems/1014.best-sightseeing-pair.md +++ b/problems/1014.best-sightseeing-pair.md @@ -106,8 +106,8 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(N)$ -- 空间复杂度：$O(N)$ +- 时间复杂度：$$O(N)$$ +- 空间复杂度：$$O(N)$$ 大家对此有何看法，欢迎给我留言，我有时间都会一一查看回答。更多算法套路可以访问我的 LeetCode 题解仓库：https://github.com/azl397985856/leetcode 。 目前已经 37K star 啦。 大家也可以关注我的公众号《力扣加加》带你啃下算法这块硬骨头。 diff --git a/problems/1019.next-greater-node-in-linked-list.md b/problems/1019.next-greater-node-in-linked-list.md index 96510afdb..a8f16c84d 100644 --- a/problems/1019.next-greater-node-in-linked-list.md +++ b/problems/1019.next-greater-node-in-linked-list.md @@ -49,7 +49,7 @@ https://leetcode-cn.com/problems/next-greater-node-in-linked-list/ 看完题目就应该想到单调栈才行，LeetCode 上关于单调栈的题目还不少，难度都不小。但是一旦你掌握了这个算法，那么这些题目对你来说都不是问题了。 -如果你不用单调栈，那么可以暴力$O(N^2)$的时间复杂度解决，只需要双层循环即可。但是这种做法应该是过不了关的。使用单调栈可以将时间复杂度降低到线性，当然需要额外的$O(N)$的空间复杂度。 +如果你不用单调栈，那么可以暴力$$O(N^2)$$的时间复杂度解决，只需要双层循环即可。但是这种做法应该是过不了关的。使用单调栈可以将时间复杂度降低到线性，当然需要额外的$$O(N)$$的空间复杂度。 顾名思义，单调栈即满足单调性的栈结构。与单调队列相比，其只在一端进行进出。为了描述方便，以下举例及代码以维护一个整数的单调递减栈为例。将一个元素插入单调栈时，为了维护栈的单调性，需要在保证将该元素插入到栈顶后整个栈满足单调性的前提下弹出最少的元素。 @@ -107,8 +107,8 @@ class Solution: 其中 N 为链表的长度。 -- 时间复杂度：$O(N)$ -- 空间复杂度：$O(N)$ +- 时间复杂度：$$O(N)$$ +- 空间复杂度：$$O(N)$$ ## 扩展 diff --git a/problems/102.binary-tree-level-order-traversal.md b/problems/102.binary-tree-level-order-traversal.md index bc24f9288..e91090e1e 100644 --- a/problems/102.binary-tree-level-order-traversal.md +++ b/problems/102.binary-tree-level-order-traversal.md @@ -195,8 +195,8 @@ class Solution: ``` ***复杂度分析*** -- 时间复杂度：$O(N)$，其中N为树中节点总数。 -- 空间复杂度：$O(N)$，其中N为树中节点总数。 +- 时间复杂度：$$O(N)$$，其中N为树中节点总数。 +- 空间复杂度：$$O(N)$$，其中N为树中节点总数。 更多题解可以访问我的LeetCode题解仓库：https://github.com/azl397985856/leetcode 。 目前已经30K star啦。 diff --git a/problems/1020.number-of-enclaves.md b/problems/1020.number-of-enclaves.md index ed2f8d8ba..87117f52c 100644 --- a/problems/1020.number-of-enclaves.md +++ b/problems/1020.number-of-enclaves.md @@ -103,8 +103,8 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(M * N)$ -- 空间复杂度：$O(M * N)$ +- 时间复杂度：$$O(M * N)$$ +- 空间复杂度：$$O(M * N)$$ ## 解法二 (原地标记法) @@ -114,7 +114,7 @@ class Solution: ### 思路 -上面的解法空间复杂度很差，我们考虑进行优化， 这里我们使用消除法。即使用题目范围外的数据原地标记是否访问， 这样时间复杂度可以优化到 $O(1)$，这是一种非常常见的优化技巧，请务必掌握，另外文章末尾的题目也是类似的技巧，大家可以结合起来练习。 +上面的解法空间复杂度很差，我们考虑进行优化， 这里我们使用消除法。即使用题目范围外的数据原地标记是否访问， 这样时间复杂度可以优化到 $$O(1)$$，这是一种非常常见的优化技巧，请务必掌握，另外文章末尾的题目也是类似的技巧，大家可以结合起来练习。 - 从矩阵边界开始 dfs - 如果碰到 1 就将其变成 0 @@ -173,8 +173,8 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(M * N)$ -- 空间复杂度：$O(1)$ +- 时间复杂度：$$O(M * N)$$ +- 空间复杂度：$$O(1)$$ ## 参考 diff --git a/problems/1023.camelcase-matching.md b/problems/1023.camelcase-matching.md index 2c0c8ac3b..f5a84317e 100644 --- a/problems/1023.camelcase-matching.md +++ b/problems/1023.camelcase-matching.md @@ -139,8 +139,8 @@ class Solution: 其中 N 为 queries 的长度， M 为 queries 的平均长度， P 为 pattern 的长度。 -- 时间复杂度：$O(N * M * P)$ -- 空间复杂度：$O(1)$ +- 时间复杂度：$$O(N * M * P)$$ +- 空间复杂度：$$O(1)$$ ## 扩展 diff --git a/problems/1032.stream-of-characters.md b/problems/1032.stream-of-characters.md index 0e1083b52..ad7a7539d 100644 --- a/problems/1032.stream-of-characters.md +++ b/problems/1032.stream-of-characters.md @@ -60,7 +60,7 @@ streamChecker.query("c"); // stream：cba 这里有两个小的点需要注意： -1. 如果用数组来存储， 由于每次都往数组头部插入一个元素，因此每次 query 操作的时间复杂度为 $O(N)$，其中 $N$ 为截止当前执行 query 的次数，我们可以使用双端队列进行优化。 +1. 如果用数组来存储， 由于每次都往数组头部插入一个元素，因此每次 query 操作的时间复杂度为 $$O(N)$$，其中 $N$ 为截止当前执行 query 的次数，我们可以使用双端队列进行优化。 2. 由于不必 query 形成的查询全部命中。比如 stream 为 cba 的时候，找到单词 c， bc， abc 都是可以的。如果是找到 c，cb，cba 比较好吧，现在是反的。其实我们可以反序插入是，类似的技巧在[211.add-and-search-word-data-structure-design](https://github.com/azl397985856/leetcode/blob/b8e8fa5f0554926efa9039495b25ed7fc158372a/problems/211.add-and-search-word-data-structure-design.md) 也有用到。 之后我们用拼接的单词在 words 中查询即可， 最简单的方式当然是每次 query 都去扫描一次，这种方式毫无疑问会超时。 diff --git a/problems/104.maximum-depth-of-binary-tree.md b/problems/104.maximum-depth-of-binary-tree.md index df4edcd65..4cf706799 100644 --- a/problems/104.maximum-depth-of-binary-tree.md +++ b/problems/104.maximum-depth-of-binary-tree.md @@ -295,8 +295,8 @@ class Solution **复杂度分析** -- 时间复杂度：$O(N)$ -- 空间复杂度：$O(N)$ +- 时间复杂度：$$O(N)$$ +- 空间复杂度：$$O(N)$$ ## 相关题目 diff --git a/problems/108.convert-sorted-array-to-binary-search-tree.md b/problems/108.convert-sorted-array-to-binary-search-tree.md index 3e1a46f2b..e0809d1ea 100644 --- a/problems/108.convert-sorted-array-to-binary-search-tree.md +++ b/problems/108.convert-sorted-array-to-binary-search-tree.md @@ -88,8 +88,8 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(N)$ -- 空间复杂度：每次递归都 copy 了 N 的 空间，因此空间复杂度为 $O(N ^ 2)$ +- 时间复杂度：$$O(N)$$ +- 空间复杂度：每次递归都 copy 了 N 的 空间，因此空间复杂度为 $$O(N ^ 2)$$ 然而，实际上没必要开辟新的空间： @@ -171,8 +171,8 @@ class Solution(object): **复杂度分析** -- 时间复杂度：$O(N)$ -- 空间复杂度：由于是平衡二叉树，因此隐式调用栈的开销为 $O(logN)$ +- 时间复杂度：$$O(N)$$ +- 空间复杂度：由于是平衡二叉树，因此隐式调用栈的开销为 $$O(logN)$$ 更多题解可以访问我的 LeetCode 题解仓库：https://github.com/azl397985856/leetcode 。 目前已经 37K star 啦。 diff --git a/problems/109.Convert-Sorted-List-to-Binary-Search-Tree.md b/problems/109.Convert-Sorted-List-to-Binary-Search-Tree.md index 199fec5be..fb39c2431 100644 --- a/problems/109.Convert-Sorted-List-to-Binary-Search-Tree.md +++ b/problems/109.Convert-Sorted-List-to-Binary-Search-Tree.md @@ -88,8 +88,8 @@ class Solution { ``` **复杂度分析** -- 时间复杂度：节点最多只遍历N*logN遍，时间复杂度为$O(NlogN)$ -- 空间复杂度：空间复杂度为$O(1)$ +- 时间复杂度：节点最多只遍历N*logN遍，时间复杂度为$$O(NlogN)$$ +- 空间复杂度：空间复杂度为$$O(1)$$ ### 缓存法 因为链表访问中点的时间复杂度为O(n),所以可以使用数组将链表的值存储,以空间换时间 @@ -217,6 +217,6 @@ class Solution ``` **复杂度分析** -- 时间复杂度：节点最多只遍历两遍，时间复杂度为$O(N)$ -- 空间复杂度：若使用数组对链表的值进行缓存，空间复杂度为$O(N)$ +- 时间复杂度：节点最多只遍历两遍，时间复杂度为$$O(N)$$ +- 空间复杂度：若使用数组对链表的值进行缓存，空间复杂度为$$O(N)$$ diff --git a/problems/11.container-with-most-water.md b/problems/11.container-with-most-water.md index 775a39b69..b12b1edcd 100644 --- a/problems/11.container-with-most-water.md +++ b/problems/11.container-with-most-water.md @@ -34,7 +34,7 @@ https://leetcode-cn.com/problems/container-with-most-water/description/ ## 思路 -题目中说`找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。` ，因此符合直觉的解法就是固定两个端点，计算可以承载的水量， 然后不断更新最大值，最后返回最大值即可。这种算法，需要两层循环，时间复杂度是 $O(n^2)$。 +题目中说`找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。` ，因此符合直觉的解法就是固定两个端点，计算可以承载的水量， 然后不断更新最大值，最后返回最大值即可。这种算法，需要两层循环，时间复杂度是 $$O(n^2)$$。 代码（JS）: @@ -60,7 +60,7 @@ return max; - ... - 计算长度为 1 的面积。 -很显然这种解法也是完备的，但是似乎时间复杂度还是 $O(n ^ 2)$, 不要着急，我们继续优化。 +很显然这种解法也是完备的，但是似乎时间复杂度还是 $$O(n ^ 2)$$, 不要着急，我们继续优化。 考虑一下，如果我们计算 n-1 长度的面积的时候，是可以直接排除一半的结果的。 @@ -149,8 +149,8 @@ class Solution: **_复杂度分析_** -- 时间复杂度：由于左右指针移动的次数加起来正好是 n， 因此时间复杂度为 $O(N)$。 -- 空间复杂度：$O(1)$。 +- 时间复杂度：由于左右指针移动的次数加起来正好是 n， 因此时间复杂度为 $$O(N)$$。 +- 空间复杂度：$$O(1)$$。 更多题解可以访问我的 LeetCode 题解仓库：https://github.com/azl397985856/leetcode 。 目前已经 37K star 啦。 diff --git a/problems/1104.path-in-zigzag-labelled-binary-tree.md b/problems/1104.path-in-zigzag-labelled-binary-tree.md index fa770f0e1..bee87c7b2 100644 --- a/problems/1104.path-in-zigzag-labelled-binary-tree.md +++ b/problems/1104.path-in-zigzag-labelled-binary-tree.md @@ -91,8 +91,8 @@ class Solution: ``` **复杂度分析** -- 时间复杂度：由于每次都在头部插入 res，因此时间复杂度为 $O(log_Label)$， 一共插入了 $O(log_Label)$ 次， 因此总的时间复杂度为 $O(logLabel * logLabel)$。 -- 空间复杂度：$O(1)$ +- 时间复杂度：由于每次都在头部插入 res，因此时间复杂度为 $$O(log_Label)$$， 一共插入了 $$O(log_Label)$$ 次， 因此总的时间复杂度为 $$O(logLabel * logLabel)$$。 +- 空间复杂度：$$O(1)$$ 大家对此有何看法，欢迎给我留言，我有时间都会一一查看回答。更多算法套路可以访问我的 LeetCode 题解仓库：https://github.com/azl397985856/leetcode 。 目前已经 37K star 啦。 大家也可以关注我的公众号《力扣加加》带你啃下算法这块硬骨头。 diff --git a/problems/1131.maximum-of-absolute-value-expression.md b/problems/1131.maximum-of-absolute-value-expression.md index e3e7478dd..d93cb85ad 100644 --- a/problems/1131.maximum-of-absolute-value-expression.md +++ b/problems/1131.maximum-of-absolute-value-expression.md @@ -190,8 +190,8 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(N^3)$ -- 空间复杂度：$O(N)$ +- 时间复杂度：$$O(N^3)$$ +- 空间复杂度：$$O(N)$$ ## 总结 diff --git a/problems/1186.maximum-subarray-sum-with-one-deletion.md b/problems/1186.maximum-subarray-sum-with-one-deletion.md index f2c947278..66bece89d 100644 --- a/problems/1186.maximum-subarray-sum-with-one-deletion.md +++ b/problems/1186.maximum-subarray-sum-with-one-deletion.md @@ -150,8 +150,8 @@ class Solution: ``` **复杂度分析** -- 时间复杂度：$O(N)$ -- 空间复杂度：$O(1)$ +- 时间复杂度：$$O(N)$$ +- 空间复杂度：$$O(1)$$ ## 关键点解析 diff --git a/problems/121.best-time-to-buy-and-sell-stock.md b/problems/121.best-time-to-buy-and-sell-stock.md index 5fba3f07e..5dde6b4c0 100644 --- a/problems/121.best-time-to-buy-and-sell-stock.md +++ b/problems/121.best-time-to-buy-and-sell-stock.md @@ -143,8 +143,8 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(N)$ -- 空间复杂度：$O(1)$ +- 时间复杂度：$$O(N)$$ +- 空间复杂度：$$O(1)$$ ## 相关题目 diff --git a/problems/1218.longest-arithmetic-subsequence-of-given-difference.md b/problems/1218.longest-arithmetic-subsequence-of-given-difference.md index 11ea4ab10..cd84ace27 100644 --- a/problems/1218.longest-arithmetic-subsequence-of-given-difference.md +++ b/problems/1218.longest-arithmetic-subsequence-of-given-difference.md @@ -67,8 +67,8 @@ https://leetcode-cn.com/problems/longest-arithmetic-subsequence-of-given-differe **复杂度分析** -- 时间复杂度：$O(N^2)$ -- 空间复杂度：$O(N)$ +- 时间复杂度：$$O(N^2)$$ +- 空间复杂度：$$O(N)$$ ### 动态规划 @@ -113,8 +113,8 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(N)$ -- 空间复杂度：$O(N)$ +- 时间复杂度：$$O(N)$$ +- 空间复杂度：$$O(N)$$ 大家对此有何看法，欢迎给我留言，我有时间都会一一查看回答。更多算法套路可以访问我的 LeetCode 题解仓库：https://github.com/azl397985856/leetcode 。 目前已经 37K star 啦。 大家也可以关注我的公众号《力扣加加》带你啃下算法这块硬骨头。 diff --git a/problems/122.best-time-to-buy-and-sell-stock-ii.md b/problems/122.best-time-to-buy-and-sell-stock-ii.md index dea9efc7b..6e17a2669 100644 --- a/problems/122.best-time-to-buy-and-sell-stock-ii.md +++ b/problems/122.best-time-to-buy-and-sell-stock-ii.md @@ -131,8 +131,8 @@ class Solution { **复杂度分析** -- 时间复杂度：$O(N)$ -- 空间复杂度：$O(1)$ +- 时间复杂度：$$O(N)$$ +- 空间复杂度：$$O(1)$$ ## 相关题目 diff --git a/problems/1227.airplane-seat-assignment-probability.md b/problems/1227.airplane-seat-assignment-probability.md index 1272bb04b..6cb7c938d 100644 --- a/problems/1227.airplane-seat-assignment-probability.md +++ b/problems/1227.airplane-seat-assignment-probability.md @@ -225,8 +225,8 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(N)$ -- 空间复杂度：$O(N)$ +- 时间复杂度：$$O(N)$$ +- 空间复杂度：$$O(N)$$ ## 优化数学分析 @@ -255,8 +255,8 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(1)$ -- 空间复杂度：$O(1)$ +- 时间复杂度：$$O(1)$$ +- 空间复杂度：$$O(1)$$ ## 关键点 diff --git a/problems/124.binary-tree-maximum-path-sum.md b/problems/124.binary-tree-maximum-path-sum.md index 65fb130b6..5287ea48c 100644 --- a/problems/124.binary-tree-maximum-path-sum.md +++ b/problems/124.binary-tree-maximum-path-sum.md @@ -175,8 +175,8 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(N)$ -- 空间复杂度：$O(N)$ +- 时间复杂度：$$O(N)$$ +- 空间复杂度：$$O(N)$$ ## 相关题目 diff --git a/problems/125.valid-palindrome.md b/problems/125.valid-palindrome.md index 438f92539..c94cac977 100644 --- a/problems/125.valid-palindrome.md +++ b/problems/125.valid-palindrome.md @@ -162,8 +162,8 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(N)$ -- 空间复杂度：$O(1)$ +- 时间复杂度：$$O(N)$$ +- 空间复杂度：$$O(1)$$ 大家对此有何看法，欢迎给我留言，我有时间都会一一查看回答。更多算法套路可以访问我的 LeetCode 题解仓库：https://github.com/azl397985856/leetcode 。 目前已经 37K star 啦。 大家也可以关注我的公众号《力扣加加》带你啃下算法这块硬骨头。 diff --git a/problems/1255.maximum-score-words-formed-by-letters.md b/problems/1255.maximum-score-words-formed-by-letters.md index 58bd83ec2..2693184ad 100644 --- a/problems/1255.maximum-score-words-formed-by-letters.md +++ b/problems/1255.maximum-score-words-formed-by-letters.md @@ -127,8 +127,8 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(2^N)$，其中 N 为 words 的个数。 -- 空间复杂度：$O(total)$，其中 total 为 words 中的字符总数。 +- 时间复杂度：$$O(2^N)$$，其中 N 为 words 的个数。 +- 空间复杂度：$$O(total)$$，其中 total 为 words 中的字符总数。 大家对此有何看法，欢迎给我留言，我有时间都会一一查看回答。更多算法套路可以访问我的 LeetCode 题解仓库：https://github.com/azl397985856/leetcode 。 目前已经 37K star 啦。 大家也可以关注我的公众号《力扣加加》带你啃下算法这块硬骨头。 diff --git a/problems/1260.shift-2d-grid.md b/problems/1260.shift-2d-grid.md index b1d362c2d..178a7a342 100644 --- a/problems/1260.shift-2d-grid.md +++ b/problems/1260.shift-2d-grid.md @@ -147,8 +147,8 @@ class Solution: ``` **复杂度分析** -- 时间复杂度：$O(N)$ -- 空间复杂度：$O(1)$ +- 时间复杂度：$$O(N)$$ +- 空间复杂度：$$O(1)$$ ## 相关题目 diff --git a/problems/1262.greatest-sum-divisible-by-three.md b/problems/1262.greatest-sum-divisible-by-three.md index 92389d2ad..4b0ebeaed 100644 --- a/problems/1262.greatest-sum-divisible-by-three.md +++ b/problems/1262.greatest-sum-divisible-by-three.md @@ -48,7 +48,7 @@ https://leetcode-cn.com/problems/greatest-sum-divisible-by-three/ ### 思路 -一种方式是找出所有的能够被 3 整除的子集，然后挑选出和最大的。由于我们选出了所有的子集，那么时间复杂度就是 $O(2^N)$ ， 毫无疑问会超时。这里我们使用回溯法找子集，如果不清楚回溯法，可以参考我之前的题解，很多题目都用到了，比如[78.subsets](https://github.com/azl397985856/leetcode/blob/master/problems/78.subsets.md)。 +一种方式是找出所有的能够被 3 整除的子集，然后挑选出和最大的。由于我们选出了所有的子集，那么时间复杂度就是 $$O(2^N)$$ ， 毫无疑问会超时。这里我们使用回溯法找子集，如果不清楚回溯法，可以参考我之前的题解，很多题目都用到了，比如[78.subsets](https://github.com/azl397985856/leetcode/blob/master/problems/78.subsets.md)。 更多回溯题目，可以访问上方链接查看（可以使用一套模板搞定）： @@ -90,7 +90,7 @@ class Solution: - 如果 mod 为 1，我们可以减去 one 数组中最小的一个（如果有的话），或者减去两个 two 数组中最小的（如果有的话），究竟减去谁取决谁更小。 - 如果 mod 为 2，我们可以减去 two 数组中最小的一个（如果有的话），或者减去两个 one 数组中最小的（如果有的话），究竟减去谁取决谁更小。 -由于我们需要取 one 和 two 中最小的一个或者两个，因此对数组 one 和 two 进行排序是可行的，如果基于排序的话，时间复杂度大致为 $O(NlogN)$，这种算法可以通过。 +由于我们需要取 one 和 two 中最小的一个或者两个，因此对数组 one 和 two 进行排序是可行的，如果基于排序的话，时间复杂度大致为 $$O(NlogN)$$，这种算法可以通过。 以题目中的例 1 为例： @@ -243,8 +243,8 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(N)$ -- 空间复杂度：$O(1)$ +- 时间复杂度：$$O(N)$$ +- 空间复杂度：$$O(1)$$ ## 关键点解析 diff --git a/problems/128.longest-consecutive-sequence.md b/problems/128.longest-consecutive-sequence.md index 834fe26c7..778ce17e9 100644 --- a/problems/128.longest-consecutive-sequence.md +++ b/problems/128.longest-consecutive-sequence.md @@ -96,8 +96,8 @@ var longestConsecutive = function(nums) { **复杂度分析** -- 时间复杂度：$O(N)$ -- 空间复杂度：$O(N)$ +- 时间复杂度：$$O(N)$$ +- 空间复杂度：$$O(N)$$ 大家对此有何看法，欢迎给我留言，我有时间都会一一查看回答。更多算法套路可以访问我的 LeetCode 题解仓库：https://github.com/azl397985856/leetcode 。 目前已经 37K star 啦。 大家也可以关注我的公众号《力扣加加》带你啃下算法这块硬骨头。 diff --git a/problems/129.sum-root-to-leaf-numbers.md b/problems/129.sum-root-to-leaf-numbers.md index 548ceb617..f417bb0dc 100644 --- a/problems/129.sum-root-to-leaf-numbers.md +++ b/problems/129.sum-root-to-leaf-numbers.md @@ -244,8 +244,8 @@ class Solution **复杂度分析** -- 时间复杂度：$O(N)$ -- 空间复杂度：$O(N)$ +- 时间复杂度：$$O(N)$$ +- 空间复杂度：$$O(N)$$ ## 拓展 diff --git a/problems/1297.maximum-number-of-occurrences-of-a-substring.md b/problems/1297.maximum-number-of-occurrences-of-a-substring.md index 47ab830d7..f10570e18 100644 --- a/problems/1297.maximum-number-of-occurrences-of-a-substring.md +++ b/problems/1297.maximum-number-of-occurrences-of-a-substring.md @@ -146,8 +146,8 @@ public boolean checkNum(String substr, int maxLetters) { 其中 N 为 s 长度 -- 时间复杂度：$O(N * minSize)$ -- 空间复杂度：$O(N * minSize)$ +- 时间复杂度：$$O(N * minSize)$$ +- 空间复杂度：$$O(N * minSize)$$ ## 关键点解析 diff --git a/problems/130.surrounded-regions.md b/problems/130.surrounded-regions.md index 82240207a..52fc0c2e3 100644 --- a/problems/130.surrounded-regions.md +++ b/problems/130.surrounded-regions.md @@ -168,8 +168,8 @@ class Solution: > 解题模板是一样的 **复杂度分析** -- 时间复杂度：$O(row * col)$ -- 空间复杂度：$O(row * col)$ +- 时间复杂度：$$O(row * col)$$ +- 空间复杂度：$$O(row * col)$$ 更多题解可以访问我的LeetCode题解仓库：https://github.com/azl397985856/leetcode 。 目前已经37K star啦。 diff --git a/problems/1310.xor-queries-of-a-subarray.md b/problems/1310.xor-queries-of-a-subarray.md index 0f9e180bc..559451c56 100644 --- a/problems/1310.xor-queries-of-a-subarray.md +++ b/problems/1310.xor-queries-of-a-subarray.md @@ -166,8 +166,8 @@ public: 其中 N 为数组 arr 长度， M 为 queries 的长度。 -- 时间复杂度：$O(N * M)$ -- 空间复杂度：$O(N)$ +- 时间复杂度：$$O(N * M)$$ +- 空间复杂度：$$O(N)$$ ## 关键点解析 diff --git a/problems/1332.remove-palindromic-subsequences.md b/problems/1332.remove-palindromic-subsequences.md index 7371bd00d..f0df426d4 100644 --- a/problems/1332.remove-palindromic-subsequences.md +++ b/problems/1332.remove-palindromic-subsequences.md @@ -123,8 +123,8 @@ class Solution { ``` **复杂度分析** -- 时间复杂度：$O(N)$ -- 空间复杂度：$O(1)$ +- 时间复杂度：$$O(N)$$ +- 空间复杂度：$$O(1)$$ 更多题解可以访问我的LeetCode题解仓库：https://github.com/azl397985856/leetcode 。 目前已经37K star啦。 diff --git a/problems/1334.find-the-city-with-the-smallest-number-of-neighbors-at-a-threshold-distance.md b/problems/1334.find-the-city-with-the-smallest-number-of-neighbors-at-a-threshold-distance.md index f78487d6d..44508082b 100644 --- a/problems/1334.find-the-city-with-the-smallest-number-of-neighbors-at-a-threshold-distance.md +++ b/problems/1334.find-the-city-with-the-smallest-number-of-neighbors-at-a-threshold-distance.md @@ -82,7 +82,7 @@ edges[i].length == 3 3. 统计每个城镇，其满足条件的城镇有多少个 4. 我们找出最少的即可 -Floyd-Warshall 算法的时间复杂度和空间复杂度都是$O(N^3)$, 而空间复杂度可以优化到$O(N^2)$。Floyd-Warshall 的基本思想是对于每两个点之间的最小距离，要么经过中间节点 k，要么不经过，我们取两者的最小值，这是一种动态规划思想，详细的解法可以参考[Floyd-Warshall 算法(wikipedia)](https://zh.wikipedia.org/wiki/Floyd-Warshall%E7%AE%97%E6%B3%95) +Floyd-Warshall 算法的时间复杂度和空间复杂度都是$$O(N^3)$$, 而空间复杂度可以优化到$$O(N^2)$$。Floyd-Warshall 的基本思想是对于每两个点之间的最小距离，要么经过中间节点 k，要么不经过，我们取两者的最小值，这是一种动态规划思想，详细的解法可以参考[Floyd-Warshall 算法(wikipedia)](https://zh.wikipedia.org/wiki/Floyd-Warshall%E7%AE%97%E6%B3%95) ## 代码 @@ -123,8 +123,8 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(N^3)$ -- 空间复杂度：$O(N^2)$ +- 时间复杂度：$$O(N^3)$$ +- 空间复杂度：$$O(N^2)$$ ## 关键点解析 diff --git a/problems/136.single-number.md b/problems/136.single-number.md index 6cefeadaf..96a7d6717 100644 --- a/problems/136.single-number.md +++ b/problems/136.single-number.md @@ -136,8 +136,8 @@ class Solution: return single_number ``` **复杂度分析** -- 时间复杂度：$O(N)$ -- 空间复杂度：$O(1)$ +- 时间复杂度：$$O(N)$$ +- 空间复杂度：$$O(1)$$ ## 延伸 diff --git a/problems/1371.find-the-longest-substring-containing-vowels-in-even-counts.en.md b/problems/1371.find-the-longest-substring-containing-vowels-in-even-counts.en.md index 479e3ca43..33bfe3f2c 100644 --- a/problems/1371.find-the-longest-substring-containing-vowels-in-even-counts.en.md +++ b/problems/1371.find-the-longest-substring-containing-vowels-in-even-counts.en.md @@ -87,8 +87,8 @@ var findTheLongestSubstring = function (s) { ### Complexity Analysis -- Time complexity: $O(n^3)$. Considering every substring takes $O(n^2)$ time. For each of the subarray we calculate the numbers of vowels taking $O(n^2)$ time in the worst case, taking a total of $O(n^3)$ time. -- Space complexity: $O(1)$. +- Time complexity: $$O(n^3)$$. Considering every substring takes $$O(n^2)$$ time. For each of the subarray we calculate the numbers of vowels taking $$O(n^2)$$ time in the worst case, taking a total of $$O(n^3)$$ time. +- Space complexity: $$O(1)$$. ## Approach2: Prefix Sum + Pruning @@ -98,7 +98,7 @@ Notice that in the last approach there is a step for `counting the numbers of vo For problems involving consecutive numbers, we can consider using prefix sum to get to a better solution. -By using this strategy we trade space complexity for time complexity, reducing the time complexity to $O(n ^ 2)$, while increasing the space complexity to $O(n)$, which is a worthwhile trade-off in many situations. +By using this strategy we trade space complexity for time complexity, reducing the time complexity to $$O(n ^ 2)$$, while increasing the space complexity to $$O(n)$$, which is a worthwhile trade-off in many situations. ### Code(`Python3/Java/JavaScript`) @@ -255,14 +255,14 @@ var findTheLongestSubstring = function (s) { ### Complexity Analysis -- Time complexity: $O(n^2)$. -- Space complexity: $O(n)$. +- Time complexity: $$O(n^2)$$. +- Space complexity: $$O(n)$$. ## Approach 3: Prefix Sum + State Compression ### Algorithm -In approach 2 we reduce the time complexity by trading space (prefix) for time. However, the time complexity of $O(n^2)$ is still a lot. Is there still room for optimization? +In approach 2 we reduce the time complexity by trading space (prefix) for time. However, the time complexity of $$O(n^2)$$ is still a lot. Is there still room for optimization? All we care about is parity. We don't need to count the specific number of occurrences of each vowel. Instead, we can use two states `odd or even`. Since we only need to deal with two states, we can consider using bit operation. @@ -346,8 +346,8 @@ var findTheLongestSubstring = function (s) { ### Complexity Analysis -- Time complexity: $O(n)$. -- Space complexity: $O(n)$. +- Time complexity: $$O(n)$$. +- Space complexity: $$O(n)$$. ## Keypoints diff --git a/problems/1371.find-the-longest-substring-containing-vowels-in-even-counts.md b/problems/1371.find-the-longest-substring-containing-vowels-in-even-counts.md index 316dcaccb..1e7db6c16 100644 --- a/problems/1371.find-the-longest-substring-containing-vowels-in-even-counts.md +++ b/problems/1371.find-the-longest-substring-containing-vowels-in-even-counts.md @@ -77,8 +77,8 @@ class Solution: **复杂度分析** -- 时间复杂度：双层循环找出所有子串的复杂度是$O(n^2)$，统计元音个数复杂度也是$O(n)$，因此这种算法的时间复杂度为$O(n^3)$。 -- 空间复杂度：$O(1)$ +- 时间复杂度：双层循环找出所有子串的复杂度是$$O(n^2)$$，统计元音个数复杂度也是$$O(n)$$，因此这种算法的时间复杂度为$$O(n^3)$$。 +- 空间复杂度：$$O(1)$$ ## 前缀和 + 剪枝 @@ -88,7 +88,7 @@ class Solution: 对于这种连续的数字问题，这里我们考虑使用[前缀和](https://oi-wiki.org/basic/prefix-sum/)来优化。 -经过这种空间换时间的策略之后，我们的时间复杂度会降低到$O(n ^ 2)$，但是相应空间复杂度会上升到$O(n)$，这种取舍在很多情况下是值得的。 +经过这种空间换时间的策略之后，我们的时间复杂度会降低到$$O(n ^ 2)$$，但是相应空间复杂度会上升到$$O(n)$$，这种取舍在很多情况下是值得的。 ### 代码 @@ -201,8 +201,8 @@ class Solution { **复杂度分析** -- 时间复杂度：$O(n^2)$。 -- 空间复杂度：$O(n)$ +- 时间复杂度：$$O(n^2)$$。 +- 空间复杂度：$$O(n)$$ ## 前缀和 + 状态压缩 @@ -261,8 +261,8 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(n)$。 -- 空间复杂度：$O(n)$ +- 时间复杂度：$$O(n)$$。 +- 空间复杂度：$$O(n)$$ ## 关键点解析 diff --git a/problems/1381.design-a-stack-with-increment-operation.md b/problems/1381.design-a-stack-with-increment-operation.md index 61470f629..5437867b8 100644 --- a/problems/1381.design-a-stack-with-increment-operation.md +++ b/problems/1381.design-a-stack-with-increment-operation.md @@ -52,11 +52,11 @@ customStack.pop(); // 返回 -1 --> 栈为空，返回 -1 - 栈 - 前缀和 -## increment 时间复杂度为 $O(k)$ 的方法 +## increment 时间复杂度为 $$O(k)$$ 的方法 ### 思路 -首先我们来看一种非常符合直觉的方法，然而这种方法并不好，increment 操作需要的时间复杂度为 $O(k)$。 +首先我们来看一种非常符合直觉的方法，然而这种方法并不好，increment 操作需要的时间复杂度为 $$O(k)$$。 `push`和 `pop` 就是普通的栈操作。 唯一要注意的是边界条件，这个已经在题目中指明了，具体来说就是： @@ -95,8 +95,8 @@ class CustomStack: **复杂度分析** -- 时间复杂度：push 和 pop 操作的时间复杂度为 $O(1)$（讲义有提到），而 increment 操作的时间复杂度为 $O(min(k, cnt))$ -- 空间复杂度：$O(1)$ +- 时间复杂度：push 和 pop 操作的时间复杂度为 $$O(1)$$（讲义有提到），而 increment 操作的时间复杂度为 $$O(min(k, cnt))$$ +- 空间复杂度：$$O(1)$$ ## 前缀和 @@ -164,14 +164,14 @@ class CustomStack: **复杂度分析** -- 时间复杂度：全部都是 $O(1)$ -- 空间复杂度：我们维护了一个大小为 maxSize 的数组，因此平均到每次的空间复杂度为 $O(maxSize / N)$，其中 N 为操作数。 +- 时间复杂度：全部都是 $$O(1)$$ +- 空间复杂度：我们维护了一个大小为 maxSize 的数组，因此平均到每次的空间复杂度为 $$O(maxSize / N)$$，其中 N 为操作数。 ## 优化的前缀和 ### 思路 -上面的思路无论如何，我们都需要维护一个大小为 $O(maxSize)$ 的数组 incremental 。而由于栈只能在栈顶进行操作，因此这实际上可以稍微优化一点，即维护一个大小为当前栈长度的 incrementals，而不是 $O(maxSize)$ 。 +上面的思路无论如何，我们都需要维护一个大小为 $$O(maxSize)$$ 的数组 incremental 。而由于栈只能在栈顶进行操作，因此这实际上可以稍微优化一点，即维护一个大小为当前栈长度的 incrementals，而不是 $$O(maxSize)$$ 。 每次栈 push 的时候，incrementals 也 push 一个 0。每次栈 pop 的时候， incrementals 也 pop，这样就可以了。 @@ -327,8 +327,8 @@ class customStack **复杂度分析** -- 时间复杂度：全部都是 $O(1)$ -- 空间复杂度：我们维护了一个大小为 cnt 的数组，因此平均到每次的空间复杂度为 $O(cnt / N)$，其中 N 为操作数，cnt 为操作过程中的栈的最大长度（小于等于 maxSize）。 +- 时间复杂度：全部都是 $$O(1)$$ +- 空间复杂度：我们维护了一个大小为 cnt 的数组，因此平均到每次的空间复杂度为 $$O(cnt / N)$$，其中 N 为操作数，cnt 为操作过程中的栈的最大长度（小于等于 maxSize）。 可以看出优化的解法在 maxSize 非常大的时候是很有意义的。 diff --git a/problems/139.word-break.md b/problems/139.word-break.md index 0601050d4..8b63bdc8a 100644 --- a/problems/139.word-break.md +++ b/problems/139.word-break.md @@ -100,8 +100,8 @@ var wordBreak = function (s, wordDict) { **复杂度分析** -- 时间复杂度：$O(N ^ 2)$ -- 空间复杂度：$O(N)$ +- 时间复杂度：$$O(N ^ 2)$$ +- 空间复杂度：$$O(N)$$ 大家对此有何看法，欢迎给我留言，我有时间都会一一查看回答。更多算法套路可以访问我的 LeetCode 题解仓库：https://github.com/azl397985856/leetcode 。 目前已经 37K star 啦。 大家也可以关注我的公众号《力扣加加》带你啃下算法这块硬骨头。 diff --git a/problems/140.word-break-ii.md b/problems/140.word-break-ii.md index 9da74dc26..aeb43a204 100644 --- a/problems/140.word-break-ii.md +++ b/problems/140.word-break-ii.md @@ -83,8 +83,8 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(2^N)$ -- 空间复杂度：$O(2^N)$ +- 时间复杂度：$$O(2^N)$$ +- 空间复杂度：$$O(2^N)$$ ## 笛卡尔积优化 @@ -130,7 +130,7 @@ class Solution: 我们也不难看出， 当我们 DFS 探到 worldhi 的时候，其可能的结果就是探测到的单词和上一步的所有可能的笛卡尔积。 -因此一种优化思路就是将回溯的结果通过返回值的形式传递给父级函数，父级函数通过笛卡尔积构造 ans 即可。而这实际上和上面的解法复杂度是一样的， 但是经过这样的改造，我们就可以使用记忆化技巧减少重复计算了。因此理论上， 我们不存在**回溯**过程了。 因此时间复杂度就是所有的组合，即一次遍历以及内部的笛卡尔积，也就是 $O(N ^ 2)$。 +因此一种优化思路就是将回溯的结果通过返回值的形式传递给父级函数，父级函数通过笛卡尔积构造 ans 即可。而这实际上和上面的解法复杂度是一样的， 但是经过这样的改造，我们就可以使用记忆化技巧减少重复计算了。因此理论上， 我们不存在**回溯**过程了。 因此时间复杂度就是所有的组合，即一次遍历以及内部的笛卡尔积，也就是 $$O(N ^ 2)$$。 ### 代码 @@ -160,8 +160,8 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(N^2)$ -- 空间复杂度：$O(N^2)$ +- 时间复杂度：$$O(N^2)$$ +- 空间复杂度：$$O(N^2)$$ 这种记忆化递归的方式和 DP 思想一模一样， 大家可以将其改造为 DP，这个留给大家来完成。 diff --git a/problems/142.Linked-List-Cycle-II.md b/problems/142.Linked-List-Cycle-II.md index 8a0d5f286..9e16b9a55 100644 --- a/problems/142.Linked-List-Cycle-II.md +++ b/problems/142.Linked-List-Cycle-II.md @@ -60,8 +60,8 @@ return null; **复杂度分析** -- 时间复杂度：$O(N)$ -- 空间复杂度：$O(N)$ +- 时间复杂度：$$O(N)$$ +- 空间复杂度：$$O(N)$$ ## 快慢指针法 @@ -211,5 +211,5 @@ class Solution **复杂度分析** -- 时间复杂度：$O(N)$ -- 空间复杂度：$O(1)$ +- 时间复杂度：$$O(N)$$ +- 空间复杂度：$$O(1)$$ diff --git a/problems/144.binary-tree-preorder-traversal.md b/problems/144.binary-tree-preorder-traversal.md index 7f41082b3..952e43363 100644 --- a/problems/144.binary-tree-preorder-traversal.md +++ b/problems/144.binary-tree-preorder-traversal.md @@ -134,8 +134,8 @@ public: ``` **复杂度分析** -- 时间复杂度：$O(N)$ -- 空间复杂度：$O(N)$ +- 时间复杂度：$$O(N)$$ +- 空间复杂度：$$O(N)$$ ## 相关专题 diff --git a/problems/1449.form-largest-integer-with-digits-that-add-up-to-target.md b/problems/1449.form-largest-integer-with-digits-that-add-up-to-target.md index c23b18efc..174659a49 100644 --- a/problems/1449.form-largest-integer-with-digits-that-add-up-to-target.md +++ b/problems/1449.form-largest-integer-with-digits-that-add-up-to-target.md @@ -174,8 +174,8 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(target))$ -- 空间复杂度：$O(target)$ +- 时间复杂度：$$O(target))$$ +- 空间复杂度：$$O(target)$$ ## 扩展 diff --git a/problems/145.binary-tree-postorder-traversal.md b/problems/145.binary-tree-postorder-traversal.md index 25ebd5ea9..382e0175f 100644 --- a/problems/145.binary-tree-postorder-traversal.md +++ b/problems/145.binary-tree-postorder-traversal.md @@ -115,8 +115,8 @@ var postorderTraversal = function(root) { **复杂度分析** -- 时间复杂度：$O(N)$ -- 空间复杂度：$O(N)$ +- 时间复杂度：$$O(N)$$ +- 空间复杂度：$$O(N)$$ ## 相关专题 diff --git a/problems/146.lru-cache.md b/problems/146.lru-cache.md index ca7ee862b..6ef5f4b36 100644 --- a/problems/146.lru-cache.md +++ b/problems/146.lru-cache.md @@ -375,5 +375,5 @@ class DoubleList **复杂度分析** -- 时间复杂度：$O(1)$ -- 空间复杂度：$O(n)$ n为容量的大小 +- 时间复杂度：$$O(1)$$ +- 空间复杂度：$$O(n)$$ n为容量的大小 diff --git a/problems/147.insertion-sort-list.md b/problems/147.insertion-sort-list.md index 7c6bf1964..a3aaca09f 100644 --- a/problems/147.insertion-sort-list.md +++ b/problems/147.insertion-sort-list.md @@ -211,7 +211,7 @@ var insertionSortList = function (head) { **复杂度分析** -- 时间复杂度：$O(N^2)$，其中 N 为链表长度。 -- 空间复杂度：$O(1)$。 +- 时间复杂度：$$O(N^2)$$，其中 N 为链表长度。 +- 空间复杂度：$$O(1)$$。 大家对此有何看法，欢迎给我留言，我有时间都会一一查看回答。更多算法套路可以访问我的 LeetCode 题解仓库：https://github.com/azl397985856/leetcode 。 目前已经 38K star 啦。大家也可以关注我的公众号《力扣加加》带你啃下算法这块硬骨头。 diff --git a/problems/15.3sum.md b/problems/15.3sum.md index 4b7879c04..8761eb983 100644 --- a/problems/15.3sum.md +++ b/problems/15.3sum.md @@ -99,7 +99,7 @@ var threeSum = function (nums) { ``` **复杂度分析** -- 时间复杂度：$O(N^2)$ +- 时间复杂度：$$O(N^2)$$ - 空间复杂度：取决于排序算法的空间消耗 大家对此有何看法，欢迎给我留言，我有时间都会一一查看回答。更多算法套路可以访问我的 LeetCode 题解仓库：https://github.com/azl397985856/leetcode 。 目前已经 37K star 啦。 diff --git a/problems/152.maximum-product-subarray.md b/problems/152.maximum-product-subarray.md index 54b14814c..daafa2c60 100644 --- a/problems/152.maximum-product-subarray.md +++ b/problems/152.maximum-product-subarray.md @@ -95,8 +95,8 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(N)$ -- 空间复杂度：$O(N)$ +- 时间复杂度：$$O(N)$$ +- 空间复杂度：$$O(N)$$ 当我们知道动态转移方程的时候，其实应该发现了。我们的dp[i] 只和 dp[i - 1]有关，这是一个空间优化的信号，告诉我们`可以借助两个额外变量记录即可`。 @@ -144,8 +144,8 @@ var maxProduct = function(nums) { **复杂度分析** -- 时间复杂度：$O(N)$ -- 空间复杂度：$O(1)$ +- 时间复杂度：$$O(N)$$ +- 空间复杂度：$$O(1)$$ 更多题解可以访问我的LeetCode题解仓库：https://github.com/azl397985856/leetcode 。 目前已经30K star啦。 diff --git a/problems/1558.minimum-numbers-of-function-calls-to-make-target-array.md b/problems/1558.minimum-numbers-of-function-calls-to-make-target-array.md index 18901d69e..546540ac1 100644 --- a/problems/1558.minimum-numbers-of-function-calls-to-make-target-array.md +++ b/problems/1558.minimum-numbers-of-function-calls-to-make-target-array.md @@ -119,8 +119,8 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(N * (max_multi + add))$，其中 N 为 nums 的长度。 -- 空间复杂度：$O(1)$ +- 时间复杂度：$$O(N * (max_multi + add))$$，其中 N 为 nums 的长度。 +- 空间复杂度：$$O(1)$$ 更多题解可以访问我的 LeetCode 题解仓库：https://github.com/azl397985856/leetcode 。 目前已经 37K star 啦。 diff --git a/problems/160.Intersection-of-Two-Linked-Lists.md b/problems/160.Intersection-of-Two-Linked-Lists.md index 19e107555..719a82ea2 100644 --- a/problems/160.Intersection-of-Two-Linked-Lists.md +++ b/problems/160.Intersection-of-Two-Linked-Lists.md @@ -57,8 +57,8 @@ return null; **复杂度分析** -- 时间复杂度：$O(N)$ -- 空间复杂度：$O(N)$ +- 时间复杂度：$$O(N)$$ +- 空间复杂度：$$O(N)$$ ## 解法二：双指针 @@ -186,5 +186,5 @@ class Solution **复杂度分析** -- 时间复杂度：$O(N)$ -- 空间复杂度：$O(1)$ +- 时间复杂度：$$O(N)$$ +- 空间复杂度：$$O(1)$$ diff --git a/problems/1631.path-with-minimum-effort.md b/problems/1631.path-with-minimum-effort.md index 3f7903710..25754a9ca 100644 --- a/problems/1631.path-with-minimum-effort.md +++ b/problems/1631.path-with-minimum-effort.md @@ -85,7 +85,7 @@ columns == heights[i].length 直到找到第一个不可以的，我们返回前一个即可。 -关于可不可以，我们可以使用 DFS 来做，由于只需要找到一条满足条件的，或者找到一个不满足的提前退出，因此最坏的情况是一直符合，并走到终点，这种情况下时间复杂度是 $(m \times n)$，因此总的时间复杂度是 $O(m \times n \times 10**6)$。 +关于可不可以，我们可以使用 DFS 来做，由于只需要找到一条满足条件的，或者找到一个不满足的提前退出，因此最坏的情况是一直符合，并走到终点，这种情况下时间复杂度是 $$(m \times n)$$，因此总的时间复杂度是 $$O(m \times n \times 10**6)$$。 实际上，上面的不断发问的过程不就是一个连续的递增序列么？ 我们的目标不就是在一个连续递增序列找指定值么？于是二分法就不难想到。 @@ -137,8 +137,8 @@ class Solution: m 为 矩阵的高度， n 为矩阵的长度。 -- 时间复杂度：$O(4 \times m \times n \times log_2 10^6)$，其中 $log_2 10^6$ 为二分的次数， $4 \times m \times n$ 为每次 dfs 的时间。 -- 空间复杂度：$O(m \times n)$，不管是递归的栈开销还是 visited 的开销都是 $O(m \times n)$。 +- 时间复杂度：$$O(4 \times m \times n \times log_2 10^6)$$，其中 $log_2 10^6$ 为二分的次数， $4 \times m \times n$ 为每次 dfs 的时间。 +- 空间复杂度：$$O(m \times n)$$，不管是递归的栈开销还是 visited 的开销都是 $$O(m \times n)$$。 ## 相关问题 diff --git a/problems/167.two-sum-ii-input-array-is-sorted.md b/problems/167.two-sum-ii-input-array-is-sorted.md index a27185681..83d283e58 100644 --- a/problems/167.two-sum-ii-input-array-is-sorted.md +++ b/problems/167.two-sum-ii-input-array-is-sorted.md @@ -161,8 +161,8 @@ class Solution: ``` **复杂度分析** -- 时间复杂度：$O(N)$ -- 空间复杂度：$O(1)$ +- 时间复杂度：$$O(N)$$ +- 空间复杂度：$$O(1)$$ 更多题解可以访问我的LeetCode题解仓库：https://github.com/azl397985856/leetcode 。 目前已经30K star啦。 diff --git a/problems/169.majority-element.md b/problems/169.majority-element.md index b1ea9fabf..9ab47a69e 100644 --- a/problems/169.majority-element.md +++ b/problems/169.majority-element.md @@ -90,8 +90,8 @@ class Solution: ``` **复杂度分析** -- 时间复杂度：$O(N)$，其中N为数组长度 -- 空间复杂度：$O(1)$ +- 时间复杂度：$$O(N)$$，其中N为数组长度 +- 空间复杂度：$$O(1)$$ 更多题解可以访问我的LeetCode题解仓库：https://github.com/azl397985856/leetcode 。 目前已经37K star啦。 diff --git a/problems/172.factorial-trailing-zeroes.md b/problems/172.factorial-trailing-zeroes.md index 95c2c0071..4a2742528 100644 --- a/problems/172.factorial-trailing-zeroes.md +++ b/problems/172.factorial-trailing-zeroes.md @@ -142,8 +142,8 @@ class Solution { **复杂度分析** -- 时间复杂度：$O(logN)$ -- 空间复杂度：$O(1)$ +- 时间复杂度：$$O(logN)$$ +- 空间复杂度：$$O(1)$$ 更多题解可以访问我的LeetCode题解仓库：https://github.com/azl397985856/leetcode 。 目前已经37K star啦。 diff --git a/problems/19.removeNthNodeFromEndofList.md b/problems/19.removeNthNodeFromEndofList.md index 2b2014086..9b12885ac 100644 --- a/problems/19.removeNthNodeFromEndofList.md +++ b/problems/19.removeNthNodeFromEndofList.md @@ -139,8 +139,8 @@ class Solution { ``` **复杂度分析** -- 时间复杂度：$O(N)$ -- 空间复杂度：$O(1)$ +- 时间复杂度：$$O(N)$$ +- 空间复杂度：$$O(1)$$ 大家对此有何看法，欢迎给我留言，我有时间都会一一查看回答。更多算法套路可以访问我的 LeetCode 题解仓库：https://github.com/azl397985856/leetcode 。 目前已经 37K star 啦。 大家也可以关注我的公众号《力扣加加》带你啃下算法这块硬骨头。 diff --git a/problems/190.reverse-bits.md b/problems/190.reverse-bits.md index b2eddb89e..a9bda4f3c 100644 --- a/problems/190.reverse-bits.md +++ b/problems/190.reverse-bits.md @@ -127,8 +127,8 @@ class Solution: ``` **复杂度分析** -- 时间复杂度：$O(logN)$ -- 空间复杂度：$O(1)$ +- 时间复杂度：$$O(logN)$$ +- 空间复杂度：$$O(1)$$ ## 拓展 不使用迭代也可以完成相同的操作： diff --git a/problems/191.number-of-1-bits.md b/problems/191.number-of-1-bits.md index f8356f547..7c5ef86d0 100644 --- a/problems/191.number-of-1-bits.md +++ b/problems/191.number-of-1-bits.md @@ -127,8 +127,8 @@ class Solution(object): ``` **复杂度分析** -- 时间复杂度：$O(logN)$ -- 空间复杂度：$O(N)$ +- 时间复杂度：$$O(logN)$$ +- 空间复杂度：$$O(N)$$ ## 扩展 可以使用位操作来达到目的。例如8位的整数21: diff --git a/problems/198.house-robber.md b/problems/198.house-robber.md index 9764553f7..12a17cbca 100644 --- a/problems/198.house-robber.md +++ b/problems/198.house-robber.md @@ -165,8 +165,8 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(N)$ -- 空间复杂度：$O(1)$ +- 时间复杂度：$$O(N)$$ +- 空间复杂度：$$O(1)$$ ## 相关题目 diff --git a/problems/2.add-two-numbers.md b/problems/2.add-two-numbers.md index fda8dae34..49f7a9024 100644 --- a/problems/2.add-two-numbers.md +++ b/problems/2.add-two-numbers.md @@ -219,8 +219,8 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(N)$ -- 空间复杂度：$O(1)$ +- 时间复杂度：$$O(N)$$ +- 空间复杂度：$$O(1)$$ ## 拓展 @@ -282,8 +282,8 @@ private: ``` **复杂度分析** -- 时间复杂度：$O(N)$ -- 空间复杂度：$O(N)$，其中 N 的空间是调用栈的开销。 +- 时间复杂度：$$O(N)$$ +- 空间复杂度：$$O(N)$$，其中 N 的空间是调用栈的开销。 大家对此有何看法，欢迎给我留言，我有时间都会一一查看回答。更多算法套路可以访问我的 LeetCode 题解仓库：https://github.com/azl397985856/leetcode 。 目前已经 37K star 啦。 大家也可以关注我的公众号《力扣加加》带你啃下算法这块硬骨头。 diff --git a/problems/20.valid-parentheses.md b/problems/20.valid-parentheses.md index da5d2c22e..93d59dd62 100644 --- a/problems/20.valid-parentheses.md +++ b/problems/20.valid-parentheses.md @@ -152,8 +152,8 @@ Python Code: **复杂度分析** -- 时间复杂度：$O(N)$ -- 空间复杂度：$O(N)$ +- 时间复杂度：$$O(N)$$ +- 空间复杂度：$$O(N)$$ ## O(1) 空间 @@ -161,7 +161,7 @@ Python Code: 基本思路是修改参数，将参数作为我们的栈。 随着我们不断遍历， s 慢慢变成了一个栈。 -因此 Python，Java，JS 等**字符串不可变**的语言无法使用此方法达到 $O(1)$。 +因此 Python，Java，JS 等**字符串不可变**的语言无法使用此方法达到 $$O(1)$$。 具体参考： [No stack O(1) space complexity O(n) time complexity solution in C++](https://leetcode.com/problems/valid-parentheses/discuss/9478/No-stack-O(1)-space-complexity-O(n)-time-complexity-solution-in-C++/244061) @@ -197,8 +197,8 @@ public: **复杂度分析** -- 时间复杂度：$O(N)$ -- 空间复杂度：$O(1)$ +- 时间复杂度：$$O(N)$$ +- 空间复杂度：$$O(1)$$ ## 正则匹配 diff --git a/problems/200.number-of-islands.md b/problems/200.number-of-islands.md index c53906e98..16c4f1ff8 100644 --- a/problems/200.number-of-islands.md +++ b/problems/200.number-of-islands.md @@ -216,8 +216,8 @@ class Solution: ``` **复杂度分析** -- 时间复杂度：$O(m * n)$ -- 空间复杂度：$O(m * n)$ +- 时间复杂度：$$O(m * n)$$ +- 空间复杂度：$$O(m * n)$$ 欢迎关注我的公众号《脑洞前端》获取更多更新鲜的LeetCode题解 diff --git a/problems/201.bitwise-and-of-numbers-range.md b/problems/201.bitwise-and-of-numbers-range.md index 7ba730d14..ed7abb305 100644 --- a/problems/201.bitwise-and-of-numbers-range.md +++ b/problems/201.bitwise-and-of-numbers-range.md @@ -131,7 +131,7 @@ class Solution: **复杂度分析** - - 时间复杂度：最坏的情况我们需要循环N次，最好的情况是一次都不需要， 因此时间复杂度取决于我们移动的位数，具体移动的次数取决于我们的输入，平均来说时间复杂度为 $O(N)$，其中N为M和N的二进制表示的位数。 - - 空间复杂度：$O(1)$ + - 时间复杂度：最坏的情况我们需要循环N次，最好的情况是一次都不需要， 因此时间复杂度取决于我们移动的位数，具体移动的次数取决于我们的输入，平均来说时间复杂度为 $$O(N)$$，其中N为M和N的二进制表示的位数。 + - 空间复杂度：$$O(1)$$ diff --git a/problems/203.remove-linked-list-elements.md b/problems/203.remove-linked-list-elements.md index 580400260..01fa7c816 100644 --- a/problems/203.remove-linked-list-elements.md +++ b/problems/203.remove-linked-list-elements.md @@ -112,8 +112,8 @@ class Solution: ``` **复杂度分析** -- 时间复杂度：$O(N)$ -- 空间复杂度：$O(1)$ +- 时间复杂度：$$O(N)$$ +- 空间复杂度：$$O(1)$$ 更多题解可以访问我的LeetCode题解仓库：https://github.com/azl397985856/leetcode 。 目前已经37K star啦。 diff --git a/problems/206.reverse-linked-list.md b/problems/206.reverse-linked-list.md index e19280bf6..035442245 100644 --- a/problems/206.reverse-linked-list.md +++ b/problems/206.reverse-linked-list.md @@ -165,8 +165,8 @@ class Solution { ``` **复杂度分析** -- 时间复杂度：$O(N)$ -- 空间复杂度：$O(1)$ +- 时间复杂度：$$O(N)$$ +- 空间复杂度：$$O(1)$$ ## 拓展 @@ -263,8 +263,8 @@ class Solution: ``` **复杂度分析** -- 时间复杂度：$O(N)$ -- 空间复杂度：$O(N)$ +- 时间复杂度：$$O(N)$$ +- 空间复杂度：$$O(N)$$ ## 相关题目 diff --git a/problems/209.minimum-size-subarray-sum.md b/problems/209.minimum-size-subarray-sum.md index 6d85b6075..7e39a159e 100644 --- a/problems/209.minimum-size-subarray-sum.md +++ b/problems/209.minimum-size-subarray-sum.md @@ -128,8 +128,8 @@ public: ``` **复杂度分析** -- 时间复杂度：$O(N)$，其中 N 为数组大小。 -- 空间复杂度：$O(1)$ +- 时间复杂度：$$O(N)$$，其中 N 为数组大小。 +- 空间复杂度：$$O(1)$$ 欢迎关注我的公众号《脑洞前端》获取更多更新鲜的LeetCode题解 diff --git a/problems/21.merge-two-sorted-lists.md b/problems/21.merge-two-sorted-lists.md index d283edc1f..232c8bbf1 100644 --- a/problems/21.merge-two-sorted-lists.md +++ b/problems/21.merge-two-sorted-lists.md @@ -80,8 +80,8 @@ const mergeTwoLists = function (l1, l2) { M、N 是两条链表 l1、l2 的长度 -- 时间复杂度：$O(M+N)$ -- 空间复杂度：$O(M+N)$ +- 时间复杂度：$$O(M+N)$$ +- 空间复杂度：$$O(M+N)$$ ## 扩展 diff --git a/problems/211.add-and-search-word-data-structure-design.md b/problems/211.add-and-search-word-data-structure-design.md index 81a0bc46c..3350b3803 100644 --- a/problems/211.add-and-search-word-data-structure-design.md +++ b/problems/211.add-and-search-word-data-structure-design.md @@ -57,7 +57,7 @@ search 中的 word 由 '.' 或小写英文字母组成 接下来我们考虑特殊字符“.”，其实也不难，只不过 search 的时候，判断如果是“.”, 我们认为匹配到了，继续往后匹配即可。 -上面的代码复杂度会比较高，我们考虑优化。如果你熟悉前缀树的话，应该注意到这可以使用前缀树来进行优化。前缀树优化之后每次查找复杂度是$O(h)$, 其中 h 是前缀树深度，也就是最长的字符串长度。 +上面的代码复杂度会比较高，我们考虑优化。如果你熟悉前缀树的话，应该注意到这可以使用前缀树来进行优化。前缀树优化之后每次查找复杂度是$$O(h)$$, 其中 h 是前缀树深度，也就是最长的字符串长度。 关于前缀树，LeetCode 有很多题目。有的是直接考察，让你实现一个前缀树，有的是间接考察，比如本题。前缀树代码见下方，大家之后可以直接当成前缀树的解题模板使用。 diff --git a/problems/212.word-search-ii.md b/problems/212.word-search-ii.md index 532101fe3..a58b68287 100644 --- a/problems/212.word-search-ii.md +++ b/problems/212.word-search-ii.md @@ -60,7 +60,7 @@ words = ["oath","pea","eat","rain"] and board = 而返回结果是需要去重的。出于简单考虑，我们使用集合（set），最后返回的时候重新转化为 list。 -刚才我提到了一个关键词“前缀”，我们考虑使用前缀树来优化。使得复杂度降低为$O(h)$, 其中 h 是前缀树深度，也就是最长的字符串长度。 +刚才我提到了一个关键词“前缀”，我们考虑使用前缀树来优化。使得复杂度降低为$$O(h)$$, 其中 h 是前缀树深度，也就是最长的字符串长度。 ![](https://tva1.sinaimg.cn/large/007S8ZIlly1ghlua4m3ofj30mz0gqdhc.jpg) diff --git a/problems/219.contains-duplicate-ii.md b/problems/219.contains-duplicate-ii.md index 5c570cd95..6b4b9d976 100644 --- a/problems/219.contains-duplicate-ii.md +++ b/problems/219.contains-duplicate-ii.md @@ -127,8 +127,8 @@ class Solution { ``` **复杂度分析** -- 时间复杂度：$O(N)$ -- 空间复杂度：$O(N)$ +- 时间复杂度：$$O(N)$$ +- 空间复杂度：$$O(N)$$ 更多题解可以访问我的LeetCode题解仓库：https://github.com/azl397985856/leetcode 。 目前已经37K star啦。 diff --git a/problems/221.maximal-square.md b/problems/221.maximal-square.md index e518db61f..a123db256 100644 --- a/problems/221.maximal-square.md +++ b/problems/221.maximal-square.md @@ -136,5 +136,5 @@ var maximalSquare = function(matrix) { ***复杂度分析*** -- 时间复杂度：$O(M * N)$，其中M为行数，N为列数。 -- 空间复杂度：$O(M * N)$，其中M为行数，N为列数。 +- 时间复杂度：$$O(M * N)$$，其中M为行数，N为列数。 +- 空间复杂度：$$O(M * N)$$，其中M为行数，N为列数。 diff --git a/problems/226.invert-binary-tree.md b/problems/226.invert-binary-tree.md index 0671df866..95c1aa42c 100644 --- a/problems/226.invert-binary-tree.md +++ b/problems/226.invert-binary-tree.md @@ -160,8 +160,8 @@ public: **复杂度分析** -- 时间复杂度：$O(N)$ -- 空间复杂度：$O(N)$ +- 时间复杂度：$$O(N)$$ +- 空间复杂度：$$O(N)$$ 更多题解可以访问我的LeetCode题解仓库：https://github.com/azl397985856/leetcode 。 目前已经37K star啦。 diff --git a/problems/229.majority-element-ii.md b/problems/229.majority-element-ii.md index b6bd3a9ab..50a7f1b96 100644 --- a/problems/229.majority-element-ii.md +++ b/problems/229.majority-element-ii.md @@ -182,8 +182,8 @@ class Solution { ``` **复杂度分析** -- 时间复杂度：$O(N)$ -- 空间复杂度：$O(1)$ +- 时间复杂度：$$O(N)$$ +- 空间复杂度：$$O(1)$$ ## 扩展 diff --git a/problems/23.merge-k-sorted-lists.md b/problems/23.merge-k-sorted-lists.md index e5c538fc5..38d974aa5 100644 --- a/problems/23.merge-k-sorted-lists.md +++ b/problems/23.merge-k-sorted-lists.md @@ -175,8 +175,8 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(kn*logk)$ -- 空间复杂度：$O(logk)$ +- 时间复杂度：$$O(kn*logk)$$ +- 空间复杂度：$$O(logk)$$ ## 相关题目 diff --git a/problems/230.kth-smallest-element-in-a-bst.md b/problems/230.kth-smallest-element-in-a-bst.md index f6b003463..a459c3d54 100644 --- a/problems/230.kth-smallest-element-in-a-bst.md +++ b/problems/230.kth-smallest-element-in-a-bst.md @@ -192,8 +192,8 @@ var kthSmallest = function(root, k) { **复杂度分析** -- 时间复杂度：$O(N)$ -- 空间复杂度：$O(N)$ +- 时间复杂度：$$O(N)$$ +- 空间复杂度：$$O(N)$$ ## 扩展 diff --git a/problems/232.implement-queue-using-stacks.md b/problems/232.implement-queue-using-stacks.md index dc472edfb..3940eef24 100644 --- a/problems/232.implement-queue-using-stacks.md +++ b/problems/232.implement-queue-using-stacks.md @@ -302,8 +302,8 @@ func (this *MyQueue) Transfer() { **复杂度分析** -- 时间复杂度：$O(1)$ -- 空间复杂度：$O(1)$ +- 时间复杂度：$$O(1)$$ +- 空间复杂度：$$O(1)$$ ## 扩展 - 类似的题目有用队列实现栈，思路是完全一样的，大家有兴趣可以试一下。 diff --git a/problems/236.lowest-common-ancestor-of-a-binary-tree.md b/problems/236.lowest-common-ancestor-of-a-binary-tree.md index 668f5f47e..6c1bed580 100644 --- a/problems/236.lowest-common-ancestor-of-a-binary-tree.md +++ b/problems/236.lowest-common-ancestor-of-a-binary-tree.md @@ -138,8 +138,8 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(N)$ -- 空间复杂度：$O(N)$ +- 时间复杂度：$$O(N)$$ +- 空间复杂度：$$O(N)$$ ## 扩展 如果递归的结束条件改为`if (!root || root.left === p || root.right === q) return root;` 代表的是什么意思，对结果有什么样的影响？ diff --git a/problems/238.product-of-array-except-self.md b/problems/238.product-of-array-except-self.md index 933abee05..42705d143 100644 --- a/problems/238.product-of-array-except-self.md +++ b/problems/238.product-of-array-except-self.md @@ -87,8 +87,8 @@ var productExceptSelf = function(nums) { ``` ***复杂度分析*** -- 时间复杂度：$O(N)$ -- 空间复杂度：$O(N)$ +- 时间复杂度：$$O(N)$$ +- 空间复杂度：$$O(N)$$ 更多题解可以访问我的LeetCode题解仓库：https://github.com/azl397985856/leetcode 。 目前已经30K star啦。 diff --git a/problems/239.sliding-window-maximum.md b/problems/239.sliding-window-maximum.md index eb64ad970..071a093c7 100644 --- a/problems/239.sliding-window-maximum.md +++ b/problems/239.sliding-window-maximum.md @@ -162,8 +162,8 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(N)$ -- 空间复杂度：$O(N)$ +- 时间复杂度：$$O(N)$$ +- 空间复杂度：$$O(N)$$ ## 扩展 diff --git a/problems/24.swapNodesInPairs.md b/problems/24.swapNodesInPairs.md index 138992ff5..d70a5eff9 100644 --- a/problems/24.swapNodesInPairs.md +++ b/problems/24.swapNodesInPairs.md @@ -181,8 +181,8 @@ class Solution ``` **复杂度分析** -- 时间复杂度：$O(N)$ -- 空间复杂度：$O(1)$ +- 时间复杂度：$$O(N)$$ +- 空间复杂度：$$O(1)$$ 大家对此有何看法，欢迎给我留言，我有时间都会一一查看回答。更多算法套路可以访问我的 LeetCode 题解仓库：https://github.com/azl397985856/leetcode 。 目前已经 37K star 啦。 大家也可以关注我的公众号《力扣加加》带你啃下算法这块硬骨头。 diff --git a/problems/240.search-a-2-d-matrix-ii.md b/problems/240.search-a-2-d-matrix-ii.md index 0b3f359dd..77223b5cc 100644 --- a/problems/240.search-a-2-d-matrix-ii.md +++ b/problems/240.search-a-2-d-matrix-ii.md @@ -123,8 +123,8 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(M + N)$ -- 空间复杂度：$O(1)$ +- 时间复杂度：$$O(M + N)$$ +- 空间复杂度：$$O(1)$$ 大家对此有何看法，欢迎给我留言，我有时间都会一一查看回答。更多算法套路可以访问我的 LeetCode 题解仓库：https://github.com/azl397985856/leetcode 。 目前已经 37K star 啦。 大家也可以关注我的公众号《力扣加加》带你啃下算法这块硬骨头。 diff --git a/problems/25.reverse-nodes-in-k-groups.md b/problems/25.reverse-nodes-in-k-groups.md index a69a7d9ea..7feef6729 100644 --- a/problems/25.reverse-nodes-in-k-groups.md +++ b/problems/25.reverse-nodes-in-k-groups.md @@ -325,8 +325,8 @@ class Solution: ``` **复杂度分析** -- 时间复杂度：$O(N)$ -- 空间复杂度：$O(1)$ +- 时间复杂度：$$O(N)$$ +- 空间复杂度：$$O(1)$$ ## 相关题目 diff --git a/problems/26.remove-duplicates-from-sorted-array.md b/problems/26.remove-duplicates-from-sorted-array.md index 83f89cf7b..a9c61ad43 100644 --- a/problems/26.remove-duplicates-from-sorted-array.md +++ b/problems/26.remove-duplicates-from-sorted-array.md @@ -151,8 +151,8 @@ public: **复杂度分析** -- 时间复杂度：$O(N)$ -- 空间复杂度：$O(1)$ +- 时间复杂度：$$O(N)$$ +- 空间复杂度：$$O(1)$$ 更多题解可以访问我的 LeetCode 题解仓库：https://github.com/azl397985856/leetcode 。 目前已经 37K star 啦。 diff --git a/problems/263.ugly-number.md b/problems/263.ugly-number.md index c13ffa93b..b77ab6c3a 100644 --- a/problems/263.ugly-number.md +++ b/problems/263.ugly-number.md @@ -107,8 +107,8 @@ var isUgly = function(num) { ``` **复杂度分析** -- 时间复杂度：$O(logN)$ -- 空间复杂度：$O(logN)$ +- 时间复杂度：$$O(logN)$$ +- 空间复杂度：$$O(logN)$$ C++ Code: @@ -161,8 +161,8 @@ class Solution: return num == 1 ``` **复杂度分析** -- 时间复杂度：$O(logN)$ -- 空间复杂度：$O(1)$ +- 时间复杂度：$$O(logN)$$ +- 空间复杂度：$$O(1)$$ 更多题解可以访问我的LeetCode题解仓库：https://github.com/azl397985856/leetcode 。 目前已经37K star啦。 diff --git a/problems/279.perfect-squares.md b/problems/279.perfect-squares.md index d5431fe7b..b48cb73c0 100644 --- a/problems/279.perfect-squares.md +++ b/problems/279.perfect-squares.md @@ -123,8 +123,8 @@ var numSquares = function(n) { **复杂度分析** -- 时间复杂度：$O(N^2)$ -- 空间复杂度：$O(N)$ +- 时间复杂度：$$O(N^2)$$ +- 空间复杂度：$$O(N)$$ 大家对此有何看法，欢迎给我留言，我有时间都会一一查看回答。更多算法套路可以访问我的 LeetCode 题解仓库：https://github.com/azl397985856/leetcode 。 目前已经 37K star 啦。 大家也可以关注我的公众号《力扣加加》带你啃下算法这块硬骨头。 diff --git a/problems/283.move-zeroes.md b/problems/283.move-zeroes.md index 3ba534c3f..55fd6faa1 100644 --- a/problems/283.move-zeroes.md +++ b/problems/283.move-zeroes.md @@ -136,8 +136,8 @@ class Solution: ``` **复杂度分析** -- 时间复杂度：$O(N)$ -- 空间复杂度：$O(1)$ +- 时间复杂度：$$O(N)$$ +- 空间复杂度：$$O(1)$$ 更多题解可以访问我的LeetCode题解仓库：https://github.com/azl397985856/leetcode 。 目前已经37K star啦。 diff --git a/problems/29.divide-two-integers.md b/problems/29.divide-two-integers.md index ded6feff7..53088ce6e 100644 --- a/problems/29.divide-two-integers.md +++ b/problems/29.divide-two-integers.md @@ -192,8 +192,8 @@ class Solution: ``` **复杂度分析** -- 时间复杂度：$O(logN)$ -- 空间复杂度：$O(1)$ +- 时间复杂度：$$O(logN)$$ +- 空间复杂度：$$O(1)$$ ## 相关题目 - [875.koko-eating-bananas](./875.koko-eating-bananas.md) diff --git a/problems/297.serialize-and-deserialize-binary-tree.md b/problems/297.serialize-and-deserialize-binary-tree.md index 705da18fc..13ad5e4e2 100644 --- a/problems/297.serialize-and-deserialize-binary-tree.md +++ b/problems/297.serialize-and-deserialize-binary-tree.md @@ -337,5 +337,5 @@ func (this *Codec) deserialize(data string) *TreeNode { **复杂度分析** -- 时间复杂度：$O(N)$，其中 N 为树的节点数。 -- 空间复杂度：$O(Q)$，其中 Q 为队列长度，最坏的情况是满二叉树，此时和 N 同阶，其中 N 为树的节点总数 +- 时间复杂度：$$O(N)$$，其中 N 为树的节点数。 +- 空间复杂度：$$O(Q)$$，其中 Q 为队列长度，最坏的情况是满二叉树，此时和 N 同阶，其中 N 为树的节点总数 diff --git a/problems/3.longest-substring-without-repeating-characters.md b/problems/3.longest-substring-without-repeating-characters.md index b14da9627..76cb692fb 100644 --- a/problems/3.longest-substring-without-repeating-characters.md +++ b/problems/3.longest-substring-without-repeating-characters.md @@ -150,8 +150,8 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(N)$ -- 空间复杂度：$O(N)$ +- 时间复杂度：$$O(N)$$ +- 空间复杂度：$$O(N)$$ 大家对此有何看法，欢迎给我留言，我有时间都会一一查看回答。更多算法套路可以访问我的 LeetCode 题解仓库：https://github.com/azl397985856/leetcode 。 目前已经 37K star 啦。 diff --git a/problems/30.substring-with-concatenation-of-all-words.md b/problems/30.substring-with-concatenation-of-all-words.md index 8e6beab24..a1eadb5b2 100644 --- a/problems/30.substring-with-concatenation-of-all-words.md +++ b/problems/30.substring-with-concatenation-of-all-words.md @@ -91,8 +91,8 @@ class Solution: 其中 N 为 words 中的总字符数。 -- 时间复杂度：$O(N)$ -- 空间复杂度：$O(N)$ +- 时间复杂度：$$O(N)$$ +- 空间复杂度：$$O(N)$$ 大家对此有何看法，欢迎给我留言，我有时间都会一一查看回答。更多算法套路可以访问我的 LeetCode 题解仓库：https://github.com/azl397985856/leetcode 。 目前已经 37K star 啦。 大家也可以关注我的公众号《力扣加加》带你啃下算法这块硬骨头。 diff --git a/problems/312.burst-balloons.md b/problems/312.burst-balloons.md index 90a535273..e5d11de1a 100644 --- a/problems/312.burst-balloons.md +++ b/problems/312.burst-balloons.md @@ -164,8 +164,8 @@ class Solution: ``` **复杂度分析** -- 时间复杂度：$O(N ^ 3)$ -- 空间复杂度：$O(N ^ 2)$ +- 时间复杂度：$$O(N ^ 3)$$ +- 空间复杂度：$$O(N ^ 2)$$ ### 总结 diff --git a/problems/32.longest-valid-parentheses.md b/problems/32.longest-valid-parentheses.md index 6392fcc6a..66692796d 100644 --- a/problems/32.longest-valid-parentheses.md +++ b/problems/32.longest-valid-parentheses.md @@ -69,8 +69,8 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(N^2)$ -- 空间复杂度：$O(1)$ +- 时间复杂度：$$O(N^2)$$ +- 空间复杂度：$$O(1)$$ ## 栈 @@ -135,8 +135,8 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(N)$ -- 空间复杂度：$O(N)$ +- 时间复杂度：$$O(N)$$ +- 空间复杂度：$$O(N)$$ ## O(1) 空间 @@ -275,8 +275,8 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(N)$ -- 空间复杂度：$O(N)$ +- 时间复杂度：$$O(N)$$ +- 空间复杂度：$$O(N)$$ ### 关键点解析 diff --git a/problems/322.coin-change.md b/problems/322.coin-change.md index b67116d13..f02c47dd2 100644 --- a/problems/322.coin-change.md +++ b/problems/322.coin-change.md @@ -123,8 +123,8 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(amonut * len(coins))$ -- 空间复杂度：$O(amount * len(coins))$ +- 时间复杂度：$$O(amonut * len(coins))$$ +- 空间复杂度：$$O(amount * len(coins))$$ dp[i][j] 依赖于`dp[i][j - 1]`和 `dp[i - coins[j - 1]][j] + 1)` 这是一个优化的信号，我们可以将其优化到一维,具体见下方。 @@ -209,8 +209,8 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(amonut * len(coins))$ -- 空间复杂度：$O(amount)$ +- 时间复杂度：$$O(amonut * len(coins))$$ +- 空间复杂度：$$O(amount)$$ ## 扩展 diff --git a/problems/328.odd-even-linked-list.md b/problems/328.odd-even-linked-list.md index a0a999cab..fc08a989b 100644 --- a/problems/328.odd-even-linked-list.md +++ b/problems/328.odd-even-linked-list.md @@ -135,8 +135,8 @@ public: **复杂度分析** -- 时间复杂度：$O(N)$ -- 空间复杂度：$O(1)$ +- 时间复杂度：$$O(N)$$ +- 空间复杂度：$$O(1)$$ 大家对此有何看法，欢迎给我留言，我有时间都会一一查看回答。更多算法套路可以访问我的 LeetCode 题解仓库：https://github.com/azl397985856/leetcode 。 目前已经 37K star 啦。 大家也可以关注我的公众号《力扣加加》带你啃下算法这块硬骨头。 diff --git a/problems/33.search-in-rotated-sorted-array.md b/problems/33.search-in-rotated-sorted-array.md index fc60dec72..3592cc607 100644 --- a/problems/33.search-in-rotated-sorted-array.md +++ b/problems/33.search-in-rotated-sorted-array.md @@ -172,8 +172,8 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(logN)$ -- 空间复杂度：$O(1)$ +- 时间复杂度：$$O(logN)$$ +- 空间复杂度：$$O(1)$$ 大家对此有何看法，欢迎给我留言，我有时间都会一一查看回答。更多算法套路可以访问我的 LeetCode 题解仓库：https://github.com/azl397985856/leetcode 。 目前已经 37K star 啦。 大家也可以关注我的公众号《力扣加加》带你啃下算法这块硬骨头。 diff --git a/problems/334.increasing-triplet-subsequence.md b/problems/334.increasing-triplet-subsequence.md index 6da292e9a..6b4eafd08 100644 --- a/problems/334.increasing-triplet-subsequence.md +++ b/problems/334.increasing-triplet-subsequence.md @@ -117,8 +117,8 @@ var increasingTriplet = function(nums) { **复杂度分析** -- 时间复杂度：$O(N)$ -- 空间复杂度：$O(1)$ +- 时间复杂度：$$O(N)$$ +- 空间复杂度：$$O(1)$$ 大家对此有何看法，欢迎给我留言，我有时间都会一一查看回答。更多算法套路可以访问我的 LeetCode 题解仓库：https://github.com/azl397985856/leetcode 。 目前已经 37K star 啦。 大家也可以关注我的公众号《力扣加加》带你啃下算法这块硬骨头。 diff --git a/problems/335.self-crossing.md b/problems/335.self-crossing.md index 4ab65ea71..dbdac8ced 100644 --- a/problems/335.self-crossing.md +++ b/problems/335.self-crossing.md @@ -51,9 +51,9 @@ https://leetcode-cn.com/problems/self-crossing/ ## 思路 -符合直觉的做法是$O(N)$时间和空间复杂度的算法。这种算法非常简单，但是题目要求我们使用空间复杂度为$O(1)$的做法。 +符合直觉的做法是$$O(N)$$时间和空间复杂度的算法。这种算法非常简单，但是题目要求我们使用空间复杂度为$$O(1)$$的做法。 -关于空间复杂度为$O(N)$的算法可以参考我之前的[874.walking-robot-simulation](https://github.com/azl397985856/leetcode/blob/be15d243a3b93d7efa731d0589a54a63cbff61ae/problems/874.walking-robot-simulation.md)。 思路基本是类似，只不过 obstacles（障碍物）不是固定的，而是我们不断遍历的时候动态生成的，我们每遇到一个点，就将其标记为 obstacle。随着算法的进行，我们的 obstacles 逐渐增大，最终和 N 一个量级。 +关于空间复杂度为$$O(N)$$的算法可以参考我之前的[874.walking-robot-simulation](https://github.com/azl397985856/leetcode/blob/be15d243a3b93d7efa731d0589a54a63cbff61ae/problems/874.walking-robot-simulation.md)。 思路基本是类似，只不过 obstacles（障碍物）不是固定的，而是我们不断遍历的时候动态生成的，我们每遇到一个点，就将其标记为 obstacle。随着算法的进行，我们的 obstacles 逐渐增大，最终和 N 一个量级。 我们考虑进行优化。我们仔细观察发现，如果想让其不相交，从大的范围来看只有两种情况： @@ -92,12 +92,12 @@ https://leetcode-cn.com/problems/self-crossing/ ## 关键点解析 - 一定要画图辅助 -- 对于这种$O(1)$空间复杂度有固定的套路。常见的有： +- 对于这种$$O(1)$$空间复杂度有固定的套路。常见的有： 1. 直接修改原数组 2. 滑动窗口（当前状态并不是和之前所有状态有关，而是仅和某几个有关）。 -我们采用的是滑动窗口。但是难点就在于我们怎么知道当前状态和哪几个有关。对于这道题来说，画图或许可以帮助你打开思路。另外面试的时候说出$O(N)$的思路也不失为一个帮助你冷静分析问题的手段。 +我们采用的是滑动窗口。但是难点就在于我们怎么知道当前状态和哪几个有关。对于这道题来说，画图或许可以帮助你打开思路。另外面试的时候说出$$O(N)$$的思路也不失为一个帮助你冷静分析问题的手段。 ## 代码 @@ -128,8 +128,8 @@ class Solution: 其中 N 为数组长度。 -- 时间复杂度：$O(N)$ -- 空间复杂度：$O(1)$ +- 时间复杂度：$$O(N)$$ +- 空间复杂度：$$O(1)$$ 大家对此有何看法，欢迎给我留言，我有时间都会一一查看回答。更多算法套路可以访问我的 LeetCode 题解仓库：https://github.com/azl397985856/leetcode 。 目前已经 37K star 啦。 大家也可以关注我的公众号《力扣加加》带你啃下算法这块硬骨头。 diff --git a/problems/337.house-robber-iii.md b/problems/337.house-robber-iii.md index 726b825f0..b97e24f1c 100644 --- a/problems/337.house-robber-iii.md +++ b/problems/337.house-robber-iii.md @@ -189,8 +189,8 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(N)$，其中 N 为树的节点个数。 -- 空间复杂度：$O(h)$，其中 h 为树的高度。 +- 时间复杂度：$$O(N)$$，其中 N 为树的节点个数。 +- 空间复杂度：$$O(h)$$，其中 h 为树的高度。 ## 相关题目 diff --git a/problems/342.power-of-four.md b/problems/342.power-of-four.md index 52a0e24af..fd16f9be2 100644 --- a/problems/342.power-of-four.md +++ b/problems/342.power-of-four.md @@ -141,8 +141,8 @@ class Solution: ``` **复杂度分析** -- 时间复杂度：$O(1)$ -- 空间复杂度：$O(1)$ +- 时间复杂度：$$O(1)$$ +- 空间复杂度：$$O(1)$$ 更多题解可以访问我的LeetCode题解仓库：https://github.com/azl397985856/leetcode 。 目前已经37K star啦。 diff --git a/problems/349.intersection-of-two-arrays.md b/problems/349.intersection-of-two-arrays.md index 91b217ed6..0aa542e38 100644 --- a/problems/349.intersection-of-two-arrays.md +++ b/problems/349.intersection-of-two-arrays.md @@ -99,8 +99,8 @@ class Solution: return set(nums1) & set(nums2) ``` **复杂度分析** -- 时间复杂度：$O(N)$ -- 空间复杂度：$O(N)$ +- 时间复杂度：$$O(N)$$ +- 空间复杂度：$$O(N)$$ 更多题解可以访问我的LeetCode题解仓库：https://github.com/azl397985856/leetcode 。 目前已经37K star啦。 diff --git a/problems/365.water-and-jug-problem.md b/problems/365.water-and-jug-problem.md index e9ca80b11..33364c353 100644 --- a/problems/365.water-and-jug-problem.md +++ b/problems/365.water-and-jug-problem.md @@ -86,8 +86,8 @@ class Solution: **复杂度分析** -- 时间复杂度：由于状态最多有$O((x + 1) * (y + 1))$ 种，因此总的时间复杂度为$O(x * y)$。 -- 空间复杂度：我们使用了队列来存储状态，set 存储已经访问的元素，空间复杂度和状态数目一致，因此空间复杂度是$O(x * y)$。 +- 时间复杂度：由于状态最多有$$O((x + 1) * (y + 1))$$ 种，因此总的时间复杂度为$$O(x * y)$$。 +- 空间复杂度：我们使用了队列来存储状态，set 存储已经访问的元素，空间复杂度和状态数目一致，因此空间复杂度是$$O(x * y)$$。 上面的思路很直观，但是很遗憾这个算法在 LeetCode 的表现是 TLE(Time Limit Exceeded)。不过如果你能在真实面试中写出这样的算法，我相信大多数情况是可以过关的。 @@ -203,8 +203,8 @@ def GCD(a, b): **复杂度分析** -- 时间复杂度：$O(log(max(a, b)))$ -- 空间复杂度：空间复杂度取决于递归的深度，因此空间复杂度为 $O(log(max(a, b)))$ +- 时间复杂度：$$O(log(max(a, b)))$$ +- 空间复杂度：空间复杂度取决于递归的深度，因此空间复杂度为 $$O(log(max(a, b)))$$ ## 关键点分析 diff --git a/problems/371.sum-of-two-integers.md b/problems/371.sum-of-two-integers.md index f41bdda9a..6a6da45f2 100644 --- a/problems/371.sum-of-two-integers.md +++ b/problems/371.sum-of-two-integers.md @@ -130,8 +130,8 @@ class Solution: ``` **复杂度分析** -- 时间复杂度：$O(1)$ -- 空间复杂度：$O(1)$ +- 时间复杂度：$$O(1)$$ +- 空间复杂度：$$O(1)$$ > 由于题目数据规模不会变化，因此其实复杂度分析是没有意义的。 diff --git a/problems/378.kth-smallest-element-in-a-sorted-matrix.md b/problems/378.kth-smallest-element-in-a-sorted-matrix.md index 3cd01bb4c..16879553d 100644 --- a/problems/378.kth-smallest-element-in-a-sorted-matrix.md +++ b/problems/378.kth-smallest-element-in-a-sorted-matrix.md @@ -167,8 +167,8 @@ var kthSmallest = function(matrix, k) { **复杂度分析** -- 时间复杂度：二分查找进行次数为 $O(log(r-l))$，每次操作时间复杂度为 O(n)，因此总的时间复杂度为 $O(nlog(r-l))$。 -- 空间复杂度：$O(1)$。 +- 时间复杂度：二分查找进行次数为 $$O(log(r-l))$$，每次操作时间复杂度为 O(n)，因此总的时间复杂度为 $$O(nlog(r-l))$$。 +- 空间复杂度：$$O(1)$$。 ## 相关题目 diff --git a/problems/380.insert-delete-getrandom-o1.md b/problems/380.insert-delete-getrandom-o1.md index 74f1b976d..533773079 100644 --- a/problems/380.insert-delete-getrandom-o1.md +++ b/problems/380.insert-delete-getrandom-o1.md @@ -44,17 +44,17 @@ randomSet.getRandom(); 我们来回顾一下基础知识： -- 数组支持随机访问，其按照索引查询的时间复杂度为$O(1)$,按值查询的时间复杂度为$O(N)$， 而插入和删除的时间复杂度为$O(N)$。 -- 链表不支持随机访问，其查询的时间复杂度为$O(N)$,但是对于插入和删除的复杂度为$O(1)$（不考虑找到选要处理的节点花费的时间）。 -- 对于哈希表，正常情况下其查询复杂度平均为$O(N)$，插入和删除的复杂度为$O(1)$。 +- 数组支持随机访问，其按照索引查询的时间复杂度为$$O(1)$$,按值查询的时间复杂度为$$O(N)$$， 而插入和删除的时间复杂度为$$O(N)$$。 +- 链表不支持随机访问，其查询的时间复杂度为$$O(N)$$,但是对于插入和删除的复杂度为$$O(1)$$（不考虑找到选要处理的节点花费的时间）。 +- 对于哈希表，正常情况下其查询复杂度平均为$$O(N)$$，插入和删除的复杂度为$$O(1)$$。 -由于题目要求 getRandom 返回要随机并且要在$O(1)$复杂度内，那么如果单纯使用链表或者哈希表肯定是不行的。 +由于题目要求 getRandom 返回要随机并且要在$$O(1)$$复杂度内，那么如果单纯使用链表或者哈希表肯定是不行的。 -而又由于对于插入和删除也需要复杂度为$O(1)$，因此单纯使用数组也是不行的，因此考虑多种使用数据结构来实现。 +而又由于对于插入和删除也需要复杂度为$$O(1)$$，因此单纯使用数组也是不行的，因此考虑多种使用数据结构来实现。 > 实际上 LeetCode 设计题，几乎没有单纯一个数据结构搞定的，基本都需要多种数据结构结合，这个时候需要你对各种数据结构以及其基本算法的复杂度有着清晰的认知。 -对于 getRandom 用数组很简单。对于判断是否已经有了存在的元素，我们使用哈希表也很容易做到。因此我们可以将数组随机访问，以及哈希表$O(1)$按检索值的特性结合起来，即同时使用这两种数据结构。 +对于 getRandom 用数组很简单。对于判断是否已经有了存在的元素，我们使用哈希表也很容易做到。因此我们可以将数组随机访问，以及哈希表$$O(1)$$按检索值的特性结合起来，即同时使用这两种数据结构。 对于删除和插入，我们需要一些技巧。 @@ -160,8 +160,8 @@ class RandomizedSet: **复杂度分析** -- 时间复杂度：$O(1)$ -- 空间复杂度：$O(1)$ +- 时间复杂度：$$O(1)$$ +- 空间复杂度：$$O(1)$$ 更多题解可以访问我的 LeetCode 题解仓库：https://github.com/azl397985856/leetcode 。 目前已经 30K star 啦。 diff --git a/problems/394.decode-string.md b/problems/394.decode-string.md index 3c3a809b6..ca1253410 100644 --- a/problems/394.decode-string.md +++ b/problems/394.decode-string.md @@ -117,8 +117,8 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(N)$，其中 N 为解码后的 s 的长度。 -- 空间复杂度：$O(N)$，其中 N 为解码后的 s 的长度。 +- 时间复杂度：$$O(N)$$，其中 N 为解码后的 s 的长度。 +- 空间复杂度：$$O(N)$$，其中 N 为解码后的 s 的长度。 ## 递归 @@ -243,8 +243,8 @@ class Solution { **复杂度分析** -- 时间复杂度：$O(N)$，其中 N 为解码后的 s 的长度。 -- 空间复杂度：$O(N)$，其中 N 为解码后的 s 的长度。 +- 时间复杂度：$$O(N)$$，其中 N 为解码后的 s 的长度。 +- 空间复杂度：$$O(N)$$，其中 N 为解码后的 s 的长度。 更多题解可以访问我的 LeetCode 题解仓库：https://github.com/azl397985856/leetcode 。 目前已经 37K star 啦。 diff --git a/problems/4.median-of-two-sorted-arrays.md b/problems/4.median-of-two-sorted-arrays.md index 14ab4cec2..f5eac866e 100644 --- a/problems/4.median-of-two-sorted-arrays.md +++ b/problems/4.median-of-two-sorted-arrays.md @@ -191,8 +191,8 @@ var findMedianSortedArrays = function (nums1, nums2) { **复杂度分析** -- 时间复杂度：$O(max(m, n))$ -- 空间复杂度：$O(m + n)$ +- 时间复杂度：$$O(max(m, n))$$ +- 空间复杂度：$$O(m + n)$$ _解法二 - 二分查找（Binary Search)_ @@ -280,8 +280,8 @@ class MedianSortedTwoArrayBinarySearch { **复杂度分析** -- 时间复杂度：$O(log(min(m, n)))$ -- 空间复杂度：$O(log(min(m, n)))$ +- 时间复杂度：$$O(log(min(m, n)))$$ +- 空间复杂度：$$O(log(min(m, n)))$$ 大家对此有何看法，欢迎给我留言，我有时间都会一一查看回答。更多算法套路可以访问我的 LeetCode 题解仓库：https://github.com/azl397985856/leetcode 。 目前已经 37K star 啦。 大家也可以关注我的公众号《力扣加加》带你啃下算法这块硬骨头。 diff --git a/problems/416.partition-equal-subset-sum.md b/problems/416.partition-equal-subset-sum.md index 098e5cac2..152582bab 100644 --- a/problems/416.partition-equal-subset-sum.md +++ b/problems/416.partition-equal-subset-sum.md @@ -296,8 +296,8 @@ var change = function (amount, coins) { **复杂度分析** -- 时间复杂度：$O(amount * len(coins))$ -- 空间复杂度：$O(amount)$ +- 时间复杂度：$$O(amount * len(coins))$$ +- 空间复杂度：$$O(amount)$$ ### 参考 diff --git a/problems/42.trapping-rain-water.en.md b/problems/42.trapping-rain-water.en.md index 38f346912..7be42b6ca 100755 --- a/problems/42.trapping-rain-water.en.md +++ b/problems/42.trapping-rain-water.en.md @@ -133,8 +133,8 @@ int trap(vector& heights) **Complexity Analysis** -- Time Complexity: $O(N)$ -- Space Complexity: $O(N)$ +- Time Complexity: $$O(N)$$ +- Space Complexity: $$O(N)$$ ## Two Pointers @@ -214,8 +214,8 @@ public: **Complexity Analysis** -- Time Complexity: $O(N)$ -- Space Complexity: $O(1)$ +- Time Complexity: $$O(N)$$ +- Space Complexity: $$O(1)$$ ## Similar Problems diff --git a/problems/42.trapping-rain-water.md b/problems/42.trapping-rain-water.md index 4aa4021bf..1cf920ac9 100755 --- a/problems/42.trapping-rain-water.md +++ b/problems/42.trapping-rain-water.md @@ -150,8 +150,8 @@ int trap(vector& heights) **复杂度分析** -- 时间复杂度：$O(N)$ -- 空间复杂度：$O(N)$ +- 时间复杂度：$$O(N)$$ +- 空间复杂度：$$O(N)$$ ## 双指针 @@ -306,8 +306,8 @@ class Solution **复杂度分析** -- 时间复杂度：$O(N)$ -- 空间复杂度：$O(1)$ +- 时间复杂度：$$O(N)$$ +- 空间复杂度：$$O(1)$$ ## 相关题目 diff --git a/problems/437.path-sum-iii.md b/problems/437.path-sum-iii.md index 0bb91c474..978187dfc 100644 --- a/problems/437.path-sum-iii.md +++ b/problems/437.path-sum-iii.md @@ -170,8 +170,8 @@ var pathSum = function(root, sum) { ``` **复杂度分析** -- 时间复杂度：$O(N)$ -- 空间复杂度：$O(N)$ +- 时间复杂度：$$O(N)$$ +- 空间复杂度：$$O(N)$$ 更多题解可以访问我的LeetCode题解仓库：https://github.com/azl397985856/leetcode 。 目前已经37K star啦。 diff --git a/problems/445.add-two-numbers-ii.md b/problems/445.add-two-numbers-ii.md index 0e403b2bf..8ef9c05b3 100644 --- a/problems/445.add-two-numbers-ii.md +++ b/problems/445.add-two-numbers-ii.md @@ -278,8 +278,8 @@ class Solution: 其中 M 和 N 分别为两个链表的长度。 -- 时间复杂度：$O(M + N)$ -- 空间复杂度：$O(M + N)$ +- 时间复杂度：$$O(M + N)$$ +- 空间复杂度：$$O(M + N)$$ 大家对此有何看法，欢迎给我留言，我有时间都会一一查看回答。更多算法套路可以访问我的 LeetCode 题解仓库：https://github.com/azl397985856/leetcode 。 目前已经 37K star 啦。 大家也可以关注我的公众号《力扣加加》带你啃下算法这块硬骨头。 diff --git a/problems/454.4-sum-ii.md b/problems/454.4-sum-ii.md index ede914aea..22aefb1b0 100644 --- a/problems/454.4-sum-ii.md +++ b/problems/454.4-sum-ii.md @@ -115,8 +115,8 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(N^2)$ -- 空间复杂度：$O(N^2)$ +- 时间复杂度：$$O(N^2)$$ +- 空间复杂度：$$O(N^2)$$ 大家对此有何看法，欢迎给我留言，我有时间都会一一查看回答。更多算法套路可以访问我的 LeetCode 题解仓库：https://github.com/azl397985856/leetcode 。 目前已经 37K star 啦。 大家也可以关注我的公众号《力扣加加》带你啃下算法这块硬骨头。 diff --git a/problems/48.rotate-image.md b/problems/48.rotate-image.md index a25cfd8c2..ded81fb39 100644 --- a/problems/48.rotate-image.md +++ b/problems/48.rotate-image.md @@ -163,8 +163,8 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(M * N)$ -- 空间复杂度：$O(1)$ +- 时间复杂度：$$O(M * N)$$ +- 空间复杂度：$$O(1)$$ 大家对此有何看法，欢迎给我留言，我有时间都会一一查看回答。更多算法套路可以访问我的 LeetCode 题解仓库：https://github.com/azl397985856/leetcode 。 目前已经 37K star 啦。 大家也可以关注我的公众号《力扣加加》带你啃下算法这块硬骨头。 diff --git a/problems/488.zuma-game.md b/problems/488.zuma-game.md index fe22820ba..c65da0249 100644 --- a/problems/488.zuma-game.md +++ b/problems/488.zuma-game.md @@ -137,8 +137,8 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(2^(min(C, 5)))$，其中 C 为连续相同颜色球的次数，比如 WWRRRR， C 就是 2， WRBDD， C 就是 4。min(C, 5) 是因为题目限定了手上球的个数不大于 5。 -- 空间复杂度：$O(min(C, 5) * Board)$，其中 C 为连续相同颜色球的次数，Board 为 Board 的长度。 +- 时间复杂度：$$O(2^(min(C, 5)))$$，其中 C 为连续相同颜色球的次数，比如 WWRRRR， C 就是 2， WRBDD， C 就是 4。min(C, 5) 是因为题目限定了手上球的个数不大于 5。 +- 空间复杂度：$$O(min(C, 5) * Board)$$，其中 C 为连续相同颜色球的次数，Board 为 Board 的长度。 ## 关键点解析 diff --git a/problems/49.group-anagrams.md b/problems/49.group-anagrams.md index a1281cb0d..2140150f9 100644 --- a/problems/49.group-anagrams.md +++ b/problems/49.group-anagrams.md @@ -139,8 +139,8 @@ class Solution: 其中 N 为 strs 的长度， M 为 strs 中字符串的平均长度。 -- 时间复杂度：$O(N * M)$ -- 空间复杂度：$O(N * M)$ +- 时间复杂度：$$O(N * M)$$ +- 空间复杂度：$$O(N * M)$$ 大家对此有何看法，欢迎给我留言，我有时间都会一一查看回答。更多算法套路可以访问我的 LeetCode 题解仓库：https://github.com/azl397985856/leetcode 。 目前已经 37K star 啦。 大家也可以关注我的公众号《力扣加加》带你啃下算法这块硬骨头。 diff --git a/problems/493.reverse-pairs.md b/problems/493.reverse-pairs.md index 55a6967b6..f1751bf62 100644 --- a/problems/493.reverse-pairs.md +++ b/problems/493.reverse-pairs.md @@ -65,7 +65,7 @@ class Solution(object): 如果你能够想到逆序数，那么你很可能直到使用类似归并排序的方法可以求解逆序数。实际上逆序数只是归并排序的副产物而已。 -我们在正常的归并排序的代码中去计算逆序数即可。由于每次分治的过程，左右两段数组分别是有序的，因此我们可以减少一些运算。 从时间复杂度的角度上讲，我们从$O(N^2)$优化到了 $O(NlogN)$。 +我们在正常的归并排序的代码中去计算逆序数即可。由于每次分治的过程，左右两段数组分别是有序的，因此我们可以减少一些运算。 从时间复杂度的角度上讲，我们从$$O(N^2)$$优化到了 $$O(NlogN)$$。 具体来说，对两段有序的数组，有序数组内部是不需要计算逆序数的。 我们计算逆序数的逻辑只是计算两个数组之间的逆序数，我们假设两个数组是 A 和 B，并且 A 数组最大的元素不大于 B 数组最小的元素。而要做到这样，我们只需要常规的归并排序即可。 @@ -117,8 +117,8 @@ class Solution(object): **复杂度分析** -- 时间复杂度：$O(NlogN)$ -- 空间复杂度：$O(logN)$ +- 时间复杂度：$$O(NlogN)$$ +- 空间复杂度：$$O(logN)$$ 大家对此有何看法，欢迎给我留言，我有时间都会一一查看回答。更多算法套路可以访问我的 LeetCode 题解仓库：https://github.com/azl397985856/leetcode 。 目前已经 37K star 啦。 大家也可以关注我的公众号《力扣加加》带你啃下算法这块硬骨头。 diff --git a/problems/494.target-sum.md b/problems/494.target-sum.md index 35fae4e43..96ad29043 100644 --- a/problems/494.target-sum.md +++ b/problems/494.target-sum.md @@ -112,8 +112,8 @@ var findTargetSumWays = function(nums, S) { **复杂度分析** -- 时间复杂度：$O(N * target)$ -- 空间复杂度：$O(target)$ +- 时间复杂度：$$O(N * target)$$ +- 空间复杂度：$$O(target)$$ 大家对此有何看法，欢迎给我留言，我有时间都会一一查看回答。更多算法套路可以访问我的 LeetCode 题解仓库：https://github.com/azl397985856/leetcode 。 目前已经 37K star 啦。 大家也可以关注我的公众号《力扣加加》带你啃下算法这块硬骨头。 diff --git a/problems/5.longest-palindromic-substring.md b/problems/5.longest-palindromic-substring.md index 06e62a261..2fd486578 100644 --- a/problems/5.longest-palindromic-substring.md +++ b/problems/5.longest-palindromic-substring.md @@ -129,8 +129,8 @@ var longestPalindrome = function (s) { **_复杂度分析_** -- 时间复杂度：$O(N^2)$ -- 空间复杂度：$O(N^2)$ +- 时间复杂度：$$O(N^2)$$ +- 空间复杂度：$$O(N^2)$$ ## 相关题目 diff --git a/problems/50.pow-x-n.md b/problems/50.pow-x-n.md index 25a6949f4..d263e8d70 100644 --- a/problems/50.pow-x-n.md +++ b/problems/50.pow-x-n.md @@ -45,7 +45,7 @@ n 是 32 位有符号整数，其数值范围是 [−231, 231 − 1] 。 这道题是让我们实现数学函数`幂`，因此直接调用系统内置函数是不被允许的。 -符合直觉的做法是`将x乘以n次`，这种做法的时间复杂度是$O(N)$。 +符合直觉的做法是`将x乘以n次`，这种做法的时间复杂度是$$O(N)$$。 经实际测试，这种做法果然超时了。测试用例通过 291/304，在 `0.00001\n2147483647`这个测试用例挂掉了。如果是面试，这个解法可以作为一种兜底解法。 @@ -188,8 +188,8 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(logN)$ -- 空间复杂度：$O(1)$ +- 时间复杂度：$$O(logN)$$ +- 空间复杂度：$$O(1)$$ ## 关键点解析 diff --git a/problems/513.find-bottom-left-tree-value.md b/problems/513.find-bottom-left-tree-value.md index 3ddd731e9..057cea863 100644 --- a/problems/513.find-bottom-left-tree-value.md +++ b/problems/513.find-bottom-left-tree-value.md @@ -224,8 +224,8 @@ class Solution **复杂度分析** -- 时间复杂度：$O(N)$，其中 N 为树的节点数。 -- 空间复杂度：$O(Q)$，其中 Q 为队列长度，最坏的情况是满二叉树，此时和 N 同阶，其中 N 为树的节点总数 +- 时间复杂度：$$O(N)$$，其中 N 为树的节点数。 +- 空间复杂度：$$O(Q)$$，其中 Q 为队列长度，最坏的情况是满二叉树，此时和 N 同阶，其中 N 为树的节点总数 ## DFS @@ -347,5 +347,5 @@ public: **复杂度分析** -- 时间复杂度：$O(N)$，其中 N 为树的节点总数。 -- 空间复杂度：$O(h)$，其中 h 为树的高度。 +- 时间复杂度：$$O(N)$$，其中 N 为树的节点总数。 +- 空间复杂度：$$O(h)$$，其中 h 为树的高度。 diff --git a/problems/516.longest-palindromic-subsequence.md b/problems/516.longest-palindromic-subsequence.md index a4c465ee0..e75ee7bbc 100644 --- a/problems/516.longest-palindromic-subsequence.md +++ b/problems/516.longest-palindromic-subsequence.md @@ -118,8 +118,8 @@ var longestPalindromeSubseq = function(s) { **复杂度分析** -- 时间复杂度：$O(N^2)$ -- 空间复杂度：$O(N^2)$ +- 时间复杂度：$$O(N^2)$$ +- 空间复杂度：$$O(N^2)$$ ## 相关题目 diff --git a/problems/518.coin-change-2.md b/problems/518.coin-change-2.md index c4ae4de51..76e36b630 100644 --- a/problems/518.coin-change-2.md +++ b/problems/518.coin-change-2.md @@ -181,8 +181,8 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(amount)$ -- 空间复杂度：$O(amount * len(coins))$ +- 时间复杂度：$$O(amount)$$ +- 空间复杂度：$$O(amount * len(coins))$$ ## 扩展 @@ -214,8 +214,8 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(amount * len(coins))$ -- 空间复杂度：$O(amount * len(coins))$ +- 时间复杂度：$$O(amount * len(coins))$$ +- 空间复杂度：$$O(amount * len(coins))$$ 大家对此有何看法，欢迎给我留言，我有时间都会一一查看回答。更多算法套路可以访问我的 LeetCode 题解仓库：https://github.com/azl397985856/leetcode 。 目前已经 37K star 啦。 diff --git a/problems/53.maximum-sum-subarray-cn.md b/problems/53.maximum-sum-subarray-cn.md index d4046ac4f..ba8b35b10 100644 --- a/problems/53.maximum-sum-subarray-cn.md +++ b/problems/53.maximum-sum-subarray-cn.md @@ -48,8 +48,8 @@ https://leetcode-cn.com/problems/maximum-subarray/ **复杂度分析** -- 时间复杂度：$O(N ^ 3)$, 其中 N 是数组长度 -- 空间复杂度：$O(1)$ +- 时间复杂度：$$O(N ^ 3)$$, 其中 N 是数组长度 +- 空间复杂度：$$O(1)$$ #### 解法二 - 前缀和 + 暴力解 @@ -64,8 +64,8 @@ https://leetcode-cn.com/problems/maximum-subarray/ **复杂度分析** -- 时间复杂度：$O(N ^ 2)$, 其中 N 是数组长度 -- 空间复杂度：$O(N)$ +- 时间复杂度：$$O(N ^ 2)$$, 其中 N 是数组长度 +- 空间复杂度：$$O(N)$$ > 如果用更改原数组表示前缀和数组，空间复杂度降为`O(1)` @@ -83,8 +83,8 @@ https://leetcode-cn.com/problems/maximum-subarray/ **复杂度分析** -- 时间复杂度：$O(N)$, 其中 N 是数组长度 -- 空间复杂度：$O(1)$ +- 时间复杂度：$$O(N)$$, 其中 N 是数组长度 +- 空间复杂度：$$O(1)$$ #### 解法四 - [分治法](https://www.wikiwand.com/zh-hans/%E5%88%86%E6%B2%BB%E6%B3%95) @@ -104,8 +104,8 @@ https://leetcode-cn.com/problems/maximum-subarray/ **复杂度分析** -- 时间复杂度：$O(NlogN)$, 其中 N 是数组长度 -- 空间复杂度：$O(logN)$ +- 时间复杂度：$$O(NlogN)$$, 其中 N 是数组长度 +- 空间复杂度：$$O(logN)$$ #### 解法五 - [动态规划](https://www.wikiwand.com/zh-hans/%E5%8A%A8%E6%80%81%E8%A7%84%E5%88%92) @@ -132,8 +132,8 @@ https://leetcode-cn.com/problems/maximum-subarray/ **复杂度分析** -- 时间复杂度：$O(N)$, 其中 N 是数组长度 -- 空间复杂度：$O(1)$ +- 时间复杂度：$$O(N)$$, 其中 N 是数组长度 +- 空间复杂度：$$O(1)$$ ## 关键点分析 diff --git a/problems/547.friend-circles.md b/problems/547.friend-circles.md index aaad3a17d..13c2608e4 100644 --- a/problems/547.friend-circles.md +++ b/problems/547.friend-circles.md @@ -54,9 +54,9 @@ N 在[1,200]的范围内。 ## 代码 -`find`, `union`, `connected` 都是典型的模板方法。 懂的同学可能也发现了，我没有做路径压缩，这直接导致 find union connected 的时间复杂度最差的情况退化到 $O(N)$。 +`find`, `union`, `connected` 都是典型的模板方法。 懂的同学可能也发现了，我没有做路径压缩，这直接导致 find union connected 的时间复杂度最差的情况退化到 $$O(N)$$。 -当然优化也不难，我们只需要给每一个顶层元素设置一个 size 用来表示连通分量的大小，这样 union 的时候我们将小的拼接到大的上即可。 另外 find 的时候我们甚至可以路径压缩，将树高限定到常数，这样时间复杂度可以降低到 $O(1)$。 +当然优化也不难，我们只需要给每一个顶层元素设置一个 size 用来表示连通分量的大小，这样 union 的时候我们将小的拼接到大的上即可。 另外 find 的时候我们甚至可以路径压缩，将树高限定到常数，这样时间复杂度可以降低到 $$O(1)$$。 ```python class UF: @@ -93,8 +93,8 @@ class Solution: **复杂度分析** -- 时间复杂度：平均 $O(logN)$，最坏的情况是 $O(N)$ -- 空间复杂度：我们使用了 parent， 因此空间复杂度为 $O(N)$ +- 时间复杂度：平均 $$O(logN)$$，最坏的情况是 $$O(N)$$ +- 空间复杂度：我们使用了 parent， 因此空间复杂度为 $$O(N)$$ ## 相关专题 diff --git a/problems/55.jump-game.md b/problems/55.jump-game.md index c51a20f33..b0517173d 100644 --- a/problems/55.jump-game.md +++ b/problems/55.jump-game.md @@ -136,8 +136,8 @@ class Solution: **_复杂度分析_** -- 时间复杂度：$O(N)$ -- 空间复杂度：$O(1)$ +- 时间复杂度：$$O(N)$$ +- 空间复杂度：$$O(1)$$ 大家对此有何看法，欢迎给我留言，我有时间都会一一查看回答。更多算法套路可以访问我的 LeetCode 题解仓库：https://github.com/azl397985856/leetcode 。 目前已经 37K star 啦。 大家也可以关注我的公众号《力扣加加》带你啃下算法这块硬骨头。 diff --git a/problems/56.merge-intervals.md b/problems/56.merge-intervals.md index b36f0b3c5..4bd5a0317 100644 --- a/problems/56.merge-intervals.md +++ b/problems/56.merge-intervals.md @@ -118,8 +118,8 @@ class Solution: **_复杂度分析_** -- 时间复杂度：由于采用了排序，因此复杂度大概为 $O(NlogN)$ -- 空间复杂度：$O(N)$ +- 时间复杂度：由于采用了排序，因此复杂度大概为 $$O(NlogN)$$ +- 空间复杂度：$$O(N)$$ 大家对此有何看法，欢迎给我留言，我有时间都会一一查看回答。更多算法套路可以访问我的 LeetCode 题解仓库：https://github.com/azl397985856/leetcode 。 目前已经 37K star 啦。 大家也可以关注我的公众号《力扣加加》带你啃下算法这块硬骨头。 diff --git a/problems/57.insert-interval.md b/problems/57.insert-interval.md index 00997fd8c..26f651090 100644 --- a/problems/57.insert-interval.md +++ b/problems/57.insert-interval.md @@ -78,8 +78,8 @@ class Solution: **复杂度分析** -- 时间复杂度：由于采用了排序，因此复杂度大概为 $O(NlogN)$ -- 空间复杂度：$O(1)$ +- 时间复杂度：由于采用了排序，因此复杂度大概为 $$O(NlogN)$$ +- 空间复杂度：$$O(1)$$ ## 一次扫描 @@ -140,8 +140,8 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(N)$ -- 空间复杂度：$O(1)$ +- 时间复杂度：$$O(N)$$ +- 空间复杂度：$$O(1)$$ 大家对此有何看法，欢迎给我留言，我有时间都会一一查看回答。更多算法套路可以访问我的 LeetCode 题解仓库：https://github.com/azl397985856/leetcode 。 目前已经 37K star 啦。 大家也可以关注我的公众号《力扣加加》带你啃下算法这块硬骨头。 diff --git a/problems/575.distribute-candies.md b/problems/575.distribute-candies.md index 75c363b1d..ec82e450e 100644 --- a/problems/575.distribute-candies.md +++ b/problems/575.distribute-candies.md @@ -81,8 +81,8 @@ class Solution: ``` **复杂度分析** -- 时间复杂度：$O(N)$ -- 空间复杂度：$O(N)$ +- 时间复杂度：$$O(N)$$ +- 空间复杂度：$$O(N)$$ 更多题解可以访问我的LeetCode题解仓库：https://github.com/azl397985856/leetcode 。 目前已经37K star啦。 diff --git a/problems/60.permutation-sequence.md b/problems/60.permutation-sequence.md index 2599483ce..630c0dd96 100644 --- a/problems/60.permutation-sequence.md +++ b/problems/60.permutation-sequence.md @@ -100,8 +100,8 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(N^2)$ -- 空间复杂度：$O(N)$ +- 时间复杂度：$$O(N^2)$$ +- 空间复杂度：$$O(N)$$ 大家对此有何看法，欢迎给我留言，我有时间都会一一查看回答。更多算法套路可以访问我的 LeetCode 题解仓库：https://github.com/azl397985856/leetcode 。 目前已经 37K star 啦。 大家也可以关注我的公众号《力扣加加》带你啃下算法这块硬骨头。 diff --git a/problems/61.Rotate-List.md b/problems/61.Rotate-List.md index 50da5d837..b5fe95f00 100644 --- a/problems/61.Rotate-List.md +++ b/problems/61.Rotate-List.md @@ -271,5 +271,5 @@ class Solution **复杂度分析** -- 时间复杂度：节点最多只遍历两遍，时间复杂度为$O(N)$ -- 空间复杂度：未使用额外的空间，空间复杂度$O(1)$ +- 时间复杂度：节点最多只遍历两遍，时间复杂度为$$O(N)$$ +- 空间复杂度：未使用额外的空间，空间复杂度$$O(1)$$ diff --git a/problems/611.valid-triangle-number.md b/problems/611.valid-triangle-number.md index 5732a2c1c..95378fd4a 100644 --- a/problems/611.valid-triangle-number.md +++ b/problems/611.valid-triangle-number.md @@ -74,21 +74,21 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(N ^ 3)$，其中 N 为 数组长度。 -- 空间复杂度：$O(1)$ +- 时间复杂度：$$O(N ^ 3)$$，其中 N 为 数组长度。 +- 空间复杂度：$$O(1)$$ ## 优化的暴力法 ### 思路 -暴力法的时间复杂度为 $O(N ^ 3)$， 其中 $N$ 最大为 1000。一般来说， $O(N ^ 3)$ 的算法在数据量 <= 500 是可以 AC 的。1000 的数量级则需要考虑 $O(N ^ 2)$ 或者更好的解法。 +暴力法的时间复杂度为 $$O(N ^ 3)$$， 其中 $N$ 最大为 1000。一般来说， $$O(N ^ 3)$$ 的算法在数据量 <= 500 是可以 AC 的。1000 的数量级则需要考虑 $$O(N ^ 2)$$ 或者更好的解法。 OK，到这里了。我给大家一个干货。 应该是其他博主不太会提的。原因可能是他们不知道， 也可能是他们觉得太小儿科不需要说。 1. 由于前面我根据数据规模推测到到了解法的复杂度区间是 $N ^ 2$, $N ^ 2 * logN$，不可能是 $N$ （WHY？）。 -2. 降低时间复杂度的方法主要有： `空间换时间` 和 `排序换时间`（我们一般都是使用基于比较的排序方法）。而`排序换时间`仅仅在总体复杂度大于 $O(NlogN)$ 才适用（原因不用多说了吧？）。 +2. 降低时间复杂度的方法主要有： `空间换时间` 和 `排序换时间`（我们一般都是使用基于比较的排序方法）。而`排序换时间`仅仅在总体复杂度大于 $$O(NlogN)$$ 才适用（原因不用多说了吧？）。 -这里由于总体的时间复杂度是 $O(N ^ 3)$，因此我自然想到了`排序换时间`。当我们对 nums 进行一次排序之后，我发现： +这里由于总体的时间复杂度是 $$O(N ^ 3)$$，因此我自然想到了`排序换时间`。当我们对 nums 进行一次排序之后，我发现： - is_triangle 函数有一些判断是无效的 @@ -122,7 +122,7 @@ for i in range(n - 2): ans += k - j - 1 ``` -由于 K 不会后退，因此最内层循环总共最多执行 N 次，因此总的时间复杂度为 $O(N ^ 2)$。 +由于 K 不会后退，因此最内层循环总共最多执行 N 次，因此总的时间复杂度为 $$O(N ^ 2)$$。 > 这个复杂度分析有点像单调栈，大家可以结合起来理解。 @@ -150,7 +150,7 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(N ^ 2)$ +- 时间复杂度：$$O(N ^ 2)$$ - 空间复杂度：取决于排序算法 更多题解可以访问我的 LeetCode 题解仓库：https://github.com/azl397985856/leetcode 。 目前已经 37K star 啦。 diff --git a/problems/62.unique-paths.md b/problems/62.unique-paths.md index 5053c8914..60858ca6f 100644 --- a/problems/62.unique-paths.md +++ b/problems/62.unique-paths.md @@ -88,8 +88,8 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(M * N)$ -- 空间复杂度：$O(M * N)$ +- 时间复杂度：$$O(M * N)$$ +- 空间复杂度：$$O(M * N)$$ 由于 dp[i][j] 只依赖于左边的元素和上面的元素，因此空间复杂度可以进一步优化， 优化到 O(n). @@ -168,12 +168,12 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(M * N)$ -- 空间复杂度：$O(N)$ +- 时间复杂度：$$O(M * N)$$ +- 空间复杂度：$$O(N)$$ ## 扩展 -你可以做到比$O(M * N)$更快，比$O(N)$更省内存的算法么？这里有一份[资料](https://leetcode.com/articles/unique-paths/)可供参考。 +你可以做到比$$O(M * N)$$更快，比$$O(N)$$更省内存的算法么？这里有一份[资料](https://leetcode.com/articles/unique-paths/)可供参考。 > 提示： 考虑数学 diff --git a/problems/63.unique-paths-ii.md b/problems/63.unique-paths-ii.md index 0bb3a9bd1..f710018f5 100644 --- a/problems/63.unique-paths-ii.md +++ b/problems/63.unique-paths-ii.md @@ -108,8 +108,8 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(M * N)$ -- 空间复杂度：$O(M * N)$ +- 时间复杂度：$$O(M * N)$$ +- 空间复杂度：$$O(M * N)$$ 由于 dp[i][j] 只依赖于左边的元素和上面的元素，因此空间复杂度可以进一步优化， 优化到 O(n). @@ -154,8 +154,8 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(M * N)$ -- 空间复杂度：$O(N)$ +- 时间复杂度：$$O(M * N)$$ +- 空间复杂度：$$O(N)$$ ## 相关题目 diff --git a/problems/686.repeated-string-match.md b/problems/686.repeated-string-match.md index 4ee7e78be..7b23a3952 100644 --- a/problems/686.repeated-string-match.md +++ b/problems/686.repeated-string-match.md @@ -128,8 +128,8 @@ class Solution: **复杂度分析** -- 时间复杂度：b in a 的时间复杂度为 M + N（取决于内部算法），因此总的时间复杂度为 $O((M + N) ^ 2)$，其中 M 和 N 为 a 和 b 的长度。 -- 空间复杂度：由于使用了 set，因此空间复杂度为 $O(M +N)$，其中 M 和 N 为 a 和 b 的长度。 +- 时间复杂度：b in a 的时间复杂度为 M + N（取决于内部算法），因此总的时间复杂度为 $$O((M + N) ^ 2)$$，其中 M 和 N 为 a 和 b 的长度。 +- 空间复杂度：由于使用了 set，因此空间复杂度为 $$O(M +N)$$，其中 M 和 N 为 a 和 b 的长度。 更多题解可以访问我的 LeetCode 题解仓库：https://github.com/azl397985856/leetcode 。 目前已经 37K star 啦。 diff --git a/problems/718.maximum-length-of-repeated-subarray.md b/problems/718.maximum-length-of-repeated-subarray.md index 7cdf6a84a..cc366de89 100644 --- a/problems/718.maximum-length-of-repeated-subarray.md +++ b/problems/718.maximum-length-of-repeated-subarray.md @@ -41,7 +41,7 @@ B: [3,2,1,4,7] 这就是最经典的最长公共子序列问题。一般这种求解**两个数组或者字符串求最大或者最小**的题目都可以考虑动态规划，并且通常都定义 dp[i][j] 为 `以 A[i], B[j] 结尾的 xxx`。这道题就是：`以 A[i], B[j] 结尾的两个数组中公共的、长度最长的子数组的长度`。 算法很简单： -- 双层循环找出所有的 i, j 组合，时间复杂度 $O(m * n)$，其中 m 和 n 分别为 A 和 B 的 长度。 +- 双层循环找出所有的 i, j 组合，时间复杂度 $$O(m * n)$$，其中 m 和 n 分别为 A 和 B 的 长度。 - 如果 A[i] == B[j]，dp[i][j] = dp[i - 1][j - 1] + 1 - 否则，dp[i][j] = 0 - 循环过程记录最大值即可。 @@ -72,8 +72,8 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(m * n)$，其中 m 和 n 分别为 A 和 B 的 长度。 -- 空间复杂度：$O(m * n)$，其中 m 和 n 分别为 A 和 B 的 长度。 +- 时间复杂度：$$O(m * n)$$，其中 m 和 n 分别为 A 和 B 的 长度。 +- 空间复杂度：$$O(m * n)$$，其中 m 和 n 分别为 A 和 B 的 长度。 ## 更多 diff --git a/problems/721.accounts-merge.md b/problems/721.accounts-merge.md index e4bde5c2d..5c481bfad 100644 --- a/problems/721.accounts-merge.md +++ b/problems/721.accounts-merge.md @@ -43,9 +43,9 @@ accounts[i][j]的长度将在[1，30]的范围内。 ## 代码 -`find`, `union`, `connected` 都是典型的模板方法。 懂的同学可能也发现了，我没有做路径压缩，这直接导致 find union connected 的时间复杂度最差的情况退化到 $O(N)$。 +`find`, `union`, `connected` 都是典型的模板方法。 懂的同学可能也发现了，我没有做路径压缩，这直接导致 find union connected 的时间复杂度最差的情况退化到 $$O(N)$$。 -当然优化也不难，我们只需要给每一个顶层元素设置一个 size 用来表示连通分量的大小，这样 union 的时候我们将小的拼接到大的上即可。 另外 find 的时候我们甚至可以路径压缩，将树高限定到常数，这样时间复杂度可以降低到 $O(1)$。 +当然优化也不难，我们只需要给每一个顶层元素设置一个 size 用来表示连通分量的大小，这样 union 的时候我们将小的拼接到大的上即可。 另外 find 的时候我们甚至可以路径压缩，将树高限定到常数，这样时间复杂度可以降低到 $$O(1)$$。 ```python class UF: @@ -78,8 +78,8 @@ class Solution: **复杂度分析** -- 时间复杂度：平均 $O(logN)$，最坏的情况是 $O(N)$ -- 空间复杂度：我们使用了 parent， 因此空间复杂度为 $O(N)$ +- 时间复杂度：平均 $$O(logN)$$，最坏的情况是 $$O(N)$$ +- 空间复杂度：我们使用了 parent， 因此空间复杂度为 $$O(N)$$ 欢迎关注我的公众号《脑洞前端》获取更多更新鲜的 LeetCode 题解 diff --git a/problems/73.set-matrix-zeroes.md b/problems/73.set-matrix-zeroes.md index 800ca66d7..6d4d89045 100644 --- a/problems/73.set-matrix-zeroes.md +++ b/problems/73.set-matrix-zeroes.md @@ -264,8 +264,8 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(M * N)$ -- 空间复杂度：$O(1)$ +- 时间复杂度：$$O(M * N)$$ +- 空间复杂度：$$O(1)$$ 大家对此有何看法，欢迎给我留言，我有时间都会一一查看回答。更多算法套路可以访问我的 LeetCode 题解仓库：https://github.com/azl397985856/leetcode 。 目前已经 37K star 啦。 大家也可以关注我的公众号《力扣加加》带你啃下算法这块硬骨头。 diff --git a/problems/75.sort-colors.md b/problems/75.sort-colors.md index 844489678..f9346209b 100644 --- a/problems/75.sort-colors.md +++ b/problems/75.sort-colors.md @@ -45,7 +45,7 @@ https://leetcode-cn.com/problems/sort-colors/ - 遍历数组，统计红白蓝三色球（0，1，2）的个数 - 根据红白蓝三色球（0，1，2）的个数重排数组 -这种思路的时间复杂度：$O(n)$，需要遍历数组两次（Two pass）。 +这种思路的时间复杂度：$$O(n)$$，需要遍历数组两次（Two pass）。 ![image](https://tva1.sinaimg.cn/large/0081Kckwly1gl0hievmxyj30kl0c1t9m.jpg) @@ -79,7 +79,7 @@ https://leetcode-cn.com/problems/sort-colors/ ![](https://tva1.sinaimg.cn/large/0081Kckwly1gl0himzyeaj310m0l2wfs.jpg) -这种思路的时间复杂度也是$O(n)$, 只需要遍历数组一次。 +这种思路的时间复杂度也是$$O(n)$$, 只需要遍历数组一次。 ### 关键点解析 @@ -116,8 +116,8 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(N)$ -- 空间复杂度：$O(1)$ +- 时间复杂度：$$O(N)$$ +- 空间复杂度：$$O(1)$$ ## 相关题目 @@ -139,8 +139,8 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(N)$，其中 N 为链表长度。 -- 空间复杂度：$O(1)$。 +- 时间复杂度：$$O(N)$$，其中 N 为链表长度。 +- 空间复杂度：$$O(1)$$。 大家对此有何看法，欢迎给我留言，我有时间都会一一查看回答。更多算法套路可以访问我的 LeetCode 题解仓库：https://github.com/azl397985856/leetcode 。 目前已经 37K star 啦。 大家也可以关注我的公众号《力扣加加》带你啃下算法这块硬骨头。 diff --git a/problems/768.max-chunks-to-make-sorted-ii.md b/problems/768.max-chunks-to-make-sorted-ii.md index c7049383a..57009bea8 100644 --- a/problems/768.max-chunks-to-make-sorted-ii.md +++ b/problems/768.max-chunks-to-make-sorted-ii.md @@ -100,8 +100,8 @@ class Solution(object): **复杂度分析** -- 时间复杂度：内部 count_a 和 count_b 的比较时间复杂度也是 $O(N)$，因此总的时间复杂度为 $O(N^2)$，其中 N 为数组长度。 -- 空间复杂度：使用了两个 counter，其大小都是 N，因此空间复杂度为 $O(N)$，其中 N 为数组长度。 +- 时间复杂度：内部 count_a 和 count_b 的比较时间复杂度也是 $$O(N)$$，因此总的时间复杂度为 $$O(N^2)$$，其中 N 为数组长度。 +- 空间复杂度：使用了两个 counter，其大小都是 N，因此空间复杂度为 $$O(N)$$，其中 N 为数组长度。 ## 优化的计数 @@ -145,8 +145,8 @@ class Solution(object): **复杂度分析** -- 时间复杂度：瓶颈在于排序，因此时间复杂度为 $O(NlogN)$，其中 N 为数组长度。 -- 空间复杂度：使用了一个 counter，其大小是 N，因此空间复杂度为 $O(N)$，其中 N 为数组长度。 +- 时间复杂度：瓶颈在于排序，因此时间复杂度为 $$O(NlogN)$$，其中 N 为数组长度。 +- 空间复杂度：使用了一个 counter，其大小是 N，因此空间复杂度为 $$O(N)$$，其中 N 为数组长度。 ## 单调栈 @@ -375,8 +375,8 @@ class Solution **复杂度分析** -- 时间复杂度：$O(N)$，其中 N 为数组长度。 -- 空间复杂度：$O(N)$，其中 N 为数组长度。 +- 时间复杂度：$$O(N)$$，其中 N 为数组长度。 +- 空间复杂度：$$O(N)$$，其中 N 为数组长度。 ## 总结 diff --git a/problems/785.is-graph-bipartite.md b/problems/785.is-graph-bipartite.md index 6a08c37bc..ff40ff242 100644 --- a/problems/785.is-graph-bipartite.md +++ b/problems/785.is-graph-bipartite.md @@ -102,8 +102,8 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(N^2)$ -- 空间复杂度：$O(N)$ +- 时间复杂度：$$O(N^2)$$ +- 空间复杂度：$$O(N)$$ ## 相关问题 diff --git a/problems/80.remove-duplicates-from-sorted-array-ii.md b/problems/80.remove-duplicates-from-sorted-array-ii.md index 09bf1ab8e..5826143cb 100644 --- a/problems/80.remove-duplicates-from-sorted-array-ii.md +++ b/problems/80.remove-duplicates-from-sorted-array-ii.md @@ -103,8 +103,8 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(N)$ -- 空间复杂度：$O(1)$ +- 时间复杂度：$$O(N)$$ +- 空间复杂度：$$O(1)$$ 基于这套代码，你可以轻易地实现 k 为任意正整数的算法。 diff --git a/problems/816.ambiguous-coordinates.md b/problems/816.ambiguous-coordinates.md index ea126bd25..d67a5f02a 100644 --- a/problems/816.ambiguous-coordinates.md +++ b/problems/816.ambiguous-coordinates.md @@ -132,8 +132,8 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(N^3)$ -- 空间复杂度：$O(N^2)$ +- 时间复杂度：$$O(N^3)$$ +- 空间复杂度：$$O(N^2)$$ 更多题解可以访问我的 LeetCode 题解仓库：https://github.com/azl397985856/leetcode 。 目前已经 37K star 啦。 diff --git a/problems/820.short-encoding-of-words.md b/problems/820.short-encoding-of-words.md index 396d1b5a8..1edea8ce5 100644 --- a/problems/820.short-encoding-of-words.md +++ b/problems/820.short-encoding-of-words.md @@ -124,8 +124,8 @@ class Solution: **_复杂度分析_** -- 时间复杂度：$O(N)$，其中 N 为单词长度列表中的总字符数，比如["time", "me"]，就是 4 + 2 = 6。 -- 空间复杂度：$O(N)$，其中 N 为单词长度列表中的总字符数，比如["time", "me"]，就是 4 + 2 = 6。 +- 时间复杂度：$$O(N)$$，其中 N 为单词长度列表中的总字符数，比如["time", "me"]，就是 4 + 2 = 6。 +- 空间复杂度：$$O(N)$$，其中 N 为单词长度列表中的总字符数，比如["time", "me"]，就是 4 + 2 = 6。 大家也可以关注我的公众号《力扣加加》获取更多更新鲜的 LeetCode 题解 diff --git a/problems/821.shortest-distance-to-a-character.md b/problems/821.shortest-distance-to-a-character.md index 3a934366c..3c5ddc1ec 100644 --- a/problems/821.shortest-distance-to-a-character.md +++ b/problems/821.shortest-distance-to-a-character.md @@ -63,8 +63,8 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(N^2)$ -- 空间复杂度：$O(1)$ +- 时间复杂度：$$O(N^2)$$ +- 空间复杂度：$$O(1)$$ 由于题目的数据范围是 $10^4$，因此通过所有的测试用例是没有问题的。 @@ -93,8 +93,8 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(N)$ -- 空间复杂度：$O(N)$ +- 时间复杂度：$$O(N)$$ +- 空间复杂度：$$O(N)$$ 实际上，我们根本不需要栈来存储。原因很简单，那就是每次我们碰到目标字符 C 的时候， 我们就把栈**全部清空**了，因此我们用一个变量标识即可，具体参考后面的代码区。 @@ -240,8 +240,8 @@ class Solution **复杂度分析** -- 时间复杂度：$O(N)$ -- 空间复杂度：$O(1)$ +- 时间复杂度：$$O(N)$$ +- 空间复杂度：$$O(1)$$ 大家对此有何看法，欢迎给我留言，我有时间都会一一查看回答。更多算法套路可以访问我的 LeetCode 题解仓库：https://github.com/azl397985856/leetcode 。 目前已经 37K star 啦。 diff --git a/problems/84.largest-rectangle-in-histogram.md b/problems/84.largest-rectangle-in-histogram.md index c779231cf..581cbe7ed 100644 --- a/problems/84.largest-rectangle-in-histogram.md +++ b/problems/84.largest-rectangle-in-histogram.md @@ -60,8 +60,8 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(N^2)$ -- 空间复杂度：$O(1)$ +- 时间复杂度：$$O(N^2)$$ +- 空间复杂度：$$O(1)$$ ## 暴力枚举 - 中心扩展法（TLE） @@ -100,8 +100,8 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(N^2)$ -- 空间复杂度：$O(N)$ +- 时间复杂度：$$O(N^2)$$ +- 空间复杂度：$$O(N)$$ ## 优化中心扩展法（Accepted） @@ -135,8 +135,8 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(N)$ -- 空间复杂度：$O(N)$ +- 时间复杂度：$$O(N)$$ +- 空间复杂度：$$O(N)$$ ## 单调栈（Accepted） @@ -146,7 +146,7 @@ class Solution: 从左到右遍历柱子，对于每一个柱子，我们想找到第一个高度小于它的柱子，那么我们就可以使用一个单调递增栈来实现。 如果柱子大于栈顶的柱子，那么说明不是我们要找的柱子，我们把它塞进去继续遍历，如果比栈顶小，那么我们就找到了第一个小于的柱子。 **对于栈顶元素，其右边第一个小于它的就是当前遍历到的柱子，左边第一个小于它的就是栈中下一个要被弹出的元素**，因此以当前栈顶为最小柱子的面积为**当前栈顶的柱子高度 \* (当前遍历到的柱子索引 - 1 - 栈中下一个要被弹出的元素索引 - 1 + 1)** -这种方法只需要遍历一次，并用一个栈。由于每一个元素最多进栈出栈一次，因此时间和空间复杂度都是$O(N)$。 +这种方法只需要遍历一次，并用一个栈。由于每一个元素最多进栈出栈一次，因此时间和空间复杂度都是$$O(N)$$。 为了统一算法逻辑，减少边界处理，我在 heights 首尾添加了两个哨兵元素，**这样我们可以保证所有的柱子都会出栈**。 @@ -165,8 +165,8 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(N)$ -- 空间复杂度：$O(N)$ +- 时间复杂度：$$O(N)$$ +- 空间复杂度：$$O(N)$$ 2020-05-30 更新： diff --git a/problems/85.maximal-rectangle.md b/problems/85.maximal-rectangle.md index e6d36059c..da22a83e5 100644 --- a/problems/85.maximal-rectangle.md +++ b/problems/85.maximal-rectangle.md @@ -84,8 +84,8 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(M * N)$ -- 空间复杂度：$O(N)$ +- 时间复杂度：$$O(M * N)$$ +- 空间复杂度：$$O(N)$$ 欢迎关注我的公众号《脑洞前端》获取更多更新鲜的 LeetCode 题解 diff --git a/problems/86.partition-list.md b/problems/86.partition-list.md index 6837f91bf..c839c6197 100644 --- a/problems/86.partition-list.md +++ b/problems/86.partition-list.md @@ -131,8 +131,8 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(N)$ -- 空间复杂度：$O(1)$ +- 时间复杂度：$$O(N)$$ +- 空间复杂度：$$O(1)$$ 大家对此有何看法，欢迎给我留言，我有时间都会一一查看回答。更多算法套路可以访问我的 LeetCode 题解仓库：https://github.com/azl397985856/leetcode 。 目前已经 37K star 啦。 大家也可以关注我的公众号《力扣加加》带你啃下算法这块硬骨头。 diff --git a/problems/874.walking-robot-simulation.md b/problems/874.walking-robot-simulation.md index c5ee18e3c..edfea1b29 100644 --- a/problems/874.walking-robot-simulation.md +++ b/problems/874.walking-robot-simulation.md @@ -59,8 +59,8 @@ https://leetcode-cn.com/problems/walking-robot-simulation/submissions/ > 我实际测试了一下，确实会超时 -- 一种方式是使用排序，然后二分查找，如果采用基于比较的排序算法，那么这种算法的瓶颈在于排序本身，也就是$O(NlogN)$。 -- 另一种方式是使用集合，将 obstacles 放入集合，然后需要的时候进行查询，查询的时候的时间复杂度为$O(1)$。 +- 一种方式是使用排序，然后二分查找，如果采用基于比较的排序算法，那么这种算法的瓶颈在于排序本身，也就是$$O(NlogN)$$。 +- 另一种方式是使用集合，将 obstacles 放入集合，然后需要的时候进行查询，查询的时候的时间复杂度为$$O(1)$$。 这里我们采用第二种方式。 @@ -126,8 +126,8 @@ class Solution: ``` **复杂度分析** -- 时间复杂度：$O(N * M)$, 其中 N 为 commands 的长度， M 为 commands 数组的平均值。 -- 空间复杂度：$O(obstacles)$ +- 时间复杂度：$$O(N * M)$$, 其中 N 为 commands 的长度， M 为 commands 数组的平均值。 +- 空间复杂度：$$O(obstacles)$$ 更多题解可以访问我的LeetCode题解仓库：https://github.com/azl397985856/leetcode 。 目前已经37K star啦。 diff --git a/problems/875.koko-eating-bananas.md b/problems/875.koko-eating-bananas.md index 0810ecee1..8d0c5679b 100644 --- a/problems/875.koko-eating-bananas.md +++ b/problems/875.koko-eating-bananas.md @@ -48,7 +48,7 @@ piles.length <= H <= 10^9 ## 思路 -符合直觉的做法是，选择最大的堆的香蕉数，然后试一下能不能行，如果不行则直接返回上次计算的结果，如果行，我们减少 1 个香蕉，试试行不行，依次类推。计算出刚好不行的即可。这种解法的时间复杂度比较高，为 $O(N * M)$，其中 N 为 piles 长度， M 为 Piles 中最大的数。。 +符合直觉的做法是，选择最大的堆的香蕉数，然后试一下能不能行，如果不行则直接返回上次计算的结果，如果行，我们减少 1 个香蕉，试试行不行，依次类推。计算出刚好不行的即可。这种解法的时间复杂度比较高，为 $$O(N * M)$$，其中 N 为 piles 长度， M 为 Piles 中最大的数。。 这道题如果能看出来是二分法解决，那么其实很简单。为什么它是二分问题呢？我这里画了个图，我相信你看了就明白了。 @@ -121,8 +121,8 @@ var minEatingSpeed = function (piles, H) { **复杂度分析** -- 时间复杂度：$O(max(N, N * logM))$，其中 N 为 piles 长度， M 为 Piles 中最大的数。 -- 空间复杂度：$O(1)$ +- 时间复杂度：$$O(max(N, N * logM))$$，其中 N 为 piles 长度， M 为 Piles 中最大的数。 +- 空间复杂度：$$O(1)$$ ## 模板 diff --git a/problems/88.merge-sorted-array.md b/problems/88.merge-sorted-array.md index fbc1ca7fc..a8358bf73 100644 --- a/problems/88.merge-sorted-array.md +++ b/problems/88.merge-sorted-array.md @@ -227,8 +227,8 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(M + N)$ -- 空间复杂度：$O(1)$ +- 时间复杂度：$$O(M + N)$$ +- 空间复杂度：$$O(1)$$ 大家对此有何看法，欢迎给我留言，我有时间都会一一查看回答。更多算法套路可以访问我的 LeetCode 题解仓库：https://github.com/azl397985856/leetcode 。 目前已经 37K star 啦。 diff --git a/problems/886.possible-bipartition.md b/problems/886.possible-bipartition.md index 44196b43d..b5caba92d 100644 --- a/problems/886.possible-bipartition.md +++ b/problems/886.possible-bipartition.md @@ -139,8 +139,8 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(N^2)$ -- 空间复杂度：$O(N)$ +- 时间复杂度：$$O(N^2)$$ +- 空间复杂度：$$O(N)$$ ## 相关问题 diff --git a/problems/887.super-egg-drop.md b/problems/887.super-egg-drop.md index a08636432..e9c199b2f 100644 --- a/problems/887.super-egg-drop.md +++ b/problems/887.super-egg-drop.md @@ -271,8 +271,8 @@ var superEggDrop = function (K, N) { **复杂度分析** -- 时间复杂度：$O(m * K)$，其中 m 为答案。 -- 空间复杂度：$O(K * N)$ +- 时间复杂度：$$O(m * K)$$，其中 m 为答案。 +- 空间复杂度：$$O(K * N)$$ 对为什么用加法的同学有疑问的可以看我写的[《对《丢鸡蛋问题》的一点补充》](https://lucifer.ren/blog/2020/08/30/887.super-egg-drop-extension/)。 diff --git a/problems/895.maximum-frequency-stack.md b/problems/895.maximum-frequency-stack.md index 0d6145fc9..ca16979fb 100644 --- a/problems/895.maximum-frequency-stack.md +++ b/problems/895.maximum-frequency-stack.md @@ -114,8 +114,8 @@ class FreqStack: **复杂度分析** -- 时间复杂度：push 和 pop 平均时间复杂度是 $O(1)$ -- 空间复杂度：$O(N)$，其中N为数字的总数。 +- 时间复杂度：push 和 pop 平均时间复杂度是 $$O(1)$$ +- 空间复杂度：$$O(N)$$，其中N为数字的总数。 大家也可以关注我的公众号《脑洞前端》获取更多更新鲜的LeetCode题解 diff --git a/problems/91.decode-ways.md b/problems/91.decode-ways.md index 6fde5b247..39e98dacd 100644 --- a/problems/91.decode-ways.md +++ b/problems/91.decode-ways.md @@ -115,8 +115,8 @@ var numDecodings = function (s) { **复杂度分析** -- 时间复杂度：$O(N)$ -- 空间复杂度：$O(N)$ +- 时间复杂度：$$O(N)$$ +- 空间复杂度：$$O(N)$$ ## 扩展 diff --git a/problems/92.reverse-linked-list-ii.md b/problems/92.reverse-linked-list-ii.md index a4ac6aa83..616139ec5 100644 --- a/problems/92.reverse-linked-list-ii.md +++ b/problems/92.reverse-linked-list-ii.md @@ -247,8 +247,8 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(N)$ -- 空间复杂度：$O(1)$ +- 时间复杂度：$$O(N)$$ +- 空间复杂度：$$O(1)$$ ## 相关题目 diff --git a/problems/935.knight-dialer.md b/problems/935.knight-dialer.md index 334bb70d5..c619b6c8d 100644 --- a/problems/935.knight-dialer.md +++ b/problems/935.knight-dialer.md @@ -96,8 +96,8 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(N)$ -- 空间复杂度：$O(N)$ +- 时间复杂度：$$O(N)$$ +- 空间复杂度：$$O(N)$$ ## 朴素遍历 @@ -119,8 +119,8 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(N)$ -- 空间复杂度：$O(1)$ +- 时间复杂度：$$O(N)$$ +- 空间复杂度：$$O(1)$$ 更多题解可以访问我的 LeetCode 题解仓库：https://github.com/azl397985856/leetcode 。 目前已经 37K star 啦。 diff --git a/problems/96.unique-binary-search-trees.md b/problems/96.unique-binary-search-trees.md index 4524cb344..0eb670089 100644 --- a/problems/96.unique-binary-search-trees.md +++ b/problems/96.unique-binary-search-trees.md @@ -95,8 +95,8 @@ class Solution: return res ``` **复杂度分析** -- 时间复杂度：一层循环是 N，另外递归深度是 N，因此总的时间复杂度是 $O(N^2)$ -- 空间复杂度：递归的栈深度和visited 的大小都是 N，因此总的空间复杂度为 $O(N)$ +- 时间复杂度：一层循环是 N，另外递归深度是 N，因此总的时间复杂度是 $$O(N^2)$$ +- 空间复杂度：递归的栈深度和visited 的大小都是 N，因此总的空间复杂度为 $$O(N)$$ ## 相关题目 diff --git a/problems/978.longest-turbulent-subarray.md b/problems/978.longest-turbulent-subarray.md index 9207c52a6..1f781e16f 100644 --- a/problems/978.longest-turbulent-subarray.md +++ b/problems/978.longest-turbulent-subarray.md @@ -85,8 +85,8 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(N)$ -- 空间复杂度：$O(1)$ +- 时间复杂度：$$O(N)$$ +- 空间复杂度：$$O(1)$$ 更多题解可以访问我的 LeetCode 题解仓库：https://github.com/azl397985856/leetcode 。 目前已经 37K star 啦。 diff --git a/problems/98.validate-binary-search-tree.md b/problems/98.validate-binary-search-tree.md index 4c519c6ae..a6aff0013 100644 --- a/problems/98.validate-binary-search-tree.md +++ b/problems/98.validate-binary-search-tree.md @@ -354,8 +354,8 @@ function valid(root, min = -Infinity, max = Infinity) { **复杂度分析** -- 时间复杂度：$O(N)$ -- 空间复杂度：$O(N)$ +- 时间复杂度：$$O(N)$$ +- 空间复杂度：$$O(N)$$ ## 相关题目 diff --git a/problems/987.vertical-order-traversal-of-a-binary-tree.md b/problems/987.vertical-order-traversal-of-a-binary-tree.md index 1423ecc19..86f7b8e1a 100644 --- a/problems/987.vertical-order-traversal-of-a-binary-tree.md +++ b/problems/987.vertical-order-traversal-of-a-binary-tree.md @@ -100,7 +100,7 @@ ok，如果这个你懂了，我们尝试加上面的两个限制加上去。 - 哈希表第二层的 key 总个数是树的高度。 - 哈希表值的总长度是树的节点数。 -也就是说哈希表的总容量和树的总的节点数是同阶的。因此空间复杂度为 $O(N)$， 排序的复杂度大致为 $NlogN$，其中 N 为树的节点总数。 +也就是说哈希表的总容量和树的总的节点数是同阶的。因此空间复杂度为 $$O(N)$$， 排序的复杂度大致为 $NlogN$，其中 N 为树的节点总数。 ## 代码 @@ -239,5 +239,5 @@ public: **复杂度分析** -- 时间复杂度：$O(NlogN)$，其中 N 为树的节点总数。 -- 空间复杂度：$O(N)$，其中 N 为树的节点总数。 +- 时间复杂度：$$O(NlogN)$$，其中 N 为树的节点总数。 +- 空间复杂度：$$O(N)$$，其中 N 为树的节点总数。 diff --git a/problems/binode-lcci.md b/problems/binode-lcci.md index 83e886ee3..0822a8186 100644 --- a/problems/binode-lcci.md +++ b/problems/binode-lcci.md @@ -127,8 +127,8 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(N)$，其中 N 为树的节点总数。 -- 空间复杂度：$O(h)$，其中 h 为树的高度。 +- 时间复杂度：$$O(N)$$，其中 N 为树的节点总数。 +- 空间复杂度：$$O(h)$$，其中 h 为树的高度。 ## 相关题目 diff --git a/problems/get-kth-magic-number-lcci.md b/problems/get-kth-magic-number-lcci.md index 43fcc7708..a7e45f540 100644 --- a/problems/get-kth-magic-number-lcci.md +++ b/problems/get-kth-magic-number-lcci.md @@ -84,8 +84,8 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(k)$ -- 空间复杂度：$O(k)$ +- 时间复杂度：$$O(k)$$ +- 空间复杂度：$$O(k)$$ 大家对此有何看法，欢迎给我留言，我有时间都会一一查看回答。更多算法套路可以访问我的 LeetCode 题解仓库：https://github.com/azl397985856/leetcode 。 目前已经 36K star 啦。 大家也可以关注我的公众号《力扣加加》带你啃下算法这块硬骨头。 diff --git a/selected/LCS.md b/selected/LCS.md index c7c492e43..eb6483425 100644 --- a/selected/LCS.md +++ b/selected/LCS.md @@ -50,7 +50,7 @@ B: [3,2,1,4,7] 算法很简单： -- 双层循环找出所有的 i, j 组合，时间复杂度 $O(m * n)$，其中 m 和 n 分别为 A 和 B 的 长度。 +- 双层循环找出所有的 i, j 组合，时间复杂度 $$O(m * n)$$，其中 m 和 n 分别为 A 和 B 的 长度。 - 如果 A[i] == B[j]，dp[i][j] = dp[i - 1][j - 1] + 1 - 否则，dp[i][j] = 0 - 循环过程记录最大值即可。 @@ -83,8 +83,8 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(m * n)$，其中 m 和 n 分别为 A 和 B 的 长度。 -- 空间复杂度：$O(m * n)$，其中 m 和 n 分别为 A 和 B 的 长度。 +- 时间复杂度：$$O(m * n)$$，其中 m 和 n 分别为 A 和 B 的 长度。 +- 空间复杂度：$$O(m * n)$$，其中 m 和 n 分别为 A 和 B 的 长度。 > 二分查找也是可以的，不过并不容易想到，大家可以试试。 @@ -166,8 +166,8 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(m * n)$，其中 m 和 n 分别为 A 和 B 的 长度。 -- 空间复杂度：$O(m * n)$，其中 m 和 n 分别为 A 和 B 的 长度。 +- 时间复杂度：$$O(m * n)$$，其中 m 和 n 分别为 A 和 B 的 长度。 +- 空间复杂度：$$O(m * n)$$，其中 m 和 n 分别为 A 和 B 的 长度。 ## 1035. 不相交的线 @@ -246,8 +246,8 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(m * n)$，其中 m 和 n 分别为 A 和 B 的 长度。 -- 空间复杂度：$O(m * n)$，其中 m 和 n 分别为 A 和 B 的 长度。 +- 时间复杂度：$$O(m * n)$$，其中 m 和 n 分别为 A 和 B 的 长度。 +- 空间复杂度：$$O(m * n)$$，其中 m 和 n 分别为 A 和 B 的 长度。 ## 总结 diff --git a/selected/LIS.md b/selected/LIS.md index ce7dd1686..37b2df3e2 100644 --- a/selected/LIS.md +++ b/selected/LIS.md @@ -88,8 +88,8 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(N ^ 2)$ -- 空间复杂度：$O(N)$ +- 时间复杂度：$$O(N ^ 2)$$ +- 空间复杂度：$$O(N)$$ ## 435. 无重叠区间 @@ -175,8 +175,8 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(N ^ 2)$ -- 空间复杂度：$O(N)$ +- 时间复杂度：$$O(N ^ 2)$$ +- 空间复杂度：$$O(N)$$ ## 646. 最长数对链 @@ -231,8 +231,8 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(N ^ 2)$ -- 空间复杂度：$O(N)$ +- 时间复杂度：$$O(N ^ 2)$$ +- 空间复杂度：$$O(N)$$ ## 452. 用最少数量的箭引爆气球 @@ -289,8 +289,8 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(N ^ 2)$ -- 空间复杂度：$O(N)$ +- 时间复杂度：$$O(N ^ 2)$$ +- 空间复杂度：$$O(N)$$ ## More diff --git a/selected/a-deleted.md b/selected/a-deleted.md index 97c67c73b..196714998 100644 --- a/selected/a-deleted.md +++ b/selected/a-deleted.md @@ -132,8 +132,8 @@ class Solution(object): **_复杂度分析_** -- 时间复杂度：虽然内层还有一个 while 循环，但是由于每个数字最多仅会入栈出栈一次，因此时间复杂度仍然为 $O(N)$，其中 $N$ 为数字长度。 -- 空间复杂度：我们使用了额外的栈来存储数字，因此空间复杂度为 $O(N)$，其中 $N$ 为数字长度。 +- 时间复杂度：虽然内层还有一个 while 循环，但是由于每个数字最多仅会入栈出栈一次，因此时间复杂度仍然为 $$O(N)$$，其中 $N$ 为数字长度。 +- 空间复杂度：我们使用了额外的栈来存储数字，因此空间复杂度为 $$O(N)$$，其中 $N$ 为数字长度。 > 提示： 如果题目改成求删除 k 个字符之后的最大数，我们只需要将 stack[-1] > digit 中的大于号改成小于号即可。 @@ -195,13 +195,13 @@ class Solution: **_复杂度分析_** -- 时间复杂度：由于判断当前字符是否在栈上存在需要 $O(N)$ 的时间，因此总的时间复杂度就是 $O(N ^ 2)$，其中 $N$ 为字符串长度。 -- 空间复杂度：我们使用了额外的栈来存储数字，因此空间复杂度为 $O(N)$，其中 $N$ 为字符串长度。 +- 时间复杂度：由于判断当前字符是否在栈上存在需要 $$O(N)$$ 的时间，因此总的时间复杂度就是 $$O(N ^ 2)$$，其中 $N$ 为字符串长度。 +- 空间复杂度：我们使用了额外的栈来存储数字，因此空间复杂度为 $$O(N)$$，其中 $N$ 为字符串长度。 查询给定字符是否在一个序列中存在的方法。根本上来说，有两种可能： -- 有序序列： 可以二分法，时间复杂度大致是 $O(N)$。 -- 无序序列： 可以使用遍历的方式，最坏的情况下时间复杂度为 $O(N)$。我们也可以使用空间换时间的方式，使用 $N$的空间 换取 $O(1)$的时间复杂度。 +- 有序序列： 可以二分法，时间复杂度大致是 $$O(N)$$。 +- 无序序列： 可以使用遍历的方式，最坏的情况下时间复杂度为 $$O(N)$$。我们也可以使用空间换时间的方式，使用 $N$的空间 换取 $$O(1)$$的时间复杂度。 由于本题中的 stack 并不是有序的，因此我们的优化点考虑空间换时间。而由于每种字符仅可以出现一次，这里使用 hashset 即可。 @@ -226,8 +226,8 @@ class Solution: **_复杂度分析_** -- 时间复杂度：$O(N)$，其中 $N$ 为字符串长度。 -- 空间复杂度：我们使用了额外的栈和 hashset，因此空间复杂度为 $O(N)$，其中 $N$ 为字符串长度。 +- 时间复杂度：$$O(N)$$，其中 $N$ 为字符串长度。 +- 空间复杂度：我们使用了额外的栈和 hashset，因此空间复杂度为 $$O(N)$$，其中 $N$ 为字符串长度。 > LeetCode 《1081. 不同字符的最小子序列》 和本题一样，不再赘述。 @@ -330,8 +330,8 @@ A < B # False 具体算法： -- 从 nums1 中 取 $min(i, len(nums1))$ 个数形成新的数组 A（取的逻辑同第一题），其中 i 等于 0,1,2, ... k。 -- 从 nums2 中 对应取 $min(j, len(nums2))$ 个数形成新的数组 B（取的逻辑同第一题），其中 j 等于 k - i。 +- 从 nums1 中 取 $$min(i, len(nums1))$$ 个数形成新的数组 A（取的逻辑同第一题），其中 i 等于 0,1,2, ... k。 +- 从 nums2 中 对应取 $$min(j, len(nums2))$$ 个数形成新的数组 B（取的逻辑同第一题），其中 j 等于 k - i。 - 将 A 和 B 按照上面的 merge 方法合并 - 上面我们暴力了 k 种组合情况，我们只需要将 k 种情况取出最大值即可。 @@ -364,8 +364,8 @@ class Solution: **_复杂度分析_** -- 时间复杂度：pick_max 的时间复杂度为 $O(M + N)$ ，其中 $M$ 为 nums1 的长度，$N$ 为 nums2 的长度。 merge 的时间复杂度为 $O(k)$，再加上外层遍历所有的 k 中可能性。因此总的时间复杂度为 $O(k^2 * (M + N))$。 -- 空间复杂度：我们使用了额外的 stack 和 ans 数组，因此空间复杂度为 $O(max(M, N, k))$，其中 $M$ 为 nums1 的长度，$N$ 为 nums2 的长度。 +- 时间复杂度：pick_max 的时间复杂度为 $$O(M + N)$$ ，其中 $M$ 为 nums1 的长度，$N$ 为 nums2 的长度。 merge 的时间复杂度为 $$O(k)$$，再加上外层遍历所有的 k 中可能性。因此总的时间复杂度为 $$O(k^2 * (M + N))$$。 +- 空间复杂度：我们使用了额外的 stack 和 ans 数组，因此空间复杂度为 $$O(max(M, N, k))$$，其中 $M$ 为 nums1 的长度，$N$ 为 nums2 的长度。 ## 总结 diff --git a/selected/atMostK.md b/selected/atMostK.md index f4bcf016b..b9c257766 100644 --- a/selected/atMostK.md +++ b/selected/atMostK.md @@ -52,8 +52,8 @@ function countSubArray(nums) { **复杂度分析** -- 时间复杂度：$O(N)$，其中 N 为数组长度。 -- 空间复杂度：$O(1)$ +- 时间复杂度：$$O(N)$$，其中 N 为数组长度。 +- 空间复杂度：$$O(1)$$ 而由于以索引为 i 结尾的子数组个数就是 i + 1，因此这道题可以直接用等差数列求和公式 `(1 + n) * n / 2`，其中 n 数组长度。 @@ -84,8 +84,8 @@ function countSubArray(nums) { **复杂度分析** -- 时间复杂度：$O(N)$，其中 N 为数组长度。 -- 空间复杂度：$O(1)$ +- 时间复杂度：$$O(N)$$，其中 N 为数组长度。 +- 空间复杂度：$$O(1)$$ 如果我值差只要大于 1 就行呢？其实改下符号就行了，这不就是求上升子序列个数么？这里不再继续赘述， 大家可以自己试试。 @@ -116,8 +116,8 @@ function countSubArray(k, nums) { **复杂度分析** -- 时间复杂度：$O(N)$，其中 N 为数组长度。 -- 空间复杂度：$O(1)$ +- 时间复杂度：$$O(N)$$，其中 N 为数组长度。 +- 空间复杂度：$$O(1)$$ ### 母题 4 @@ -290,8 +290,8 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(N)$，其中 $N$ 为字符串 p 的长度。 -- 空间复杂度：由于最多存储 26 个字母， 因此空间实际上是常数，故空间复杂度为 $O(1)$。 +- 时间复杂度：$$O(N)$$，其中 $N$ 为字符串 p 的长度。 +- 空间复杂度：由于最多存储 26 个字母， 因此空间实际上是常数，故空间复杂度为 $$O(1)$$。 ## 795. 区间子数组个数（中等） @@ -349,8 +349,8 @@ class Solution: **_复杂度分析_** -- 时间复杂度：$O(N)$，其中 $N$ 为数组长度。 -- 空间复杂度：$O(1)$。 +- 时间复杂度：$$O(N)$$，其中 $N$ 为数组长度。 +- 空间复杂度：$$O(1)$$。 ## 904. 水果成篮（中等） @@ -437,8 +437,8 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(N)$，其中 $N$ 为数组长度。 -- 空间复杂度：$O(k)$。 +- 时间复杂度：$$O(N)$$，其中 $N$ 为数组长度。 +- 空间复杂度：$$O(k)$$。 ## 992. K 个不同整数的子数组（困难） @@ -510,8 +510,8 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(N)$，中 $N$ 为数组长度。 -- 空间复杂度：$O(k)$。 +- 时间复杂度：$$O(N)$$，中 $N$ 为数组长度。 +- 空间复杂度：$$O(k)$$。 ## 1109. 航班预订统计（中等） @@ -594,8 +594,8 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(N)$，中 $N$ 为数组长度。 -- 空间复杂度：$O(N)$。 +- 时间复杂度：$$O(N)$$，中 $N$ 为数组长度。 +- 空间复杂度：$$O(N)$$。 ## 总结 diff --git a/selected/byte-dance-algo-ex-2017.md b/selected/byte-dance-algo-ex-2017.md index 6bf556d9d..ccf3e858d 100644 --- a/selected/byte-dance-algo-ex-2017.md +++ b/selected/byte-dance-algo-ex-2017.md @@ -119,8 +119,8 @@ print(cnt + 3 - cur) **复杂度分析** -- 时间复杂度：由于使用了排序， 因此时间复杂度为 $O(NlogN)$。（假设使用了基于比较的排序） -- 空间复杂度：$O(1)$ +- 时间复杂度：由于使用了排序， 因此时间复杂度为 $$O(NlogN)$$。（假设使用了基于比较的排序） +- 空间复杂度：$$O(1)$$ ## 2. 异或 @@ -311,8 +311,8 @@ print(ans // 2) **复杂度分析** -- 时间复杂度：$O(N)$ -- 空间复杂度：$O(N)$ +- 时间复杂度：$$O(N)$$ +- 空间复杂度：$$O(N)$$ ## 3. 字典序 @@ -367,8 +367,8 @@ print(sorted(nums)[m - 1]) **复杂度分析** -- 时间复杂度：取决于排序算法， 不妨认为是 $O(NlogN)$ -- 空间复杂度: $O(N)$ +- 时间复杂度：取决于排序算法， 不妨认为是 $$O(NlogN)$$ +- 空间复杂度: $$O(N)$$ 这种算法可以 pass 50 % case。 @@ -386,7 +386,7 @@ print(sorted(nums)[m - 1]) 如图黄色部分， 表示字典序的顺序，注意箭头的方向。因此本质上，**求字典序第 m 个数， 就是求这棵树的前序遍历的第 m 个节点。** -因此一种优化思路就是构建一颗这样的树，然后去遍历。 构建的复杂度是 $O(N)$，遍历的复杂度是 $O(M)$。因此这种算法的复杂度可以达到 $O(max(m, n))$ ，由于 n >= m，因此就是 $O(N)$。 +因此一种优化思路就是构建一颗这样的树，然后去遍历。 构建的复杂度是 $$O(N)$$，遍历的复杂度是 $$O(M)$$。因此这种算法的复杂度可以达到 $$O(max(m, n))$$ ，由于 n >= m，因此就是 $$O(N)$$。 实际上， 这样的优化算法依然是无法 AC 全部测试用例的，会超内存限制。 因此我们的思路只能是不使用 N 的空间去构造树。想想也知道， 由于 N 最大可能为 10^18，一个数按照 4 字节来算， 那么这就有 400000000 字节，大约是 381 M，这是不能接受的。 @@ -419,7 +419,7 @@ ok，铺垫地差不多了。 接下来，我们的重点是**如何计算给定节点的孩子节点的个数**。 -这个过程和完全二叉树计算节点个数并无二致，这个算法的时间复杂度应该是 $O(logN*logN)$。 如果不会的同学，可以参考力扣原题： [222. 完全二叉树的节点个数](https://leetcode-cn.com/problems/count-complete-tree-nodes/ "22. 完全二叉树的节点个数]") ，这是一个难度为中等的题目。 +这个过程和完全二叉树计算节点个数并无二致，这个算法的时间复杂度应该是 $$O(logN*logN)$$。 如果不会的同学，可以参考力扣原题： [222. 完全二叉树的节点个数](https://leetcode-cn.com/problems/count-complete-tree-nodes/ "22. 完全二叉树的节点个数]") ，这是一个难度为中等的题目。 > 因此这道题本身被划分为 hard，一点都不为过。 @@ -452,8 +452,8 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(logN * log N)$ -- 空间复杂度：$O(logN)$ +- 时间复杂度：$$O(logN * log N)$$ +- 空间复杂度：$$O(logN)$$ 而这道题， 我们可以更简单和高效。 @@ -512,8 +512,8 @@ print(findKthNumber(n, m)) **复杂度分析** -- 时间复杂度：$O(logM * log N)$ -- 空间复杂度：$O(1)$ +- 时间复杂度：$$O(logM * log N)$$ +- 空间复杂度：$$O(1)$$ ## 总结 diff --git a/selected/byte-dance-algo-ex.md b/selected/byte-dance-algo-ex.md index d159f0db0..fb49822a9 100644 --- a/selected/byte-dance-algo-ex.md +++ b/selected/byte-dance-algo-ex.md @@ -89,8 +89,8 @@ for i in range(t): **复杂度分析** -- 时间复杂度：$O(t)$ -- 空间复杂度：$O(t)$ +- 时间复杂度：$$O(t)$$ +- 空间复杂度：$$O(t)$$ ### 小结 @@ -249,8 +249,8 @@ print(max(ans, j - i + 1)) **复杂度分析** -- 时间复杂度：$O(N)$ -- 空间复杂度：$O(1)$ +- 时间复杂度：$$O(N)$$ +- 空间复杂度：$$O(1)$$ ### 小结 diff --git a/selected/construct-binary-tree.md b/selected/construct-binary-tree.md index 90b89e31b..3f1a70389 100644 --- a/selected/construct-binary-tree.md +++ b/selected/construct-binary-tree.md @@ -84,8 +84,8 @@ class Solution: **复杂度分析** -- 时间复杂度：由于每次递归我们的 inorder 和 preorder 的总数都会减 1，因此我们要递归 N 次，故时间复杂度为 $O(N)$，其中 N 为节点个数。 -- 空间复杂度：我们使用了递归，也就是借助了额外的栈空间来完成， 由于栈的深度为 N，因此总的空间复杂度为 $O(N)$，其中 N 为节点个数。 +- 时间复杂度：由于每次递归我们的 inorder 和 preorder 的总数都会减 1，因此我们要递归 N 次，故时间复杂度为 $$O(N)$$，其中 N 为节点个数。 +- 空间复杂度：我们使用了递归，也就是借助了额外的栈空间来完成， 由于栈的深度为 N，因此总的空间复杂度为 $$O(N)$$，其中 N 为节点个数。 > 空间复杂度忽略了开辟数组的内存消耗。 @@ -162,8 +162,8 @@ class Solution: **复杂度分析** -- 时间复杂度：由于每次递归我们的 inorder 和 postorder 的总数都会减 1，因此我们要递归 N 次，故时间复杂度为 $O(N)$，其中 N 为节点个数。 -- 空间复杂度：我们使用了递归，也就是借助了额外的栈空间来完成， 由于栈的深度为 N，因此总的空间复杂度为 $O(N)$，其中 N 为节点个数。 +- 时间复杂度：由于每次递归我们的 inorder 和 postorder 的总数都会减 1，因此我们要递归 N 次，故时间复杂度为 $$O(N)$$，其中 N 为节点个数。 +- 空间复杂度：我们使用了递归，也就是借助了额外的栈空间来完成， 由于栈的深度为 N，因此总的空间复杂度为 $$O(N)$$，其中 N 为节点个数。 > 空间复杂度忽略了开辟数组的内存消耗。 @@ -227,8 +227,8 @@ class Solution: **复杂度分析** -- 时间复杂度：由于每次递归我们的 postorder 和 preorder 的总数都会减 1，因此我们要递归 N 次，故时间复杂度为 $O(N)$，其中 N 为节点个数。 -- 空间复杂度：我们使用了递归，也就是借助了额外的栈空间来完成， 由于栈的深度为 N，因此总的空间复杂度为 $O(N)$，其中 N 为节点个数。 +- 时间复杂度：由于每次递归我们的 postorder 和 preorder 的总数都会减 1，因此我们要递归 N 次，故时间复杂度为 $$O(N)$$，其中 N 为节点个数。 +- 空间复杂度：我们使用了递归，也就是借助了额外的栈空间来完成， 由于栈的深度为 N，因此总的空间复杂度为 $$O(N)$$，其中 N 为节点个数。 > 空间复杂度忽略了开辟数组的内存消耗。 diff --git a/selected/mother-01.md b/selected/mother-01.md index 05dcea61e..12117128c 100644 --- a/selected/mother-01.md +++ b/selected/mother-01.md @@ -56,8 +56,8 @@ def f(nums1, nums2): **复杂度分析** -- 时间复杂度：$O(N)$ -- 空间复杂度：$O(1)$ +- 时间复杂度：$$O(N)$$ +- 空间复杂度：$$O(1)$$ ## 母题 2 @@ -82,15 +82,15 @@ def f(nums1, nums2): **复杂度分析** -- 时间复杂度：$O(N ^ 2)$ -- 空间复杂度：$O(1)$ +- 时间复杂度：$$O(N ^ 2)$$ +- 空间复杂度：$$O(1)$$ -由于暴力的时间复杂度是 $O(N^2)$，因此其实也可以先排序将问题转换为母题 1，然后用母题 1 的解法求解。 +由于暴力的时间复杂度是 $$O(N^2)$$，因此其实也可以先排序将问题转换为母题 1，然后用母题 1 的解法求解。 **复杂度分析** -- 时间复杂度：$O(NlogN)$ -- 空间复杂度：$O(1)$ +- 时间复杂度：$$O(NlogN)$$ +- 空间复杂度：$$O(1)$$ ## 母题 3 @@ -104,8 +104,8 @@ def f(nums1, nums2): **复杂度分析** -- 时间复杂度：$O(klogM)$，其中 M 为 k 个非空数组的长度的最小值。 -- 空间复杂度：$O(1)$ +- 时间复杂度：$$O(klogM)$$，其中 M 为 k 个非空数组的长度的最小值。 +- 空间复杂度：$$O(1)$$ 我们也可以使用堆来处理，代码更简单，逻辑更清晰。这里我们使用小顶堆，作用就是选出最小值。 @@ -134,12 +134,12 @@ def f(matrix): **复杂度分析** -建堆的时间和空间复杂度为 $O(k)$。 +建堆的时间和空间复杂度为 $$O(k)$$。 -while 循环会执行 M 次 ，其中 M 为 k 个非空数组的长度的最小值。heappop 和 heappush 的时间复杂度都是 logk。因此 while 循环总的时间复杂度为 $O(Mlogk)$。 +while 循环会执行 M 次 ，其中 M 为 k 个非空数组的长度的最小值。heappop 和 heappush 的时间复杂度都是 logk。因此 while 循环总的时间复杂度为 $$O(Mlogk)$$。 -- 时间复杂度：$O(max(Mlogk, k))$，其中 M 为 k 个非空数组的长度的最小值。 -- 空间复杂度：$O(k)$ +- 时间复杂度：$$O(max(Mlogk, k))$$，其中 M 为 k 个非空数组的长度的最小值。 +- 空间复杂度：$$O(k)$$ ## 母题 4 @@ -185,8 +185,8 @@ def f(nums1, nums2): **复杂度分析** -- 时间复杂度：$O(N)$ -- 空间复杂度：$O(1)$ +- 时间复杂度：$$O(N)$$ +- 空间复杂度：$$O(1)$$ ## 母题 6 @@ -222,12 +222,12 @@ def f(matrix): **复杂度分析** -建堆的时间和空间复杂度为 $O(N)$。 +建堆的时间和空间复杂度为 $$O(N)$$。 -heappop 的时间复杂度为 $O(logN)$。 +heappop 的时间复杂度为 $$O(logN)$$。 -- 时间复杂度：$O(NlogN)$，其中 N 是矩阵中的数字总数。 -- 空间复杂度：$O(N)$，其中 N 是矩阵中的数字总数。 +- 时间复杂度：$$O(NlogN)$$，其中 N 是矩阵中的数字总数。 +- 空间复杂度：$$O(N)$$，其中 N 是矩阵中的数字总数。 ## 母题 7 @@ -268,8 +268,8 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(N)$，其中 N 为两个链表中较短的那个的长度。 -- 空间复杂度：$O(N)$，其中 N 为两个链表中较短的那个的长度。 +- 时间复杂度：$$O(N)$$，其中 N 为两个链表中较短的那个的长度。 +- 空间复杂度：$$O(N)$$，其中 N 为两个链表中较短的那个的长度。 ```py # Definition for singly-linked list. @@ -303,8 +303,8 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(N)$，其中 N 为两个链表中较短的那个的长度。 -- 空间复杂度：$O(1)$ +- 时间复杂度：$$O(N)$$，其中 N 为两个链表中较短的那个的长度。 +- 空间复杂度：$$O(1)$$ ## 母题 8 @@ -347,10 +347,10 @@ class Solution: **复杂度分析** -mergeKLists 执行了 k 次，每次都执行一次 mergeTwoLists，mergeTwoLists 的时间复杂度前面已经分析过了，为 $O(N)$，其中 N 为两个链表中较短的那个的长度。 +mergeKLists 执行了 k 次，每次都执行一次 mergeTwoLists，mergeTwoLists 的时间复杂度前面已经分析过了，为 $$O(N)$$，其中 N 为两个链表中较短的那个的长度。 -- 时间复杂度：$O(k * N)$，其中 N 为两个链表中较短的那个的长度 -- 空间复杂度：$O(max(k, N))$ +- 时间复杂度：$$O(k * N)$$，其中 N 为两个链表中较短的那个的长度 +- 空间复杂度：$$O(max(k, N))$$ ```py # Definition for singly-linked list. @@ -377,10 +377,10 @@ class Solution: **复杂度分析** -mergeKLists 执行了 logk 次，每次都执行一次 mergeTwoLists，mergeTwoLists 的时间复杂度前面已经分析过了，为 $O(N)$，其中 N 为两个链表中较短的那个的长度。 +mergeKLists 执行了 logk 次，每次都执行一次 mergeTwoLists，mergeTwoLists 的时间复杂度前面已经分析过了，为 $$O(N)$$，其中 N 为两个链表中较短的那个的长度。 -- 时间复杂度：$O(Nlogk)$，其中 N 为两个链表中较短的那个的长度 -- 空间复杂度：$O(max(logk, N))$，其中 N 为两个链表中较短的那个的长度 +- 时间复杂度：$$O(Nlogk)$$，其中 N 为两个链表中较短的那个的长度 +- 空间复杂度：$$O(max(logk, N))$$，其中 N 为两个链表中较短的那个的长度 ## 全家福 diff --git a/selected/schedule-topic.md b/selected/schedule-topic.md index ff6666e89..02ab0560f 100644 --- a/selected/schedule-topic.md +++ b/selected/schedule-topic.md @@ -72,9 +72,9 @@ MyCalendar.book(20, 30); // returns true 复杂度分析： -- 时间复杂度：$O(N^2)$。N 指的是日常安排的数量，对于每个新的日常安排，我们检查新的日常安排是否发生冲突来决定是否可以预订新的日常安排。 +- 时间复杂度：$$O(N^2)$$。N 指的是日常安排的数量，对于每个新的日常安排，我们检查新的日常安排是否发生冲突来决定是否可以预订新的日常安排。 -- 空间复杂度: $O(N)$。 +- 空间复杂度: $$O(N)$$。 这个代码写出来之后整体代码就呼之欲出了，全部代码见下方代码部分。 @@ -157,11 +157,11 @@ class MyCalendar: ### 思路 -和上面思路类似，只不过我们每次都对 calendars 进行排序，那么我们可以通过二分查找日程安排的情况来检查新日常安排是否可以预订。如果每次插入之前都进行一次排序，那么时间复杂度会很高。如图，我们的[s1,e1], [s2,e2], [s3,e3] 是按照时间顺序排好的日程安排。我们现在要插入[s,e],我们使用二分查找，找到要插入的位置，然后和插入位置的课程进行一次比对即可，这部分的时间复杂度是 $O(logN)$。 +和上面思路类似，只不过我们每次都对 calendars 进行排序，那么我们可以通过二分查找日程安排的情况来检查新日常安排是否可以预订。如果每次插入之前都进行一次排序，那么时间复杂度会很高。如图，我们的[s1,e1], [s2,e2], [s3,e3] 是按照时间顺序排好的日程安排。我们现在要插入[s,e],我们使用二分查找，找到要插入的位置，然后和插入位置的课程进行一次比对即可，这部分的时间复杂度是 $$O(logN)$$。 ![image.png](http://ww1.sinaimg.cn/large/e9f490c8ly1gbj28k6v4gj21100c2754.jpg) -我们考虑使用平衡二叉树来维护这种动态的变化，在最差的情况时间复杂度会退化到上述的$O(N^2)$，平均情况是$O(NlogN)$，其中 N 是已预订的日常安排数。 +我们考虑使用平衡二叉树来维护这种动态的变化，在最差的情况时间复杂度会退化到上述的$$O(N^2)$$，平均情况是$$O(NlogN)$$，其中 N 是已预订的日常安排数。 ![image.png](http://ww1.sinaimg.cn/large/e9f490c8ly1gbj2dirnf0j20xs0fe75j.jpg) diff --git a/selected/serialize.md b/selected/serialize.md index 84d08d609..c8dc1b708 100644 --- a/selected/serialize.md +++ b/selected/serialize.md @@ -195,8 +195,8 @@ Java 代码： **复杂度分析** -- 时间复杂度：每个节点都会被处理一次，因此时间复杂度为 $O(N)$，其中 $N$ 为节点的总数。 -- 空间复杂度：空间复杂度取决于栈深度，因此空间复杂度为 $O(h)$，其中 $h$ 为树的深度。 +- 时间复杂度：每个节点都会被处理一次，因此时间复杂度为 $$O(N)$$，其中 $N$ 为节点的总数。 +- 空间复杂度：空间复杂度取决于栈深度，因此空间复杂度为 $$O(h)$$，其中 $h$ 为树的深度。 ## BFS @@ -283,8 +283,8 @@ Python 代码： **复杂度分析** -- 时间复杂度：每个节点都会被处理一次，因此时间复杂度为 $O(N)$，其中 $N$ 为节点的总数。 -- 空间复杂度：$O(N)$，其中 $N$ 为节点的总数。 +- 时间复杂度：每个节点都会被处理一次，因此时间复杂度为 $$O(N)$$，其中 $N$ 为节点的总数。 +- 空间复杂度：$$O(N)$$，其中 $N$ 为节点的总数。 ## 总结 diff --git a/selected/zuma-game.md b/selected/zuma-game.md index b95bdd00f..649508adb 100644 --- a/selected/zuma-game.md +++ b/selected/zuma-game.md @@ -141,8 +141,8 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(2^(min(C, 5)))$，其中 C 为连续相同颜色球的次数，比如 WWRRRR， C 就是 2， WRBDD， C 就是 4。min(C, 5) 是因为题目限定了手上球的个数不大于 5。 -- 空间复杂度：$O(min(C, 5) * Board)$，其中 C 为连续相同颜色球的次数，Board 为 Board 的长度。 +- 时间复杂度：$$O(2^(min(C, 5)))$$，其中 C 为连续相同颜色球的次数，比如 WWRRRR， C 就是 2， WRBDD， C 就是 4。min(C, 5) 是因为题目限定了手上球的个数不大于 5。 +- 空间复杂度：$$O(min(C, 5) * Board)$$，其中 C 为连续相同颜色球的次数，Board 为 Board 的长度。 ## 关键点解析 diff --git a/thinkings/GCD.md b/thinkings/GCD.md index cf2304288..6b4984563 100644 --- a/thinkings/GCD.md +++ b/thinkings/GCD.md @@ -23,8 +23,8 @@ def GCD(a: int, b: int) -> int: **复杂度分析** -- 时间复杂度：最好的情况是执行一次循环体，最坏的情况是循环到 smaller 为 1，因此总的时间复杂度为 $O(N)$，其中 N 为 a 和 b 中较小的数。 -- 空间复杂度：$O(1)$。 +- 时间复杂度：最好的情况是执行一次循环体，最坏的情况是循环到 smaller 为 1，因此总的时间复杂度为 $$O(N)$$，其中 N 为 a 和 b 中较小的数。 +- 空间复杂度：$$O(1)$$。 ## 辗转相除法 @@ -37,8 +37,8 @@ def GCD(a: int, b: int) -> int: **复杂度分析** -- 时间复杂度：$O(log(max(a, b)))$ -- 空间复杂度：空间复杂度取决于递归的深度，因此空间复杂度为 $O(log(max(a, b)))$ +- 时间复杂度：$$O(log(max(a, b)))$$ +- 空间复杂度：空间复杂度取决于递归的深度，因此空间复杂度为 $$O(log(max(a, b)))$$ 下面我们对上面的过程进行一个表形象地讲解，实际上这也是教材里面的讲解方式，我只是照搬过来，增加一下自己的理解罢了。我们来通过一个例子来讲解： diff --git a/thinkings/balanced-tree.md b/thinkings/balanced-tree.md index b62c20f6a..8755e1094 100644 --- a/thinkings/balanced-tree.md +++ b/thinkings/balanced-tree.md @@ -86,8 +86,8 @@ class Solution: **复杂度分析** -- 时间复杂度：对于 isBalanced 来说，由于每个节点最多被访问一次，这部分的时间复杂度为 $O(N)$，而 dfs 函数 每次被调用的次数不超过 $log N$，因此总的时间复杂度为 $O(NlogN)$，其中 $N$ 为 树的节点总数。 -- 空间复杂度：由于使用了递归，这里的空间复杂度的瓶颈在栈空间，因此空间复杂度为 $O(h)$，其中 $h$ 为树的高度。 +- 时间复杂度：对于 isBalanced 来说，由于每个节点最多被访问一次，这部分的时间复杂度为 $$O(N)$$，而 dfs 函数 每次被调用的次数不超过 $log N$，因此总的时间复杂度为 $$O(NlogN)$$，其中 $N$ 为 树的节点总数。 +- 空间复杂度：由于使用了递归，这里的空间复杂度的瓶颈在栈空间，因此空间复杂度为 $$O(h)$$，其中 $h$ 为树的高度。 ## 108. 将有序数组转换为二叉搜索树（简单） @@ -148,8 +148,8 @@ class Solution: **复杂度分析** -- 时间复杂度：由于每个节点最多被访问一次，因此总的时间复杂度为 $O(N)$，其中 $N$ 为数组长度。 -- 空间复杂度：由于使用了递归，这里的空间复杂度的瓶颈在栈空间，因此空间复杂度为 $O(h)$，其中 $h$ 为树的高度。同时由于是平衡二叉树，因此 $h$ 就是 $log N$。 +- 时间复杂度：由于每个节点最多被访问一次，因此总的时间复杂度为 $$O(N)$$，其中 $N$ 为数组长度。 +- 空间复杂度：由于使用了递归，这里的空间复杂度的瓶颈在栈空间，因此空间复杂度为 $$O(h)$$，其中 $h$ 为树的高度。同时由于是平衡二叉树，因此 $h$ 就是 $log N$。 ## 109. 有序链表转换二叉搜索树（中等） @@ -218,8 +218,8 @@ class Solution: **复杂度分析** -- 时间复杂度：由于每个节点最多被访问一次，因此总的时间复杂度为 $O(N)$，其中 $N$ 为链表长度。 -- 空间复杂度：由于使用了递归，这里的空间复杂度的瓶颈在栈空间，因此空间复杂度为 $O(h)$，其中 $h$ 为树的高度。同时由于是平衡二叉树，因此 $h$ 就是 $log N$。 +- 时间复杂度：由于每个节点最多被访问一次，因此总的时间复杂度为 $$O(N)$$，其中 $N$ 为链表长度。 +- 空间复杂度：由于使用了递归，这里的空间复杂度的瓶颈在栈空间，因此空间复杂度为 $$O(h)$$，其中 $h$ 为树的高度。同时由于是平衡二叉树，因此 $h$ 就是 $log N$。 ## 1382. 将二叉搜索树变平衡（中等） @@ -284,8 +284,8 @@ class Solution: **复杂度分析** -- 时间复杂度：由于每个节点最多被访问一次，因此总的时间复杂度为 $O(N)$，其中 $N$ 为链表长度。 -- 空间复杂度：虽然使用了递归，但是瓶颈不在栈空间，而是开辟的长度为 $N$ 的 nums 数组，因此空间复杂度为 $O(N)$，其中 $N$ 为树的节点总数。 +- 时间复杂度：由于每个节点最多被访问一次，因此总的时间复杂度为 $$O(N)$$，其中 $N$ 为链表长度。 +- 空间复杂度：虽然使用了递归，但是瓶颈不在栈空间，而是开辟的长度为 $N$ 的 nums 数组，因此空间复杂度为 $$O(N)$$，其中 $N$ 为树的节点总数。 ## 总结 diff --git a/thinkings/basic-data-structure.md b/thinkings/basic-data-structure.md index 5f0be50fa..1af05cda2 100644 --- a/thinkings/basic-data-structure.md +++ b/thinkings/basic-data-structure.md @@ -508,7 +508,7 @@ times 的长度在 [1, 6000] 之间。 ### 图的遍历 -图建立好了，接下来就是要遍历。不管你是什么算法，肯定都要遍历的，一般有以下两种方法（其他奇葩的遍历方式实际意义不大，没有必要学习）。不管是哪一种遍历， 如果图有环，就一定要记录节点的访问情况，防止死循环。当然你可能不需要真正地使用一个集合记录节点的访问情况，比如使用一个数据范围外的数据原地标记，这样的空间复杂度会是 $O(1)$。 +图建立好了，接下来就是要遍历。不管你是什么算法，肯定都要遍历的，一般有以下两种方法（其他奇葩的遍历方式实际意义不大，没有必要学习）。不管是哪一种遍历， 如果图有环，就一定要记录节点的访问情况，防止死循环。当然你可能不需要真正地使用一个集合记录节点的访问情况，比如使用一个数据范围外的数据原地标记，这样的空间复杂度会是 $$O(1)$$。 这里以有向图为例， 有向图也是类似，这里不再赘述。 @@ -642,7 +642,7 @@ class Solution: floyd_warshall 也是解决两个点距离的算法，只不过由于其计算过程会把中间运算结果保存起来防止重复计算，因此其特别适合**求图中任意两点的距离**，比如力扣的 1462. 课程安排 IV。除了这个优点，还有一个非常重要的点是 floyd_warshall 算法由于使用了动态规划的思想而不是贪心，因此其**可以处理负权重**的情况。 -floyd_warshall 的基本思想是动态规划。该算法的时间复杂度是 $O(N^3)$，空间复杂度是 $O(N^2)$，其中 N 为顶点个数。 +floyd_warshall 的基本思想是动态规划。该算法的时间复杂度是 $$O(N^3)$$，空间复杂度是 $$O(N^2)$$，其中 N 为顶点个数。 算法也不难理解，简单来说就是： **i 到 j 的最短路径 = i 到 k 的最短路径 + k 到 j 的最短路径**的最小值。 diff --git a/thinkings/binary-tree-traversal.md b/thinkings/binary-tree-traversal.md index 6aa47785f..4352e6074 100644 --- a/thinkings/binary-tree-traversal.md +++ b/thinkings/binary-tree-traversal.md @@ -152,7 +152,7 @@ class Solution: ## Morris 遍历 -我们可以使用一种叫做 Morris 遍历的方法，既不使用递归也不借助于栈。从而在 $O(1)$ 空间完成这个过程。 +我们可以使用一种叫做 Morris 遍历的方法，既不使用递归也不借助于栈。从而在 $$O(1)$$ 空间完成这个过程。 ```python def MorrisTraversal(root): diff --git a/thinkings/bit.md b/thinkings/bit.md index 0b1b60d5d..975896744 100644 --- a/thinkings/bit.md +++ b/thinkings/bit.md @@ -36,8 +36,8 @@ class Solution: return single_number ``` ***复杂度分析*** -- 时间复杂度：$O(N)$，其中N为数组长度。 -- 空间复杂度：$O(1)$ +- 时间复杂度：$$O(N)$$，其中N为数组长度。 +- 空间复杂度：$$O(1)$$ ## 137. 只出现一次的数字2 @@ -88,12 +88,12 @@ var singleNumber = function(nums) { ``` ***复杂度分析*** -- 时间复杂度：$O(N)$，其中N为数组长度。 -- 空间复杂度：$O(1)$ +- 时间复杂度：$$O(N)$$，其中N为数组长度。 +- 空间复杂度：$$O(1)$$ ## 645. 错误的集合 -和上面的`137. 只出现一次的数字2`思路一样。这题没有限制空间复杂度，因此直接hashmap 存储一下没问题。 不多说了，我们来看一种空间复杂度$O(1)$的解法。 +和上面的`137. 只出现一次的数字2`思路一样。这题没有限制空间复杂度，因此直接hashmap 存储一下没问题。 不多说了，我们来看一种空间复杂度$$O(1)$$的解法。 由于和`137. 只出现一次的数字2`思路基本一样，我直接复用了代码。具体思路是，将nums的所有索引提取出一个数组idx，那么由idx和nums组成的数组构成singleNumbers的输入，其输出是唯二不同的两个数。 @@ -135,8 +135,8 @@ class Solution: ``` ***复杂度分析*** -- 时间复杂度：$O(N)$ -- 空间复杂度：$O(1)$ +- 时间复杂度：$$O(N)$$ +- 空间复杂度：$$O(1)$$ ## 260. 只出现一次的数字3 @@ -186,8 +186,8 @@ class Solution: ``` ***复杂度分析*** -- 时间复杂度：$O(N)$，其中N为数组长度。 -- 空间复杂度：$O(1)$ +- 时间复杂度：$$O(N)$$，其中N为数组长度。 +- 空间复杂度：$$O(1)$$ ## 相关题目 diff --git a/thinkings/greedy.md b/thinkings/greedy.md index 09930db5d..c1032e26b 100644 --- a/thinkings/greedy.md +++ b/thinkings/greedy.md @@ -76,9 +76,9 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(N)$。 +- 时间复杂度：$$O(N)$$。 -- 空间复杂度：$O(1)$。 +- 空间复杂度：$$O(1)$$。 ### 1024. 视频拼接 @@ -171,9 +171,9 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(\sum_{i=1}^{n}ranges[i] + T)$，其中 ranges[i] 为 clips[i] 的区间长度。 +- 时间复杂度：$$O(\sum_{i=1}^{n}ranges[i] + T)$$，其中 ranges[i] 为 clips[i] 的区间长度。 -- 空间复杂度：$O(T)$。 +- 空间复杂度：$$O(T)$$。 ### 1326. 灌溉花园的最少水龙头数目 @@ -269,9 +269,9 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(\sum_{i=1}^{n}R[i] + n)$，其中 R[i] 为 ranges[i] 的区间长度。 +- 时间复杂度：$$O(\sum_{i=1}^{n}R[i] + n)$$，其中 R[i] 为 ranges[i] 的区间长度。 -- 空间复杂度：$O(n)$。 +- 空间复杂度：$$O(n)$$。 ## 总结 diff --git a/thinkings/linked-list.md b/thinkings/linked-list.md index b4a71b08a..e23bbae97 100644 --- a/thinkings/linked-list.md +++ b/thinkings/linked-list.md @@ -47,7 +47,7 @@ data 是数据域，存放数据，next 是一个指向下一个节点的指针 链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。 -从上面的物理结构图可以看出数组是一块连续的空间，数组的每一项都是紧密相连的，因此如果要执行插入和删除操作就很麻烦。对数组头部的插入和删除时间复杂度都是$O(N)$，而平均复杂度也是$O(N)$，只有对尾部的插入和删除才是$O(1)$。简单来说”数组对查询特别友好，对删除和添加不友好“。为了解决这个问题，就有了链表这种数据结构。链表适合在数据需要有一定顺序，但是又需要进行频繁增删除的场景，具体内容参考后面的《链表的基本操作》小节。 +从上面的物理结构图可以看出数组是一块连续的空间，数组的每一项都是紧密相连的，因此如果要执行插入和删除操作就很麻烦。对数组头部的插入和删除时间复杂度都是$$O(N)$$，而平均复杂度也是$$O(N)$$，只有对尾部的插入和删除才是$$O(1)$$。简单来说”数组对查询特别友好，对删除和添加不友好“。为了解决这个问题，就有了链表这种数据结构。链表适合在数据需要有一定顺序，但是又需要进行频繁增删除的场景，具体内容参考后面的《链表的基本操作》小节。 ![](https://tva1.sinaimg.cn/large/007S8ZIlly1gfigmeqc3xj316o094jt6.jpg) @@ -772,7 +772,7 @@ while cur: ## 总结 -数组和栈从逻辑上没有大的区别，你看基本操作都是差不多的。如果是单链表，我们无法在 $O(1)$ 的时间拿到前驱节点，这也是为什么我们遍历的时候老是维护一个前驱节点的原因。但是本质原因其实是链表的增删操作都依赖前驱节点。这是链表的基本操作，是链表的特性天生决定的。 +数组和栈从逻辑上没有大的区别，你看基本操作都是差不多的。如果是单链表，我们无法在 $$O(1)$$ 的时间拿到前驱节点，这也是为什么我们遍历的时候老是维护一个前驱节点的原因。但是本质原因其实是链表的增删操作都依赖前驱节点。这是链表的基本操作，是链表的特性天生决定的。 可能有的同学有这样的疑问”考点你只讲了指针的修改和链表拼接，难道说链表就只会这些就够了？那我做的题怎么还需要我会前缀和啥的呢？你是不是坑我呢？“ diff --git a/thinkings/monotone-stack.md b/thinkings/monotone-stack.md index 69b51da3a..2e6c56102 100644 --- a/thinkings/monotone-stack.md +++ b/thinkings/monotone-stack.md @@ -118,8 +118,8 @@ class Solution: **复杂度分析** -- 时间复杂度：由于 arr 的元素最多只会入栈，出栈一次，因此时间复杂度仍然是 $O(N)$，其中 N 为数组长度。 -- 空间复杂度：由于使用了栈， 并且栈的长度最大是和 arr 长度一致，因此空间复杂度是 $O(N)$，其中 N 为数组长度。 +- 时间复杂度：由于 arr 的元素最多只会入栈，出栈一次，因此时间复杂度仍然是 $$O(N)$$，其中 N 为数组长度。 +- 空间复杂度：由于使用了栈， 并且栈的长度最大是和 arr 长度一致，因此空间复杂度是 $$O(N)$$，其中 N 为数组长度。 ### 代码 diff --git a/thinkings/prefix.md b/thinkings/prefix.md index ade57c8d6..bd8e87f6d 100644 --- a/thinkings/prefix.md +++ b/thinkings/prefix.md @@ -54,8 +54,8 @@ function countSubArray(nums) { **复杂度分析** -- 时间复杂度：$O(N)$，其中 N 为数组长度。 -- 空间复杂度：$O(1)$ +- 时间复杂度：$$O(N)$$，其中 N 为数组长度。 +- 空间复杂度：$$O(1)$$ 而由于以索引为 i 结尾的子数组个数就是 i + 1，因此这道题可以直接用等差数列求和公式 `(1 + n) * n / 2`，其中 n 数组长度。 @@ -86,8 +86,8 @@ function countSubArray(nums) { **复杂度分析** -- 时间复杂度：$O(N)$，其中 N 为数组长度。 -- 空间复杂度：$O(1)$ +- 时间复杂度：$$O(N)$$，其中 N 为数组长度。 +- 空间复杂度：$$O(1)$$ 如果我值差只要大于 1 就行呢？其实改下符号就行了，这不就是求上升子序列个数么？这里不再继续赘述， 大家可以自己试试。 @@ -118,8 +118,8 @@ function countSubArray(k, nums) { **复杂度分析** -- 时间复杂度：$O(N)$，其中 N 为数组长度。 -- 空间复杂度：$O(1)$ +- 时间复杂度：$$O(N)$$，其中 N 为数组长度。 +- 空间复杂度：$$O(1)$$ ### 母题 4 @@ -292,8 +292,8 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(N)$，其中 $N$ 为字符串 p 的长度。 -- 空间复杂度：由于最多存储 26 个字母， 因此空间实际上是常数，故空间复杂度为 $O(1)$。 +- 时间复杂度：$$O(N)$$，其中 $N$ 为字符串 p 的长度。 +- 空间复杂度：由于最多存储 26 个字母， 因此空间实际上是常数，故空间复杂度为 $$O(1)$$。 ## 795. 区间子数组个数（中等） @@ -351,8 +351,8 @@ class Solution: **_复杂度分析_** -- 时间复杂度：$O(N)$，其中 $N$ 为数组长度。 -- 空间复杂度：$O(1)$。 +- 时间复杂度：$$O(N)$$，其中 $N$ 为数组长度。 +- 空间复杂度：$$O(1)$$。 ## 904. 水果成篮（中等） @@ -439,8 +439,8 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(N)$，其中 $N$ 为数组长度。 -- 空间复杂度：$O(k)$。 +- 时间复杂度：$$O(N)$$，其中 $N$ 为数组长度。 +- 空间复杂度：$$O(k)$$。 ## 992. K 个不同整数的子数组（困难） @@ -512,8 +512,8 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(N)$，中 $N$ 为数组长度。 -- 空间复杂度：$O(k)$。 +- 时间复杂度：$$O(N)$$，中 $N$ 为数组长度。 +- 空间复杂度：$$O(k)$$。 ## 1109. 航班预订统计（中等） @@ -594,8 +594,8 @@ class Solution: **复杂度分析** -- 时间复杂度：$O(N)$，中 $N$ 为数组长度。 -- 空间复杂度：$O(N)$。 +- 时间复杂度：$$O(N)$$，中 $N$ 为数组长度。 +- 空间复杂度：$$O(N)$$。 ## 总结 diff --git a/thinkings/tree.md b/thinkings/tree.md index 071e3230b..bba9bb302 100644 --- a/thinkings/tree.md +++ b/thinkings/tree.md @@ -757,7 +757,7 @@ class Solution { ![bst](https://tva1.sinaimg.cn/large/007S8ZIlly1ghluh33ttoj30rs0mudhi.jpg) （图片来自 https://www.geeksforgeeks.org/floor-in-binary-search-tree-bst/） -可以看出每次向下走，都会排除了一个分支，如果一颗二叉搜索树同时也是一颗二叉平衡树的话，那么其搜索过程时间复杂度就是 $O(logN)$。实际上，**平衡二叉搜索树的查找和有序数组的二分查找本质都是一样的，只是数据的存储方式不同罢了**。那为什么有了有序数组二分，还需要二叉搜索树呢？原因在于树的结构对于动态数据比较友好，比如数据是频繁变动的，比如经常添加和删除，那么就可以使用二叉搜索树。理论上添加和删除的时间复杂度都是 $O(h)$，其中 h 为树的高度，如果是一颗平衡二叉搜索树，那么时间复杂度就是 $O(logN)$。而数组的添加和删除的时间复杂度为 $O(N)$，其中 N 为数组长度。 +可以看出每次向下走，都会排除了一个分支，如果一颗二叉搜索树同时也是一颗二叉平衡树的话，那么其搜索过程时间复杂度就是 $$O(logN)$$。实际上，**平衡二叉搜索树的查找和有序数组的二分查找本质都是一样的，只是数据的存储方式不同罢了**。那为什么有了有序数组二分，还需要二叉搜索树呢？原因在于树的结构对于动态数据比较友好，比如数据是频繁变动的，比如经常添加和删除，那么就可以使用二叉搜索树。理论上添加和删除的时间复杂度都是 $$O(h)$$，其中 h 为树的高度，如果是一颗平衡二叉搜索树，那么时间复杂度就是 $$O(logN)$$。而数组的添加和删除的时间复杂度为 $$O(N)$$，其中 N 为数组长度。 **方便搜索，是二叉搜索树核心的设计初衷。不让查找算法时间复杂度退化到线性是平衡二叉树的初衷**。 @@ -997,11 +997,12 @@ def deserialize(self, data): 可以看出： - 路径可以由一个节点做成，可以由两个节点组成，也可以由三个节点组成等等，但是必须连续。 -- 路径必须是”直来直去“的，不能拐。 比如上图的路径的左下角是 3，就不能是 2，因为如果是 2 就拐了。 +- 路径必须是”直来直去“的，不能有分叉。 比如上图的路径的左下角是 3，当然也可以是 2，但是 2 比较小。但是不可以 2 和 3 同时选。 + 我们继续回到 124 题。题目说是 ”从任意节点出发.......“ 看完这个描述我会想到大概率是要么全局记录最大值，要么双递归。 -- 如果使用双递归，那么复杂度就是 $O(N^2)$，实际上，子树的路径和计算出来了，可以推导出父节点的最大路径和，因此如果使用双递归会有重复计算。一个可行的方式是记忆化递归。 +- 如果使用双递归，那么复杂度就是 $$O(N^2)$$，实际上，子树的路径和计算出来了，可以推导出父节点的最大路径和，因此如果使用双递归会有重复计算。一个可行的方式是记忆化递归。 - 如果使用全局记录最大值，只需要在递归的时候 return 当前的一条边（上面提了不能拐），并在函数内部计算以当前节点出发的最大路径和，并更新全局最大值即可。 这里的核心其实是 return 较大的一条边，因为较小的边不可能是答案。 这里我选择使用第二种方法。