文档更新

Author: cloudyan

README.zh-CN.md

@@ -1,9 +1,5 @@
 # JavaScript 算法与数据结构
 
-## TypeScript 版本
-
-参考 https://github.com/loiane/javascript-datastructures-algorithms
-
 [![CI](https://github.com/trekhleb/javascript-algorithms/workflows/CI/badge.svg)](https://github.com/trekhleb/javascript-algorithms/actions?query=workflow%3ACI+branch%3Amaster)
 [![codecov](https://codecov.io/gh/trekhleb/javascript-algorithms/branch/master/graph/badge.svg)](https://codecov.io/gh/trekhleb/javascript-algorithms)
 
@@ -288,7 +284,6 @@ npm test -- 'playground'
 
 ### 数组排序算法的复杂性
 
-<<<<<<< HEAD
 | 名称         |   最优   |      平均      |     最坏     |  内存  | 稳定 | 备注                                           |
 | ------------ | :------: | :------------: | :----------: | :----: | :--: | ---------------------------------------------- |
 | **冒泡排序** |    n     |      n^2       |     n^2      |   1    | Yes  |                                                |
@@ -302,29 +297,16 @@ npm test -- 'playground'
 | **基数排序** |  n \* k  |     n \* k     |    n \* k    | n + k  | Yes  | k - 最长 key 的升序                            |
 
 > ℹ️ A few more [projects](https://trekhleb.dev/projects/) and [articles](https://trekhleb.dev/blog/) about JavaScript and algorithms on [trekhleb.dev](https://trekhleb.dev)
-=======
-| 名称                  | 最优      | 平均      | 最坏          | 内存      | 稳定      | 备注                  |
-| --------------------- | :-------: | :-------: | :-----------: | :-------: | :-------: | --------------------- |
-| **冒泡排序**          | n         | n^2       | n^2           | 1         | Yes       |                       |
-| **插入排序**          | n         | n^2       | n^2           | 1         | Yes       |                       |
-| **选择排序**          | n^2       | n^2       | n^2           | 1         | No        |                       |
-| **堆排序**            | n log(n)  | n log(n)  | n log(n)      | 1         | No        |                       |
-| **归并排序**          | n log(n)  | n log(n)  | n log(n)      | n         | Yes       |                       |
-| **快速排序**          | n log(n)  | n log(n)  | n^2           | log(n)    | No        | 在 in-place 版本下，内存复杂度通常是 O(log(n)) |
-| **希尔排序**          | n log(n)  | 取决于差距序列   | n (log(n))^2  | 1         | No        |  |
-| **计数排序**          | n + r     | n + r     | n + r         | n + r     | Yes       | r - 数组里最大的数    |
-| **基数排序**          | n * k     | n * k     | n * k         | n + k     | Yes       | k - 最长 key 的升序   |
 
 ## 扩展学习
 
-* TypeScript 版本
-* 算法可视化
+- [TypeScript 版本](https://github.com/loiane/javascript-datastructures-algorithms)
+- [算法可视化](https://visualgo.net/zh)
 
 参考资料
 
-* https://github.com/loiane/javascript-datastructures-algorithms
-* https://visualgo.net/zh
-* https://coolshell.cn/articles/4671.html
-  * https://www.cs.usfca.edu/~galles/visualization/Algorithms.html
-  * https://www.cs.usfca.edu/~galles/visualization/source.html
->>>>>>> 5b541e4 (更新文档)
+- https://github.com/loiane/javascript-datastructures-algorithms
+- https://visualgo.net/zh
+- https://coolshell.cn/articles/4671.html
+  - https://www.cs.usfca.edu/~galles/visualization/Algorithms.html
+  - https://www.cs.usfca.edu/~galles/visualization/source.html

src/algorithms/math/bits/README.zh-CN.md

@@ -4,6 +4,16 @@ _Read this in other languages:_
 [français](README.fr-FR.md),
 [english](README.md)
 
+### Bit 操控
+
+- set
+- get
+- update
+- clear
+- 乘
+- 除
+- 变负
+
 #### Get Bit
 
 该方法向右移动目标位到最右边，即位数组的第0个位置上。然后在该数上与形如 `0001`的二进制形式的数进行`AND`操作。这会清理掉除了目标位的所有其它位的数据。如果目标位是1，那么结果就是`1`，反之，结果是`0`;
@@ -226,7 +236,7 @@ B = 6: 110
 └──────┴────┴────┴─────────┴──────────┴─────────┴───────────┴───────────┘
 ```
 
-> 查看[fullAdder.js](fullAdder.js)了解更多细节。  
+> 查看[fullAdder.js](fullAdder.js)了解更多细节。
 > 查看[Full Adder on YouTube](https://www.youtube.com/watch?v=wvJc9CZcvBc&list=PLLXdhg_r2hKA7DPDsunoDZ-Z769jWn4R8).
 
 ## References

src/algorithms/math/bits/bitLength.js

@@ -1,5 +1,6 @@
 /**
  * Return the number of bits used in the binary representation of the number.
+ * or number.toString(2).length
  *
  * @param {number} number
  * @return {number}

src/algorithms/math/complex-number/README.md

@@ -1,5 +1,7 @@
 # Complex Number
 
+复数 - 复数及其基本运算
+
 _Read this in other languages:_
 [français](README.fr-FR.md).
 

src/algorithms/math/euclidean-algorithm/README.md

@@ -1,5 +1,7 @@
 # Euclidean algorithm
 
+欧几里得算法 - 计算最大公约数 (GCD)
+
 _Read this in other languages:_
 [français](README.fr-FR.md).
 

src/algorithms/math/factorial/README.zh-CN.md

@@ -6,7 +6,7 @@
 5! = 5 * 4 * 3 * 2 * 1 = 120
 ```
 
-| n     | n!                          | 
+| n     | n!                          |
 | ----- | --------------------------: |
 | 0     | 1                           |
 | 1     | 1                           |
@@ -25,3 +25,8 @@
 | 14    | 87 178 291 200              |
 | 15    | 1 307 674 368 000           |
 
+实现方式
+
+- 迭代方式 iter
+- 递归方式 recurse
+- 尾递归优化 tail

src/algorithms/math/fast-powering/README.md

@@ -1,5 +1,7 @@
 # Fast Powering Algorithm
 
+快速算次方
+
 _Read this in other languages:_
 [français](README.fr-FR.md).
 

src/algorithms/math/fibonacci/README.zh-CN.md

@@ -1,5 +1,7 @@
 # 斐波那契数
 
+斐波那契数 - `经典` 和 `闭式` 版本
+
 _Read this in other languages:_
 [français](README.fr-FR.md),
 [english](README.md),

src/algorithms/math/fourier-transform/README.md

@@ -3,6 +3,8 @@
 _Read this in other languages:_
 [français](README.fr-FR.md).
 
+离散傅里叶变换 - 把时间信号解析成构成它的频率
+
 ## Definitions
 
 The **Fourier Transform** (**FT**) decomposes a function of time (a signal) into

src/algorithms/math/integer-partition/README.md

@@ -1,11 +1,13 @@
 # Integer Partition
 
-In number theory and combinatorics, a partition of a positive 
-integer `n`, also called an **integer partition**, is a way of 
-writing `n` as a sum of positive integers. 
+整数拆分
 
-Two sums that differ only in the order of their summands are 
-considered the same partition. For example, `4` can be partitioned 
+In number theory and combinatorics, a partition of a positive
+integer `n`, also called an **integer partition**, is a way of
+writing `n` as a sum of positive integers.
+
+Two sums that differ only in the order of their summands are
+considered the same partition. For example, `4` can be partitioned
 in five distinct ways:
 
 ```
@@ -17,13 +19,13 @@ in five distinct ways:
 ```
 
 The order-dependent composition `1 + 3` is the same partition
-as `3 + 1`, while the two distinct 
-compositions `1 + 2 + 1` and `1 + 1 + 2` represent the same 
+as `3 + 1`, while the two distinct
+compositions `1 + 2 + 1` and `1 + 1 + 2` represent the same
 partition `2 + 1 + 1`.
 
 Young diagrams associated to the partitions of the positive
-integers `1` through `8`. They are arranged so that images 
-under the reflection about the main diagonal of the square 
+integers `1` through `8`. They are arranged so that images
+under the reflection about the main diagonal of the square
 are conjugate partitions.
 
 ![Integer Partition](https://upload.wikimedia.org/wikipedia/commons/d/d8/Ferrer_partitioning_diagrams.svg)

src/algorithms/math/is-power-of-two/README.md

@@ -1,5 +1,7 @@
 # Is a power of two
 
+判断 2 次方数 - 检查数字是否为 2 的幂 (原生和按位算法)
+
 Given a positive integer, write a function to find if it is
 a power of two or not.
 

src/algorithms/math/least-common-multiple/README.md

@@ -1,11 +1,13 @@
 # Least common multiple
 
-In arithmetic and number theory, the least common multiple, 
-lowest common multiple, or smallest common multiple of 
-two integers `a` and `b`, usually denoted by `LCM(a, b)`, is 
-the smallest positive integer that is divisible by 
-both `a` and `b`. Since division of integers by zero is 
-undefined, this definition has meaning only if `a` and `b` are 
+最小公倍数 (LCM)
+
+In arithmetic and number theory, the least common multiple,
+lowest common multiple, or smallest common multiple of
+two integers `a` and `b`, usually denoted by `LCM(a, b)`, is
+the smallest positive integer that is divisible by
+both `a` and `b`. Since division of integers by zero is
+undefined, this definition has meaning only if `a` and `b` are
 both different from zero. However, some authors define `lcm(a,0)`
 as `0` for all `a`, which is the result of taking the `lcm`
 to be the least upper bound in the lattice of divisibility.
@@ -26,20 +28,20 @@ and the multiples of `6` are:
 6, 12, 18, 24, 30, 36, 42, 48, 54, 60, 66, 72, ...
 ```
 
-Common multiples of `4` and `6` are simply the numbers 
+Common multiples of `4` and `6` are simply the numbers
 that are in both lists:
 
 ```
 12, 24, 36, 48, 60, 72, ....
 ```
 
-So, from this list of the first few common multiples of 
+So, from this list of the first few common multiples of
 the numbers `4` and `6`, their least common multiple is `12`.
 
 ## Computing the least common multiple
 
-The following formula reduces the problem of computing the 
-least common multiple to the problem of computing the greatest 
+The following formula reduces the problem of computing the
+least common multiple to the problem of computing the greatest
 common divisor (GCD), also known as the greatest common factor:
 
 ```
@@ -48,11 +50,11 @@ lcm(a, b) = |a * b| / gcd(a, b)
 
 ![LCM](https://upload.wikimedia.org/wikipedia/commons/c/c9/Symmetrical_5-set_Venn_diagram_LCM_2_3_4_5_7.svg)
 
-A Venn diagram showing the least common multiples of 
-combinations of `2`, `3`, `4`, `5` and `7` (`6` is skipped as 
+A Venn diagram showing the least common multiples of
+combinations of `2`, `3`, `4`, `5` and `7` (`6` is skipped as
 it is `2 × 3`, both of which are already represented).
 
-For example, a card game which requires its cards to be 
+For example, a card game which requires its cards to be
 divided equally among up to `5` players requires at least `60`
 cards, the number at the intersection of the `2`, `3`, `4`
 and `5` sets, but not the `7` set.

src/algorithms/math/liu-hui/README.md

@@ -1,66 +1,68 @@
 # Liu Hui's π Algorithm
 
+割圆术 - 基于 N-gons 的近似 π 计算
+
 Liu Hui remarked in his commentary to The Nine Chapters on the Mathematical Art,
-that the ratio of the circumference of an inscribed hexagon to the diameter of 
-the circle was `three`, hence `π` must be greater than three. He went on to provide 
-a detailed step-by-step description of an iterative algorithm to calculate `π` to 
-any required accuracy based on bisecting polygons; he calculated `π` to 
-between `3.141024` and `3.142708` with a 96-gon; he suggested that `3.14` was 
-a good enough approximation, and expressed `π` as `157/50`; he admitted that 
-this number was a bit small. Later he invented an ingenious quick method to 
-improve on it, and obtained `π ≈ 3.1416` with only a 96-gon, with an accuracy 
-comparable to that from a 1536-gon. His most important contribution in this 
+that the ratio of the circumference of an inscribed hexagon to the diameter of
+the circle was `three`, hence `π` must be greater than three. He went on to provide
+a detailed step-by-step description of an iterative algorithm to calculate `π` to
+any required accuracy based on bisecting polygons; he calculated `π` to
+between `3.141024` and `3.142708` with a 96-gon; he suggested that `3.14` was
+a good enough approximation, and expressed `π` as `157/50`; he admitted that
+this number was a bit small. Later he invented an ingenious quick method to
+improve on it, and obtained `π ≈ 3.1416` with only a 96-gon, with an accuracy
+comparable to that from a 1536-gon. His most important contribution in this
 area was his simple iterative `π` algorithm.
 
 ## Area of a circle
 
 Liu Hui argued:
 
-> Multiply one side of a hexagon by the radius (of its 
-circumcircle), then multiply this by three, to yield the 
-area of a dodecagon; if we cut a hexagon into a 
-dodecagon, multiply its side by its radius, then again 
-multiply by six, we get the area of a 24-gon; the finer 
-we cut, the smaller the loss with respect to the area 
-of circle, thus with further cut after cut, the area of 
-the resulting polygon will coincide and become one with 
+> Multiply one side of a hexagon by the radius (of its
+circumcircle), then multiply this by three, to yield the
+area of a dodecagon; if we cut a hexagon into a
+dodecagon, multiply its side by its radius, then again
+multiply by six, we get the area of a 24-gon; the finer
+we cut, the smaller the loss with respect to the area
+of circle, thus with further cut after cut, the area of
+the resulting polygon will coincide and become one with
 the circle; there will be no loss
 
 ![Liu Hui](https://upload.wikimedia.org/wikipedia/commons/6/69/Cutcircle2.svg)
 
 Liu Hui's method of calculating the area of a circle.
 
-Further, Liu Hui proved that the area of a circle is half of its circumference 
+Further, Liu Hui proved that the area of a circle is half of its circumference
 multiplied by its radius. He said:
 
-> Between a polygon and a circle, there is excess radius. Multiply the excess 
-radius by a side of the polygon. The resulting area exceeds the boundary of 
+> Between a polygon and a circle, there is excess radius. Multiply the excess
+radius by a side of the polygon. The resulting area exceeds the boundary of
 the circle
 
-In the diagram `d = excess radius`. Multiplying `d` by one side results in 
-oblong `ABCD` which exceeds the boundary of the circle. If a side of the polygon 
-is small (i.e. there is a very large number of sides), then the excess radius 
+In the diagram `d = excess radius`. Multiplying `d` by one side results in
+oblong `ABCD` which exceeds the boundary of the circle. If a side of the polygon
+is small (i.e. there is a very large number of sides), then the excess radius
 will be small, hence excess area will be small.
 
-> Multiply the side of a polygon by its radius, and the area doubles; 
+> Multiply the side of a polygon by its radius, and the area doubles;
 hence multiply half the circumference by the radius to yield the area of circle.
 
 ![Liu Hui](https://upload.wikimedia.org/wikipedia/commons/9/95/Cutcircle.svg)
 
-The area within a circle is equal to the radius multiplied by half the 
+The area within a circle is equal to the radius multiplied by half the
 circumference, or `A = r x C/2 = r x r x π`.
 
 ## Iterative algorithm
 
-Liu Hui began with an inscribed hexagon. Let `M` be the length of one side `AB` of 
+Liu Hui began with an inscribed hexagon. Let `M` be the length of one side `AB` of
 hexagon, `r` is the radius of circle.
 
 ![Liu Hui](https://upload.wikimedia.org/wikipedia/commons/4/46/Liuhui_geyuanshu.svg)
 
-Bisect `AB` with line `OPC`, `AC` becomes one side of dodecagon (12-gon), let 
+Bisect `AB` with line `OPC`, `AC` becomes one side of dodecagon (12-gon), let
 its length be `m`. Let the length of `PC` be `j` and the length of `OP` be `G`.
 
-`AOP`, `APC` are two right angle triangles. Liu Hui used 
+`AOP`, `APC` are two right angle triangles. Liu Hui used
 the [Gou Gu](https://en.wikipedia.org/wiki/Pythagorean_theorem) (Pythagorean theorem)
 theorem repetitively:
 
@@ -79,12 +81,12 @@ theorem repetitively:
 ![](https://wikimedia.org/api/rest_v1/media/math/render/svg/3ffeafe88d2983b364ad3442746063e3207fe842)
 
 
-From here, there is now a technique to determine `m` from `M`, which gives the 
-side length for a polygon with twice the number of edges. Starting with a 
-hexagon, Liu Hui could determine the side length of a dodecagon using this 
-formula. Then continue repetitively to determine the side length of a 
-24-gon given the side length of a dodecagon. He could do this recursively as 
-many times as necessary. Knowing how to determine the area of these polygons, 
+From here, there is now a technique to determine `m` from `M`, which gives the
+side length for a polygon with twice the number of edges. Starting with a
+hexagon, Liu Hui could determine the side length of a dodecagon using this
+formula. Then continue repetitively to determine the side length of a
+24-gon given the side length of a dodecagon. He could do this recursively as
+many times as necessary. Knowing how to determine the area of these polygons,
 Liu Hui could then approximate `π`.
 
 ## References