Skip to content

Commit b971fca

Browse files
author
lucifer
committed
feat: latex $ -> $$
1 parent c80758e commit b971fca

File tree

183 files changed

+630
-629
lines changed

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

183 files changed

+630
-629
lines changed

‎91/binary-search.md

+13-13
Original file line numberDiff line numberDiff line change
@@ -54,12 +54,12 @@
5454

5555
**复杂度分析**
5656

57-
- 平均时间复杂度： $O(logN)$
58-
- 最坏时间复杂度： $O(logN)$
59-
- 最优时间复杂度： $O(1)$
57+
- 平均时间复杂度： $$O(logN)$$
58+
- 最坏时间复杂度： $$O(logN)$$
59+
- 最优时间复杂度： $$O(1)$$
6060
- 空间复杂度
61-
- 迭代: $O(1)$
62-
- 递归： $O(logN)$（无尾调用消除）
61+
- 迭代: $$O(1)$$
62+
- 递归： $$O(logN)$$（无尾调用消除）
6363

6464
> 后面的复杂度也是类似的，不再赘述。
6565
@@ -467,8 +467,8 @@ class Solution:
467467

468468
**复杂度分析**
469469

470-
- 时间复杂度：$O(log N)$
471-
- 空间复杂度：$O(1)$
470+
- 时间复杂度：$$O(log N)$$
471+
- 空间复杂度：$$O(1)$$
472472

473473
### 二维数组
474474

@@ -553,8 +553,8 @@ class Solution:
553553

554554
**复杂度分析**
555555

556-
- 时间复杂度：最坏的情况是只有一行或者只有一列，此时时间复杂度为 $O(M * N)$。更多的情况下时间复杂度为 $O(M + N)$
557-
- 空间复杂度：$O(1)$
556+
- 时间复杂度：最坏的情况是只有一行或者只有一列，此时时间复杂度为 $$O(M * N)$$。更多的情况下时间复杂度为 $$O(M + N)$$
557+
- 空间复杂度：$$O(1)$$
558558

559559
力扣 [240. 搜索二维矩阵 II](https://leetcode-cn.com/problems/search-a-2d-matrix-ii/) 发生了一点变化，不再是`每行的第一个整数大于前一行的最后一个整数`，而是 `每列的元素从上到下升序排列`。我们仍然可以选择左下进行二分。
560560

@@ -633,8 +633,8 @@ class Solution:
633633

634634
**复杂度分析**
635635

636-
- 时间复杂度：$O(log N)$
637-
- 空间复杂度：$O(1)$
636+
- 时间复杂度：$$O(log N)$$
637+
- 空间复杂度：$$O(1)$$
638638

639639
##### 另一种二分法
640640

@@ -712,8 +712,8 @@ class Solution:
712712

713713
**复杂度分析**
714714

715-
- 时间复杂度：$O(log N)$
716-
- 空间复杂度：$O(1)$
715+
- 时间复杂度：$$O(log N)$$
716+
- 空间复杂度：$$O(1)$$
717717

718718
### 二叉树
719719

‎daily/2019-08-09.md

+3-3
Original file line numberDiff line numberDiff line change
@@ -24,7 +24,7 @@
2424
我们新建一个额外的dp数组，与原矩阵大小相同。在这个矩阵中,dp(i,j)表示从原点到坐标(i,j)的最小路径和。我们初始化dp值为对应的原矩阵值，然后去填整个矩阵，对于每个元素考虑从上方移动过来还是从左方移动过来，因此获得最小路径和我们有如下递推公式：`dp(i,j)=grid(i,j)+min(dp(i-1,j),dp(i,j-1))`
2525

2626

27-
我们可以使用原地算法，这样就不需要开辟dp数组，空间复杂度可以降低到$O(1)$。
27+
我们可以使用原地算法，这样就不需要开辟dp数组，空间复杂度可以降低到$$O(1)$$。
2828

2929
```c++
3030
class Solution {
@@ -62,8 +62,8 @@ public:
6262
6363
6464
**复杂度分析**
65-
- 时间复杂度：$O(M * N)$
66-
- 空间复杂度：$O(1)$
65+
- 时间复杂度：$$O(M * N)$$
66+
- 空间复杂度：$$O(1)$$
6767
## 其他优秀解答
6868
6969
> 暂缺

‎problems/1.two-sum.md

+2-2
Original file line numberDiff line numberDiff line change
@@ -92,8 +92,8 @@ func twoSum(nums []int, target int) []int {
9292

9393
**复杂度分析**
9494

95-
- 时间复杂度：$O(N)$
96-
- 空间复杂度：$O(N)$
95+
- 时间复杂度：$$O(N)$$
96+
- 空间复杂度：$$O(N)$$
9797

9898
更多题解可以访问我的LeetCode题解仓库：https://github.com/azl397985856/leetcode 。 目前已经37K star啦。
9999

‎problems/100.same-tree.md

+6-6
Original file line numberDiff line numberDiff line change
@@ -114,8 +114,8 @@ class Solution
114114

115115
**复杂度分析**
116116

117-
- 时间复杂度：$O(N)$，其中 N 为树的节点数。
118-
- 空间复杂度：$O(h)$，其中 h 为树的高度。
117+
- 时间复杂度：$$O(N)$$，其中 N 为树的节点数。
118+
- 空间复杂度：$$O(h)$$，其中 h 为树的高度。
119119

120120
## 层序遍历
121121

@@ -174,8 +174,8 @@ function isSameNode(nodeA, nodeB) {
174174

175175
**复杂度分析**
176176

177-
- 时间复杂度：$O(N)$，其中 N 为树的节点数。
178-
- 空间复杂度：$O(Q)$，其中 Q 为队列的长度最大值，在这里不会超过相邻两层的节点数的最大值。
177+
- 时间复杂度：$$O(N)$$，其中 N 为树的节点数。
178+
- 空间复杂度：$$O(Q)$$，其中 Q 为队列的长度最大值，在这里不会超过相邻两层的节点数的最大值。
179179

180180
## 前中序确定一棵树
181181

@@ -226,5 +226,5 @@ function inorder(root, arr) {
226226

227227
**复杂度分析**
228228

229-
- 时间复杂度：$O(N)$，其中 N 为树的节点数。
230-
- 空间复杂度：使用了中序遍历的结果数组，因此空间复杂度为 $O(N)$，其中 N 为树的节点数。
229+
- 时间复杂度：$$O(N)$$，其中 N 为树的节点数。
230+
- 空间复杂度：使用了中序遍历的结果数组，因此空间复杂度为 $$O(N)$$，其中 N 为树的节点数。

‎problems/101.symmetric-tree.md

+2-2
Original file line numberDiff line numberDiff line change
@@ -191,8 +191,8 @@ class Solution:
191191

192192
**复杂度分析**
193193

194-
- 时间复杂度：$O(N)$，其中 N 为节点数。
195-
- 空间复杂度：递归的深度最高为节点数，因此空间复杂度是 $O(N)$，其中 N 为节点数。
194+
- 时间复杂度：$$O(N)$$，其中 N 为节点数。
195+
- 空间复杂度：递归的深度最高为节点数，因此空间复杂度是 $$O(N)$$，其中 N 为节点数。
196196

197197
大家对此有何看法，欢迎给我留言，我有时间都会一一查看回答。更多算法套路可以访问我的 LeetCode 题解仓库：https://github.com/azl397985856/leetcode 。 目前已经 37K star 啦。
198198
大家也可以关注我的公众号《力扣加加》带你啃下算法这块硬骨头。

‎problems/1011.capacity-to-ship-packages-within-d-days.md

+2-2
Original file line numberDiff line numberDiff line change
@@ -176,5 +176,5 @@ var shipWithinDays = function(weights, D) {
176176

177177
**复杂度分析**
178178

179-
- 时间复杂度：$O(logN)$
180-
- 空间复杂度：$O(N)$
179+
- 时间复杂度：$$O(logN)$$
180+
- 空间复杂度：$$O(N)$$

‎problems/1014.best-sightseeing-pair.md

+2-2
Original file line numberDiff line numberDiff line change
@@ -106,8 +106,8 @@ class Solution:
106106

107107
**复杂度分析**
108108

109-
- 时间复杂度：$O(N)$
110-
- 空间复杂度：$O(N)$
109+
- 时间复杂度：$$O(N)$$
110+
- 空间复杂度：$$O(N)$$
111111

112112
大家对此有何看法，欢迎给我留言，我有时间都会一一查看回答。更多算法套路可以访问我的 LeetCode 题解仓库：https://github.com/azl397985856/leetcode 。 目前已经 37K star 啦。
113113
大家也可以关注我的公众号《力扣加加》带你啃下算法这块硬骨头。

‎problems/1019.next-greater-node-in-linked-list.md

+3-3
Original file line numberDiff line numberDiff line change
@@ -49,7 +49,7 @@ https://leetcode-cn.com/problems/next-greater-node-in-linked-list/
4949

5050
看完题目就应该想到单调栈才行，LeetCode 上关于单调栈的题目还不少，难度都不小。但是一旦你掌握了这个算法，那么这些题目对你来说都不是问题了。
5151

52-
如果你不用单调栈，那么可以暴力$O(N^2)$的时间复杂度解决，只需要双层循环即可。但是这种做法应该是过不了关的。使用单调栈可以将时间复杂度降低到线性，当然需要额外的$O(N)$的空间复杂度。
52+
如果你不用单调栈，那么可以暴力$$O(N^2)$$的时间复杂度解决，只需要双层循环即可。但是这种做法应该是过不了关的。使用单调栈可以将时间复杂度降低到线性，当然需要额外的$$O(N)$$的空间复杂度。
5353

5454
顾名思义，单调栈即满足单调性的栈结构。与单调队列相比，其只在一端进行进出。为了描述方便，以下举例及代码以维护一个整数的单调递减栈为例。将一个元素插入单调栈时，为了维护栈的单调性，需要在保证将该元素插入到栈顶后整个栈满足单调性的前提下弹出最少的元素。
5555

@@ -107,8 +107,8 @@ class Solution:
107107

108108
其中 N 为链表的长度。
109109

110-
- 时间复杂度：$O(N)$
111-
- 空间复杂度：$O(N)$
110+
- 时间复杂度：$$O(N)$$
111+
- 空间复杂度：$$O(N)$$
112112

113113
## 扩展
114114

‎problems/102.binary-tree-level-order-traversal.md

+2-2
Original file line numberDiff line numberDiff line change
@@ -195,8 +195,8 @@ class Solution:
195195
```
196196

197197
***复杂度分析***
198-
- 时间复杂度：$O(N)$，其中N为树中节点总数。
199-
- 空间复杂度：$O(N)$，其中N为树中节点总数。
198+
- 时间复杂度：$$O(N)$$，其中N为树中节点总数。
199+
- 空间复杂度：$$O(N)$$，其中N为树中节点总数。
200200

201201
更多题解可以访问我的LeetCode题解仓库：https://github.com/azl397985856/leetcode 。 目前已经30K star啦。
202202

‎problems/1020.number-of-enclaves.md

+5-5
Original file line numberDiff line numberDiff line change
@@ -103,8 +103,8 @@ class Solution:
103103

104104
**复杂度分析**
105105

106-
- 时间复杂度：$O(M * N)$
107-
- 空间复杂度：$O(M * N)$
106+
- 时间复杂度：$$O(M * N)$$
107+
- 空间复杂度：$$O(M * N)$$
108108

109109
## 解法二 (原地标记法)
110110

@@ -114,7 +114,7 @@ class Solution:
114114

115115
### 思路
116116

117-
上面的解法空间复杂度很差，我们考虑进行优化， 这里我们使用消除法。即使用题目范围外的数据原地标记是否访问， 这样时间复杂度可以优化到 $O(1)$，这是一种非常常见的优化技巧，请务必掌握，另外文章末尾的题目也是类似的技巧，大家可以结合起来练习。
117+
上面的解法空间复杂度很差，我们考虑进行优化， 这里我们使用消除法。即使用题目范围外的数据原地标记是否访问， 这样时间复杂度可以优化到 $$O(1)$$，这是一种非常常见的优化技巧，请务必掌握，另外文章末尾的题目也是类似的技巧，大家可以结合起来练习。
118118

119119
- 从矩阵边界开始 dfs
120120
- 如果碰到 1 就将其变成 0
@@ -173,8 +173,8 @@ class Solution:
173173

174174
**复杂度分析**
175175

176-
- 时间复杂度：$O(M * N)$
177-
- 空间复杂度：$O(1)$
176+
- 时间复杂度：$$O(M * N)$$
177+
- 空间复杂度：$$O(1)$$
178178

179179
## 参考
180180

‎problems/1023.camelcase-matching.md

+2-2
Original file line numberDiff line numberDiff line change
@@ -139,8 +139,8 @@ class Solution:
139139

140140
其中 N 为 queries 的长度， M 为 queries 的平均长度， P 为 pattern 的长度。
141141

142-
- 时间复杂度：$O(N * M * P)$
143-
- 空间复杂度：$O(1)$
142+
- 时间复杂度：$$O(N * M * P)$$
143+
- 空间复杂度：$$O(1)$$
144144

145145
## 扩展
146146

‎problems/1032.stream-of-characters.md

+1-1
Original file line numberDiff line numberDiff line change
@@ -60,7 +60,7 @@ streamChecker.query("c"); // stream：cba
6060

6161
这里有两个小的点需要注意：
6262

63-
1. 如果用数组来存储， 由于每次都往数组头部插入一个元素，因此每次 query 操作的时间复杂度为 $O(N)$，其中 $N$ 为截止当前执行 query 的次数，我们可以使用双端队列进行优化。
63+
1. 如果用数组来存储， 由于每次都往数组头部插入一个元素，因此每次 query 操作的时间复杂度为 $$O(N)$$，其中 $N$ 为截止当前执行 query 的次数，我们可以使用双端队列进行优化。
6464
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) 也有用到。
6565

6666
之后我们用拼接的单词在 words 中查询即可， 最简单的方式当然是每次 query 都去扫描一次，这种方式毫无疑问会超时。

‎problems/104.maximum-depth-of-binary-tree.md

+2-2
Original file line numberDiff line numberDiff line change
@@ -295,8 +295,8 @@ class Solution
295295

296296
**复杂度分析**
297297

298-
- 时间复杂度：$O(N)$
299-
- 空间复杂度：$O(N)$
298+
- 时间复杂度：$$O(N)$$
299+
- 空间复杂度：$$O(N)$$
300300

301301
## 相关题目
302302

‎problems/108.convert-sorted-array-to-binary-search-tree.md

+4-4
Original file line numberDiff line numberDiff line change
@@ -88,8 +88,8 @@ class Solution:
8888

8989
**复杂度分析**
9090

91-
- 时间复杂度：$O(N)$
92-
- 空间复杂度：每次递归都 copy 了 N 的 空间，因此空间复杂度为 $O(N ^ 2)$
91+
- 时间复杂度：$$O(N)$$
92+
- 空间复杂度：每次递归都 copy 了 N 的 空间，因此空间复杂度为 $$O(N ^ 2)$$
9393

9494
然而，实际上没必要开辟新的空间：
9595

@@ -171,8 +171,8 @@ class Solution(object):
171171

172172
**复杂度分析**
173173

174-
- 时间复杂度：$O(N)$
175-
- 空间复杂度：由于是平衡二叉树，因此隐式调用栈的开销为 $O(logN)$
174+
- 时间复杂度：$$O(N)$$
175+
- 空间复杂度：由于是平衡二叉树，因此隐式调用栈的开销为 $$O(logN)$$
176176

177177
更多题解可以访问我的 LeetCode 题解仓库：https://github.com/azl397985856/leetcode 。 目前已经 37K star 啦。
178178

‎problems/109.Convert-Sorted-List-to-Binary-Search-Tree.md

+4-4
Original file line numberDiff line numberDiff line change
@@ -88,8 +88,8 @@ class Solution {
8888
```
8989

9090
**复杂度分析**
91-
- 时间复杂度：节点最多只遍历N*logN遍，时间复杂度为$O(NlogN)$
92-
- 空间复杂度：空间复杂度为$O(1)$
91+
- 时间复杂度：节点最多只遍历N*logN遍，时间复杂度为$$O(NlogN)$$
92+
- 空间复杂度：空间复杂度为$$O(1)$$
9393

9494
### 缓存法
9595
因为链表访问中点的时间复杂度为O(n),所以可以使用数组将链表的值存储,以空间换时间
@@ -217,6 +217,6 @@ class Solution
217217
```
218218

219219
**复杂度分析**
220-
- 时间复杂度：节点最多只遍历两遍，时间复杂度为$O(N)$
221-
- 空间复杂度：若使用数组对链表的值进行缓存，空间复杂度为$O(N)$
220+
- 时间复杂度：节点最多只遍历两遍，时间复杂度为$$O(N)$$
221+
- 空间复杂度：若使用数组对链表的值进行缓存，空间复杂度为$$O(N)$$
222222

‎problems/11.container-with-most-water.md

+4-4
Original file line numberDiff line numberDiff line change
@@ -34,7 +34,7 @@ https://leetcode-cn.com/problems/container-with-most-water/description/
3434

3535
## 思路
3636

37-
题目中说`找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。` ，因此符合直觉的解法就是固定两个端点，计算可以承载的水量， 然后不断更新最大值，最后返回最大值即可。这种算法，需要两层循环，时间复杂度是 $O(n^2)$。
37+
题目中说`找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。` ，因此符合直觉的解法就是固定两个端点，计算可以承载的水量， 然后不断更新最大值，最后返回最大值即可。这种算法，需要两层循环，时间复杂度是 $$O(n^2)$$。
3838

3939
代码（JS）:
4040

@@ -60,7 +60,7 @@ return max;
6060
- ...
6161
- 计算长度为 1 的面积。
6262

63-
很显然这种解法也是完备的，但是似乎时间复杂度还是 $O(n ^ 2)$, 不要着急，我们继续优化。
63+
很显然这种解法也是完备的，但是似乎时间复杂度还是 $$O(n ^ 2)$$, 不要着急，我们继续优化。
6464

6565
考虑一下，如果我们计算 n-1 长度的面积的时候，是可以直接排除一半的结果的。
6666

@@ -149,8 +149,8 @@ class Solution:
149149

150150
**_复杂度分析_**
151151

152-
- 时间复杂度：由于左右指针移动的次数加起来正好是 n， 因此时间复杂度为 $O(N)$。
153-
- 空间复杂度：$O(1)$。
152+
- 时间复杂度：由于左右指针移动的次数加起来正好是 n， 因此时间复杂度为 $$O(N)$$。
153+
- 空间复杂度：$$O(1)$$。
154154

155155
更多题解可以访问我的 LeetCode 题解仓库：https://github.com/azl397985856/leetcode 。 目前已经 37K star 啦。
156156

‎problems/1104.path-in-zigzag-labelled-binary-tree.md

+2-2
Original file line numberDiff line numberDiff line change
@@ -91,8 +91,8 @@ class Solution:
9191
```
9292

9393
**复杂度分析**
94-
- 时间复杂度：由于每次都在头部插入 res，因此时间复杂度为 $O(log_Label)$， 一共插入了 $O(log_Label)$ 次， 因此总的时间复杂度为 $O(logLabel * logLabel)$。
95-
- 空间复杂度：$O(1)$
94+
- 时间复杂度：由于每次都在头部插入 res，因此时间复杂度为 $$O(log_Label)$$， 一共插入了 $$O(log_Label)$$ 次， 因此总的时间复杂度为 $$O(logLabel * logLabel)$$。
95+
- 空间复杂度：$$O(1)$$
9696

9797
大家对此有何看法，欢迎给我留言，我有时间都会一一查看回答。更多算法套路可以访问我的 LeetCode 题解仓库：https://github.com/azl397985856/leetcode 。 目前已经 37K star 啦。
9898
大家也可以关注我的公众号《力扣加加》带你啃下算法这块硬骨头。

‎problems/1131.maximum-of-absolute-value-expression.md

+2-2
Original file line numberDiff line numberDiff line change
@@ -190,8 +190,8 @@ class Solution:
190190

191191
**复杂度分析**
192192

193-
- 时间复杂度：$O(N^3)$
194-
- 空间复杂度：$O(N)$
193+
- 时间复杂度：$$O(N^3)$$
194+
- 空间复杂度：$$O(N)$$
195195

196196
## 总结
197197

‎problems/1186.maximum-subarray-sum-with-one-deletion.md

+2-2
Original file line numberDiff line numberDiff line change
@@ -150,8 +150,8 @@ class Solution:
150150
```
151151

152152
**复杂度分析**
153-
- 时间复杂度：$O(N)$
154-
- 空间复杂度：$O(1)$
153+
- 时间复杂度：$$O(N)$$
154+
- 空间复杂度：$$O(1)$$
155155

156156
## 关键点解析
157157

‎problems/121.best-time-to-buy-and-sell-stock.md

+2-2
Original file line numberDiff line numberDiff line change
@@ -143,8 +143,8 @@ class Solution:
143143

144144
**复杂度分析**
145145

146-
- 时间复杂度：$O(N)$
147-
- 空间复杂度：$O(1)$
146+
- 时间复杂度：$$O(N)$$
147+
- 空间复杂度：$$O(1)$$
148148

149149
## 相关题目
150150

‎problems/1218.longest-arithmetic-subsequence-of-given-difference.md

+4-4
Original file line numberDiff line numberDiff line change
@@ -67,8 +67,8 @@ https://leetcode-cn.com/problems/longest-arithmetic-subsequence-of-given-differe
6767

6868
**复杂度分析**
6969

70-
- 时间复杂度：$O(N^2)$
71-
- 空间复杂度：$O(N)$
70+
- 时间复杂度：$$O(N^2)$$
71+
- 空间复杂度：$$O(N)$$
7272

7373
### 动态规划
7474

@@ -113,8 +113,8 @@ class Solution:
113113

114114
**复杂度分析**
115115

116-
- 时间复杂度：$O(N)$
117-
- 空间复杂度：$O(N)$
116+
- 时间复杂度：$$O(N)$$
117+
- 空间复杂度：$$O(N)$$
118118

119119
大家对此有何看法，欢迎给我留言，我有时间都会一一查看回答。更多算法套路可以访问我的 LeetCode 题解仓库：https://github.com/azl397985856/leetcode 。 目前已经 37K star 啦。
120120
大家也可以关注我的公众号《力扣加加》带你啃下算法这块硬骨头。

‎problems/122.best-time-to-buy-and-sell-stock-ii.md

+2-2
Original file line numberDiff line numberDiff line change
@@ -131,8 +131,8 @@ class Solution {
131131

132132
**复杂度分析**
133133

134-
- 时间复杂度：$O(N)$
135-
- 空间复杂度：$O(1)$
134+
- 时间复杂度：$$O(N)$$
135+
- 空间复杂度：$$O(1)$$
136136

137137
## 相关题目
138138

0 commit comments

Comments
 (0)