feat: update solutions to lc problems

Author: yanglbme

basic/sorting/BubbleSort/README.md

@@ -234,14 +234,14 @@ print(arr)
 
 ## 算法分析
 
-空间复杂度 O(1)、时间复杂度 O(n²)。
+空间复杂度 $O(1)$、时间复杂度 $O(n^2)$。
 
 分情况讨论：
 
-1. 给定的数组按照顺序已经排好：只需要进行 `n-1` 次比较，两两交换次数为 0，时间复杂度为 O(n)，这是最好的情况。
-2. 给定的数组按照逆序排列：需要进行 `n*(n-1)/2` 次比较，时间复杂度为 O(n²)，这是最坏的情况。
-3. 给定的数组杂乱无章。在这种情况下，平均时间复杂度 O(n²)。
+1. 给定的数组按照顺序已经排好：只需要进行 $n-1$ 次比较，两两交换次数为 0，时间复杂度为 $O(n)$，这是最好的情况。
+2. 给定的数组按照逆序排列：需要进行 $\frac{n\times (n-1)}{2}$ 次比较，时间复杂度为 $O(n^2)$，这是最坏的情况。
+3. 给定的数组杂乱无章。在这种情况下，平均时间复杂度 $O(n^2)$。
 
-因此，时间复杂度是 O(n²)，这是一种稳定的排序算法。
+因此，时间复杂度是 $O(n^2)$，这是一种稳定的排序算法。
 
 > 稳定是指，两个相等的数，在排序过后，相对位置保持不变。

basic/sorting/CountingSort/README.md

@@ -69,5 +69,5 @@ func CountingSort(nums []int, min, max int) {
 
 ## 算法分析
 
--   时间复杂度 `O(n+k)`， 其中 `n` 为排序数组长度，`k` 为排序数组中数值的取值范围，当 `k < n` 时，时间复杂度为 `O(n)`
--   空间复杂度 `O(n+k)`， 其中 `n` 为排序数组长度，`k` 为排序数组中数值的取值范围，当 `k < n` 时，空间复杂度为 `O(n)`
+-   时间复杂度 $O(n+k)$， 其中 $n$ 为排序数组长度，而 $k$ 为排序数组中数值的取值范围，当 $k\lt n$ 时，时间复杂度为 $O(n)$。
+-   空间复杂度 $O(n+k)$， 其中 $n$ 为排序数组长度，而 $k$ 为排序数组中数值的取值范围，当 $k\lt n$ 时，空间复杂度为 $O(n)$。

basic/sorting/InsertionSort/README.md

@@ -214,12 +214,12 @@ print(insertion_sort(array))
 
 ## 算法分析
 
-空间复杂度 O(1)，时间复杂度 O(n²)。
+空间复杂度 $O(1)$，时间复杂度 $O(n^2)$。
 
 分情况讨论：
 
-1. 给定的数组按照顺序排好序：只需要进行 n-1 次比较，两两交换次数为 0，时间复杂度为 O(n)，这是最好的情况。
-1. 给定的数组按照逆序排列：需要进行 `n*(n-1)/2` 次比较，时间复杂度为 O(n²)，这是最坏的情况。
-1. 给定的数组杂乱无章：在这种情况下，平均时间复杂度是 O(n²)。
+1. 给定的数组按照顺序排好序：只需要进行 $n-1$ 次比较，两两交换次数为 0，时间复杂度为 $O(n)$，这是最好的情况。
+1. 给定的数组按照逆序排列：需要进行 $\frac{n\times (n-1)}{2}$ 次比较，时间复杂度为 $O(n^2)$，这是最坏的情况。
+1. 给定的数组杂乱无章：在这种情况下，平均时间复杂度是 $O(n^2)$。
 
-因此，时间复杂度是 O(n²)，这也是一种稳定的排序算法。
+因此，时间复杂度是 $O(n^2)$，这也是一种稳定的排序算法。

basic/sorting/SelectionSort/README.md

@@ -217,7 +217,7 @@ print(arr)
 
 ## 算法分析
 
-空间复杂度 O(1)，时间复杂度 O(n²)。
+空间复杂度 $O(1)$，时间复杂度 $O(n^2)$。
 
 那选择排序是稳定的排序算法吗？
 

basic/sorting/ShellSort/README.md

@@ -127,9 +127,9 @@ fn main() {
 
 时间复杂度：
 
-希尔排序的时间性能取决于所取“增量”序列的函数，这涉及到一些数学上尚未解决的难题。但是有人通过大量的实验，给出了较好的结果：当 n 较大时，比较和移动的次数约在 `n^1.25` 到 `(1.6n)^1.25` 之间。所以可以这样简单记忆：
+希尔排序的时间性能取决于所取“增量”序列的函数，这涉及到一些数学上尚未解决的难题。但是有人通过大量的实验，给出了较好的结果：当 $n$ 较大时，比较和移动的次数约在 $n^{1.25}$ 到 ${1.6n}^{1.25}$ 之间。所以可以这样简单记忆：
 
--   当 n 较小时，希尔排序和插入排序相差不大，都为 n² 左右。
--   当 n 很大时，时间增长幅度逐渐放缓，平均复杂度是 nlogn。
+-   当 $n$ 较小时，希尔排序和插入排序相差不大，都为 $n^2$ 左右。
+-   当 $n$ 很大时，时间增长幅度逐渐放缓，平均复杂度是 $O(n\log n)$。
 
-空间复杂度：O(1)。
+空间复杂度：$O(1)$。

lcci/01.02.Check Permutation/README.md

@@ -30,11 +30,13 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
-**方法一：**
+**方法一：哈希表**
 
-使用哈希表作为字符计数器，`O(n)` 时间内解决。
+使用哈希表作为字符计数器。
 
-**方法二：**
+时间复杂度 $O(n)$。
+
+**方法二：排序**
 
 按照字符编码重新排序字符串，再检查两者一致性。
 

lcci/08.06.Hanota/README.md

@@ -1,6 +1,9 @@
 # [面试题 08.06. 汉诺塔问题](https://leetcode.cn/problems/hanota-lcci)
+
 [English Version](/lcci/08.06.Hanota/README_EN.md)
+
 ## 题目描述
+
 <!-- 这里写题目描述 -->
 <p>在经典汉诺塔问题中，有 3 根柱子及 N 个不同大小的穿孔圆盘，盘子可以滑入任意一根柱子。一开始，所有盘子自上而下按升序依次套在第一根柱子上(即每一个盘子只能放在更大的盘子上面)。移动圆盘时受到以下限制:<br>
 (1) 每次只能移动一个盘子;<br>
@@ -20,21 +23,33 @@
 <ol>
 	<li>A中盘子的数目不大于14个。</li>
 </ol>
+
 ## 解法
+
 <!-- 这里可写通用的实现逻辑 -->
+
 <!-- tabs:start -->
+
 ### **Python3**
+
 <!-- 这里可写当前语言的特殊实现逻辑 -->
+
 ```python
 
 ```
+
 ### **Java**
+
 <!-- 这里可写当前语言的特殊实现逻辑 -->
+
 ```java
 
 ```
+
 ### **...**
+
 ```
 
 ```
+
 <!-- tabs:end -->

lcci/08.06.Hanota/README_EN.md

@@ -1,6 +1,9 @@
 # [08.06. Hanota](https://leetcode.cn/problems/hanota-lcci)
+
 [中文文档](/lcci/08.06.Hanota/README.md)
+
 ## Description
+
 <p>In the classic problem of the Towers of Hanoi, you have 3 towers and N disks of different sizes which can slide onto any tower. The puzzle starts with disks sorted in ascending order of size from top to bottom (i.e., each disk sits on top of an even larger one). You have the following constraints:</p>
 <p>(1) Only one disk can be moved at a time.<br />
 (2) A disk is slid off the top of one tower onto another tower.<br />
@@ -26,18 +29,27 @@
 <ol>
 	<li><code>A.length &lt;= 14</code></li>
 </ol>
+
 ## Solutions
+
 <!-- tabs:start -->
+
 ### **Python3**
+
 ```python
 
 ```
+
 ### **Java**
+
 ```java
 
 ```
+
 ### **...**
+
 ```
 
 ```
+
 <!-- tabs:end -->

lcci/08.08.Permutation II/README.md

@@ -1,6 +1,9 @@
 # [面试题 08.08. 有重复字符串的排列组合](https://leetcode.cn/problems/permutation-ii-lcci)
+
 [English Version](/lcci/08.08.Permutation%20II/README_EN.md)
+
 ## 题目描述
+
 <!-- 这里写题目描述 -->
 <p>有重复字符串的排列组合。编写一种方法，计算某字符串的所有排列组合。</p>
 <p><strong>示例1:</strong></p>
@@ -16,20 +19,31 @@
 	<li>字符都是英文字母。</li>
 	<li>字符串长度在[1, 9]之间。</li>
 </ol>
+
 ## 解法
+
 <!-- 这里可写通用的实现逻辑 -->
+
 <!-- tabs:start -->
+
 ### **Python3**
+
 <!-- 这里可写当前语言的特殊实现逻辑 -->
+
 ```python
 
 ```
+
 ### **Java**
+
 <!-- 这里可写当前语言的特殊实现逻辑 -->
+
 ```java
 
 ```
+
 ### **JavaScript**
+
 ```js
 /**
  * @param {string} S
@@ -66,8 +80,11 @@ function dfs(arr, depth, prev, record, res) {
     }
 }
 ```
+
 ### **...**
+
 ```
 
 ```
+
 <!-- tabs:end -->

lcci/08.08.Permutation II/README_EN.md

@@ -1,6 +1,9 @@
 # [08.08. Permutation II](https://leetcode.cn/problems/permutation-ii-lcci)
+
 [中文文档](/lcci/08.08.Permutation%20II/README.md)
+
 ## Description
+
 <p>Write a method to compute all permutations of a string whose charac&shy; ters are not necessarily unique. The list of permutations should not have duplicates.</p>
 <p><strong>Example1:</strong></p>
 <pre>
@@ -23,17 +26,25 @@
 	<li>All characters are English letters.</li>
 	<li><code>1 &lt;= S.length &lt;= 9</code></li>
 </ol>
+
 ## Solutions
+
 <!-- tabs:start -->
+
 ### **Python3**
+
 ```python
 
 ```
+
 ### **Java**
+
 ```java
 
 ```
+
 ### **JavaScript**
+
 ```js
 /**
  * @param {string} S
@@ -70,8 +81,11 @@ function dfs(arr, depth, prev, record, res) {
     }
 }
 ```
+
 ### **...**
+
 ```
 
 ```
+
 <!-- tabs:end -->

lcci/08.11.Coin/README.md

@@ -1,6 +1,9 @@
 # [面试题 08.11. 硬币](https://leetcode.cn/problems/coin-lcci)
+
 [English Version](/lcci/08.11.Coin/README_EN.md)
+
 ## 题目描述
+
 <!-- 这里写题目描述 -->
 <p>硬币。给定数量不限的硬币，币值为25分、10分、5分和1分，编写代码计算n分有几种表示法。(结果可能会很大，你需要将结果模上1000000007)</p>
 <p> <strong>示例1:</strong></p>
@@ -27,21 +30,31 @@
 <ul>
     <li>0 &lt;= n (总金额) &lt;= 1000000</li>
 </ul>
+
 ## 解法
-完全背包问题
+
 <!-- 这里可写通用的实现逻辑 -->
+
+**方法一：动态规划**
+
 <!-- tabs:start -->
 ### **Python3**
+
 <!-- 这里可写当前语言的特殊实现逻辑 -->
+
 ```python
 
 ```
 ### **Java**
+
 <!-- 这里可写当前语言的特殊实现逻辑 -->
+
 ```java
 
 ```
+
 ### **TypeScript**
+
 ```ts
 function waysToChange(n: number): number {
     const MOD = 10 ** 9 + 7;
@@ -56,8 +69,11 @@ function waysToChange(n: number): number {
     return dp.pop() % MOD;
 }
 ```
+
 ### **...**
+
 ```
 
 ```
+
 <!-- tabs:end -->

lcci/08.11.Coin/README_EN.md

@@ -1,6 +1,9 @@
 # [08.11. Coin](https://leetcode.cn/problems/coin-lcci)
+
 [中文文档](/lcci/08.11.Coin/README.md)
+
 ## Description
+
 <p>Given an infinite number of quarters (25 cents), dimes (10 cents), nickels (5 cents), and pennies (1 cent), write code to calculate the number of ways of representing n cents.&nbsp;(The result may be large, so you should return it modulo 1000000007)</p>
 <p><strong>Example1:</strong></p>
 <pre>
@@ -39,17 +42,25 @@
 <ul>
 	<li>0 &lt;= n&nbsp;&lt;= 1000000</li>
 </ul>
+
 ## Solutions
+
 <!-- tabs:start -->
+
 ### **Python3**
+
 ```python
 
 ```
+
 ### **Java**
+
 ```java
 
 ```
+
 ### **TypeScript**
+
 ```ts
 function waysToChange(n: number): number {
     const MOD = 10 ** 9 + 7;
@@ -64,8 +75,11 @@ function waysToChange(n: number): number {
     return dp.pop() % MOD;
 }
 ```
+
 ### **...**
+
 ```
 
 ```
+
 <!-- tabs:end -->

lcci/10.10.Rank from Stream/README.md

@@ -33,14 +33,14 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
-树状数组。
+**方法一：树状数组**
 
 树状数组，也称作“二叉索引树”（Binary Indexed Tree）或 Fenwick 树。 它可以高效地实现如下两个操作：
 
 1. **单点更新** `update(x, delta)`： 把序列 x 位置的数加上一个值 delta；
 1. **前缀和查询** `query(x)`：查询序列 `[1,...x]` 区间的区间和，即位置 x 的前缀和。
 
-这两个操作的时间复杂度均为 `O(log n)`。
+这两个操作的时间复杂度均为 $O(\log n)$。
 
 树状数组最基本的功能就是求比某点 x 小的点的个数（这里的比较是抽象的概念，可以是数的大小、坐标的大小、质量的大小等等）。
 

lcci/17.12.BiNode/README.md

@@ -33,7 +33,7 @@
 
 中序遍历过程中改变指针指向。
 
-时间复杂度 O(n)。
+时间复杂度 $O(n)$。
 
 同 [897. 递增顺序查找树](/solution/0800-0899/0897.Increasing%20Order%20Search%20Tree/README.md)。