remote $

kelly7707 · Mar 31, 2022 · 6259a0e · 6259a0e
1 parent 77aa72b
commit 6259a0e
Show file tree

Hide file tree

Showing 45 changed files with 210 additions and 210 deletions.
diff --git a/problems/0005.最长回文子串.md b/problems/0005.最长回文子串.md
@@ -38,7 +38,7 @@
 
 两层for循环，遍历区间起始位置和终止位置，然后判断这个区间是不是回文。
 
-时间复杂度：$O(n^3)$
+时间复杂度：O(n^3)
 
 ## 动态规划
 
@@ -205,8 +205,8 @@ public:
 
 ```
 
-* 时间复杂度：$O(n^2)$
-* 空间复杂度：$O(n^2)$
+* 时间复杂度：O(n^2)
+* 空间复杂度：O(n^2)
 
 ## 双指针
 
@@ -253,8 +253,8 @@ public:
 
 ```
 
-* 时间复杂度：$O(n^2)$
-* 空间复杂度：$O(1)$
+* 时间复杂度：O(n^2)
+* 空间复杂度：O(1)
 
 
 

diff --git a/problems/0027.移除元素.md b/problems/0027.移除元素.md
@@ -11,7 +11,7 @@
 
 给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。
 
-不要使用额外的数组空间，你必须仅使用 $O(1)$ 额外空间并**原地**修改输入数组。
+不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并**原地**修改输入数组。
 
 元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。
 
@@ -42,7 +42,7 @@
 
 ![27.移除元素-暴力解法](https://tva1.sinaimg.cn/large/008eGmZEly1gntrc7x9tjg30du09m1ky.gif)
 
-很明显暴力解法的时间复杂度是$O(n^2)$，这道题目暴力解法在leetcode上是可以过的。
+很明显暴力解法的时间复杂度是O(n^2)，这道题目暴力解法在leetcode上是可以过的。
 
 代码如下：
 
@@ -68,8 +68,8 @@ public:
 };
 ```
 
-* 时间复杂度：$O(n^2)$
-* 空间复杂度：$O(1)$
+* 时间复杂度：O(n^2)
+* 空间复杂度：O(1)
 
 ### 双指针法
 
@@ -101,16 +101,16 @@ public:
 ```
 注意这些实现方法并没有改变元素的相对位置！
 
-* 时间复杂度：$O(n)$
-* 空间复杂度：$O(1)$
+* 时间复杂度：O(n)
+* 空间复杂度：O(1)
 
 旧文链接：[数组：就移除个元素很难么？](https://programmercarl.com/0027.移除元素.html)
 
 ```CPP
 /**
 * 相向双指针方法，基于元素顺序可以改变的题目描述改变了元素相对位置，确保了移动最少元素
-* 时间复杂度：$O(n)$
-* 空间复杂度：$O(1)$
+* 时间复杂度：O(n)
+* 空间复杂度：O(1)
 */
 class Solution {
 public:

diff --git a/problems/0028.实现strStr.md b/problems/0028.实现strStr.md
@@ -229,9 +229,9 @@ next数组就可以是前缀表，但是很多实现都是把前缀表统一减
 
 # 时间复杂度分析
 
-其中n为文本串长度，m为模式串长度，因为在匹配的过程中，根据前缀表不断调整匹配的位置，可以看出匹配的过程是$O(n)$，之前还要单独生成next数组，时间复杂度是$O(m)$。所以整个KMP算法的时间复杂度是$O(n+m)$的。
+其中n为文本串长度，m为模式串长度，因为在匹配的过程中，根据前缀表不断调整匹配的位置，可以看出匹配的过程是O(n)，之前还要单独生成next数组，时间复杂度是O(m)。所以整个KMP算法的时间复杂度是O(n+m)的。
 
-暴力的解法显而易见是$O(n × m)$，所以**KMP在字符串匹配中极大的提高的搜索的效率。**
+暴力的解法显而易见是O(n × m)，所以**KMP在字符串匹配中极大的提高的搜索的效率。**
 
 为了和力扣题目28.实现strStr保持一致，方便大家理解，以下文章统称haystack为文本串, needle为模式串。
 

diff --git a/problems/0042.接雨水.md b/problems/0042.接雨水.md
@@ -129,8 +129,8 @@ public:
 };
 ```
 
-因为每次遍历列的时候，还要向两边寻找最高的列，所以时间复杂度为$O(n^2)$。
-空间复杂度为$O(1)$。
+因为每次遍历列的时候，还要向两边寻找最高的列，所以时间复杂度为O(n^2)。
+空间复杂度为O(1)。
 
 
 
@@ -779,8 +779,8 @@ int trap(int* height, int heightSize) {
 }
 ```
 
-* 时间复杂度 $O(n)$
-* 空间复杂度 $O(1)$
+* 时间复杂度 O(n)
+* 空间复杂度 O(1)
 
 
 -----------------------

diff --git a/problems/0053.最大子序和.md b/problems/0053.最大子序和.md
@@ -21,8 +21,8 @@
 
 暴力解法的思路，第一层for 就是设置起始位置，第二层for循环遍历数组寻找最大值
 
-* 时间复杂度：$O(n^2)$
-* 空间复杂度：$O(1)$
+* 时间复杂度：O(n^2)
+* 空间复杂度：O(1)
 
 ```CPP
 class Solution {
@@ -98,8 +98,8 @@ public:
 };
 ```
 
-* 时间复杂度：$O(n)$
-* 空间复杂度：$O(1)$
+* 时间复杂度：O(n)
+* 空间复杂度：O(1)
 
 当然题目没有说如果数组为空，应该返回什么，所以数组为空的话返回啥都可以了。
 
@@ -128,8 +128,8 @@ public:
 };
 ```
 
-* 时间复杂度：$O(n)$
-* 空间复杂度：$O(n)$
+* 时间复杂度：O(n)
+* 空间复杂度：O(n)
 
 ## 总结
 

diff --git a/problems/0053.最大子序和（动态规划）.md b/problems/0053.最大子序和（动态规划）.md
@@ -80,8 +80,8 @@ public:
 };
 ```
 
-* 时间复杂度：$O(n)$
-* 空间复杂度：$O(n)$
+* 时间复杂度：O(n)
+* 空间复杂度：O(n)
 
 
 ## 总结

diff --git a/problems/0062.不同路径.md b/problems/0062.不同路径.md
@@ -80,7 +80,7 @@ public:
 
 那二叉树的节点个数就是 2^(m + n - 1) - 1。可以理解深搜的算法就是遍历了整个满二叉树（其实没有遍历整个满二叉树，只是近似而已）
 
-所以上面深搜代码的时间复杂度为$O(2^{m + n - 1} - 1)$，可以看出，这是指数级别的时间复杂度，是非常大的。
+所以上面深搜代码的时间复杂度为O(2^(m + n - 1) - 1)，可以看出，这是指数级别的时间复杂度，是非常大的。
 
 ### 动态规划
 
@@ -143,8 +143,8 @@ public:
 };
 ```
 
-* 时间复杂度：$O(m × n)$
-* 空间复杂度：$O(m × n)$
+* 时间复杂度：O(m × n)
+* 空间复杂度：O(m × n)
 
 其实用一个一维数组（也可以理解是滚动数组）就可以了，但是不利于理解，可以优化点空间，建议先理解了二维，在理解一维，C++代码如下：
 
@@ -164,8 +164,8 @@ public:
 };
 ```
 
-* 时间复杂度：$O(m × n)$
-* 空间复杂度：$O(n)$
+* 时间复杂度：O(m × n)
+* 空间复杂度：O(n)
 
 ### 数论方法
 
@@ -224,8 +224,8 @@ public:
 };
 ```
 
-* 时间复杂度：$O(m)$
-* 空间复杂度：$O(1)$
+* 时间复杂度：O(m)
+* 空间复杂度：O(1)
 
 **计算组合问题的代码还是有难度的，特别是处理溢出的情况！**
 

diff --git a/problems/0063.不同路径II.md b/problems/0063.不同路径II.md
@@ -152,8 +152,8 @@ public:
 };
 ```
 
-* 时间复杂度：$O(n × m)$，n、m 分别为obstacleGrid 长度和宽度
-* 空间复杂度：$O(n × m)$
+* 时间复杂度：O(n × m)，n、m 分别为obstacleGrid 长度和宽度
+* 空间复杂度：O(n × m)
 
 ## 总结
 

diff --git a/problems/0122.买卖股票的最佳时机II（动态规划）.md b/problems/0122.买卖股票的最佳时机II（动态规划）.md
@@ -88,8 +88,8 @@ public:
 };
 ```
 
-* 时间复杂度：$O(n)$
-* 空间复杂度：$O(n)$
+* 时间复杂度：O(n)
+* 空间复杂度：O(n)
 
 大家可以本题和[121. 买卖股票的最佳时机](https://programmercarl.com/0121.买卖股票的最佳时机.html)的代码几乎一样，唯一的区别在：
 
@@ -121,8 +121,8 @@ public:
 };
 ```
 
-* 时间复杂度：$O(n)$ 
-* 空间复杂度：$O(1)$
+* 时间复杂度：O(n)
+* 空间复杂度：O(1)
 
 
 

diff --git a/problems/0139.单词拆分.md b/problems/0139.单词拆分.md
@@ -66,8 +66,8 @@ public:
 };
 ```
 
-* 时间复杂度：$O(2^n)$，因为每一个单词都有两个状态，切割和不切割
-* 空间复杂度：$O(n)$，算法递归系统调用栈的空间
+* 时间复杂度：O(2^n)，因为每一个单词都有两个状态，切割和不切割
+* 空间复杂度：O(n)，算法递归系统调用栈的空间
 
 那么以上代码很明显要超时了，超时的数据如下：
 
@@ -114,7 +114,7 @@ public:
 };
 ```
 
-这个时间复杂度其实也是：$O(2^n)$。只不过对于上面那个超时测试用例优化效果特别明显。
+这个时间复杂度其实也是：O(2^n)。只不过对于上面那个超时测试用例优化效果特别明显。
 
 **这个代码就可以AC了，当然回溯算法不是本题的主菜，背包才是！**
 
@@ -207,8 +207,8 @@ public:
 };
 ```
 
-* 时间复杂度：$O(n^3)$，因为substr返回子串的副本是$O(n)$的复杂度（这里的n是substring的长度）
-* 空间复杂度：$O(n)$
+* 时间复杂度：O(n^3)，因为substr返回子串的副本是$O(n)$的复杂度（这里的n是substring的长度）
+* 空间复杂度：O(n)
 
 
 ## 总结

diff --git a/problems/0151.翻转字符串里的单词.md b/problems/0151.翻转字符串里的单词.md
@@ -36,7 +36,7 @@
 
 一些同学会使用split库函数，分隔单词，然后定义一个新的string字符串，最后再把单词倒序相加，那么这道题题目就是一道水题了，失去了它的意义。
 
-所以这里我还是提高一下本题的难度：**不要使用辅助空间，空间复杂度要求为$O(1)$。**
+所以这里我还是提高一下本题的难度：**不要使用辅助空间，空间复杂度要求为O(1)。**
 
 不能使用辅助空间之后，那么只能在原字符串上下功夫了。
 
@@ -81,11 +81,11 @@ void removeExtraSpaces(string& s) {
 
 如果不仔细琢磨一下erase的时间复杂读，还以为以上的代码是$O(n)$的时间复杂度呢。
 
-想一下真正的时间复杂度是多少，一个erase本来就是$O(n)$的操作，erase实现原理题目：[数组：就移除个元素很难么？](https://programmercarl.com/0027.移除元素.html)，最优的算法来移除元素也要$O(n)$。
+想一下真正的时间复杂度是多少，一个erase本来就是O(n)的操作，erase实现原理题目：[数组：就移除个元素很难么？](https://programmercarl.com/0027.移除元素.html)，最优的算法来移除元素也要O(n)。
 
-erase操作上面还套了一个for循环，那么以上代码移除冗余空格的代码时间复杂度为$O(n^2)$。
+erase操作上面还套了一个for循环，那么以上代码移除冗余空格的代码时间复杂度为O(n^2)。
 
-那么使用双指针法来去移除空格，最后resize（重新设置）一下字符串的大小，就可以做到$O(n)$的时间复杂度。
+那么使用双指针法来去移除空格，最后resize（重新设置）一下字符串的大小，就可以做到O(n)的时间复杂度。
 
 如果对这个操作比较生疏了，可以再看一下这篇文章：[数组：就移除个元素很难么？](https://programmercarl.com/0027.移除元素.html)是如何移除元素的。
 

diff --git a/problems/0189.旋转数组.md b/problems/0189.旋转数组.md
@@ -12,7 +12,7 @@
 进阶：
 
 尽可能想出更多的解决方案，至少有三种不同的方法可以解决这个问题。
-你可以使用空间复杂度为 $O(1)$ 的 原地 算法解决这个问题吗？
+你可以使用空间复杂度为 O(1) 的 原地 算法解决这个问题吗？
 
 示例 1:
 
@@ -41,7 +41,7 @@
 
 本题其实和[字符串：剑指Offer58-II.左旋转字符串](https://programmercarl.com/剑指Offer58-II.左旋转字符串.html)就非常像了，剑指offer上左旋转，本题是右旋转。
 
-注意题目要求是**要求使用空间复杂度为 $O(1)$ 的 原地 算法**
+注意题目要求是**要求使用空间复杂度为 O(1) 的 原地 算法**
 
 那么我来提供一种旋转的方式哈。
 

diff --git a/problems/0209.长度最小的子数组.md b/problems/0209.长度最小的子数组.md
@@ -20,7 +20,7 @@
 
 ## 暴力解法
 
-这道题目暴力解法当然是 两个for循环，然后不断的寻找符合条件的子序列，时间复杂度很明显是$O(n^2)$。
+这道题目暴力解法当然是 两个for循环，然后不断的寻找符合条件的子序列，时间复杂度很明显是O(n^2)。
 
 代码如下：
 
@@ -47,8 +47,8 @@ public:
     }
 };
 ```
-时间复杂度：$O(n^2)$
-空间复杂度：$O(1)$
+时间复杂度：O(n^2)
+空间复杂度：O(1)
 
 ## 滑动窗口
 
@@ -80,7 +80,7 @@ public:
 
 ![leetcode_209](https://img-blog.csdnimg.cn/20210312160441942.png)
 
-可以发现**滑动窗口的精妙之处在于根据当前子序列和大小的情况，不断调节子序列的起始位置。从而将$O(n^2)$的暴力解法降为$O(n)$。**
+可以发现**滑动窗口的精妙之处在于根据当前子序列和大小的情况，不断调节子序列的起始位置。从而将O(n^2)暴力解法降为O(n)。**
 
 C++代码如下：
 
@@ -107,12 +107,12 @@ public:
 };
 ```
 
-时间复杂度：$O(n)$
-空间复杂度：$O(1)$
+时间复杂度：O(n)
+空间复杂度：O(1)
 
-**一些录友会疑惑为什么时间复杂度是$O(n)$**。
+**一些录友会疑惑为什么时间复杂度是O(n)**。
 
-不要以为for里放一个while就以为是$O(n^2)$啊， 主要是看每一个元素被操作的次数，每个元素在滑动窗后进来操作一次，出去操作一次，每个元素都是被被操作两次，所以时间复杂度是 2 × n 也就是$O(n)$。
+不要以为for里放一个while就以为是O(n^2)啊， 主要是看每一个元素被操作的次数，每个元素在滑动窗后进来操作一次，出去操作一次，每个元素都是被被操作两次，所以时间复杂度是 2 × n 也就是O(n)。
 
 ## 相关题目推荐
 

diff --git a/problems/0222.完全二叉树的节点个数.md b/problems/0222.完全二叉树的节点个数.md
@@ -105,8 +105,8 @@ public:
 };
 ```
 
-* 时间复杂度：$O(n)$
-* 空间复杂度：$O(\log n)$，算上了递归系统栈占用的空间
+* 时间复杂度：O(n)
+* 空间复杂度：O(log n)，算上了递归系统栈占用的空间
 
 **网上基本都是这个精简的代码版本，其实不建议大家照着这个来写，代码确实精简，但隐藏了一些内容，连遍历的顺序都看不出来，所以初学者建议学习版本一的代码，稳稳的打基础**。
 
@@ -138,8 +138,8 @@ public:
     }
 };
 ```
-* 时间复杂度：$O(n)$
-* 空间复杂度：$O(n)$
+* 时间复杂度：O(n)
+* 空间复杂度：O(n)
 
 ## 完全二叉树
 
@@ -185,8 +185,8 @@ public:
 };
 ```
 
-* 时间复杂度：$O(\log n × \log n)$
-* 空间复杂度：$O(\log n)$
+* 时间复杂度：O(log n × log n)
+* 空间复杂度：O(log n)
 
 # 其他语言版本