2020-07-10 21:21:12

docs/cpp/40.md

@@ -146,7 +146,7 @@ Value of c (c): 2
 
 *   当`c = 5;`时，值 5 存储在变量`c` - `0x7fff5fbff8c`的地址中。
 *   当`pc = &c;`指针`pc`保持`c` - `0x7fff5fbff8c`的地址时，表达式（取消引用运算符）`*pc`输出该地址中存储的值，5。
-*   当由于地址指针`pc`保持为`c = 11;`与`c` - `0x7fff5fbff8c`相同时，执行表达式`*pc`时也会反映`c`的值变化 输出 11。
+*   由于地址指针`pc`保持与`c` - `0x7fff5fbff8c`相同，执行表达式`*pc`时也会反映`c`的值变化，输出`c = 11;`。
 *   当`*pc = 2;`时，它将更改`pc` - `0x7fff5fbff8c`存储的地址的内容。 这从 11 更改为 2。因此，当我们打印`c`的值时，该值也为 2。
 
 ## 使用指针时的常见错误

docs/cpp/49.md

@@ -155,7 +155,7 @@ Sum: 13
 
 在此程序中，类`A`和`B`已将`add()`声明为友元函数。 因此，该功能可以访问两个类的私有数据。
 
-在这里，`add()`函数将两个对象`objectA`和`objectB`的私有数据`numA`和`numB`相加，并将其返回到主对象 功能。
+在这里，`add()`函数将两个对象`objectA`和`objectB`的私有数据`numA`和`numB`相加，并将对象返回到`main`函数。
 
 为了使该程序正常工作，应如上例所示对类类`B`进行前向声明。
 

docs/csharp/21.md

@@ -106,7 +106,7 @@ namespace HeightWeightInfo
 
 ### 示例 2：
 
-让我们以在`file1.cs`中定义的局部类`Car`为例，该类具有三种方法`InitializeCar`（），`BuildRim`（）和`BuildWheels`（）。 在这些方法中，将`InitializeCar`定义为`partial`。
+让我们以在`file1.cs`中定义的局部类`Car`为例，该类具有三种方法`InitializeCar()`，`BuildRim()`和`BuildWheels()`。 在这些方法中，将`InitializeCar`定义为`partial`。
 
 ```cs
 public partial class Car

docs/dsal/20.md

@@ -53,9 +53,9 @@ Heapify(array, size, i)
   leftChild = 2i + 1
   rightChild = 2i + 2
 
-  if leftChild > array[largest]
+  if leftChild > array[largest]
     set leftChildIndex as largest
-  if rightChild > array[largest]
+  if rightChild > array[largest]
     set rightChildIndex as largest
 
   swap array[i] and array[largest]

docs/dsal/34.md

@@ -63,11 +63,11 @@ B-tree
 
     
 
-2.  在根目录中找不到`k`，因此，请将其与根键进行比较。 在根节点 上找不到
+2.  在根目录中找不到`k`，因此，请将其与根键进行比较。 
 
     ![Not found on the root node](img/1a4d8cbc29ae6d3f24554bb32e0c5345.png "Not found on the root node")
 
-    k
+    在根节点上找不到`k`
 
     
 

docs/dsal/36.md

@@ -56,7 +56,7 @@ B 树中的删除操作主要有三种情况。
 
     
 
-    如果两个直接同级节点都已经具有最小数量的键，则将该节点与左同级节点或右同级节点合并 节点。 **此合并是通过父节点完成的。**
+    如果两个直接同级节点都已经具有最小数量的键，则将该节点与左同级节点或右同级节点合并。 **此合并是通过父节点完成的。**
 
     在上述情况下，删除 30 个结果。
 

docs/dsal/37.md

@@ -70,10 +70,12 @@ B+ tree
 
 
 
-1.  将`k`与根节点进行比较。 在根 的根下找不到
+1.  将`k`与根节点进行比较。 
 
     ![B+ tree search](img/dad6db2e9d0cd91143a972a50b186d19.png "B+ tree search")
 
+    在根下找不到
+
     
 
 2.  由于`k > 25`，请找到合适的子级。

docs/dsal/53.md

@@ -44,7 +44,7 @@
 
     ![Bubble Sort steps](img/fc6ae38469effa7d7e0de368c04b278a.png "Bubble Sort step 3")
 
-    比较相邻的元素 元素
+    比较相邻的元素
 
     
 

docs/dsal/75.md

@@ -6,7 +6,7 @@
 
 最长公共子序列（LCS）定义为所有给定序列共有的最长子序列，条件是该子序列的元素不需要占据原始序列内的连续位置。
 
-如果`S1`和`S2`是两个给定的序列，则`Z`是`S1`和`S2`的共同子序列 如果`Z`是`S1`和`S2`的子序列。 此外，`Z`必须是`S1`和`S2`的索引的**严格增加的序列**。
+如果`S1`和`S2`是两个给定的序列，`Z`是`S1`和`S2`的子序列，则`Z`是`S1`和`S2`的共同子序列。 此外，`Z`必须是`S1`和`S2`的索引的**严格增加的序列**。
 
 在严格增加的序列中，从原始序列中选择的元素的索引必须在`Z`中按升序排列。
 
@@ -89,7 +89,7 @@ Second Sequence
 
     
 
-7.  为了找到最长的公共子序列，请从最后一个元素开始并遵循箭头的方向。 与（）符号相对应的元素形成最长的公共子序列。
+7.  为了找到最长的公共子序列，请从最后一个元素开始并遵循箭头的方向。 与`()`符号相对应的元素形成最长的公共子序列。
 
     ![Longest Common Subsequence create a path](img/829bcd93831c05bb3dfe0ab57b4d18e9.png "create a path according to the arrows")
 

docs/java/150.md

@@ -36,7 +36,7 @@ public class Factorial {
 Factorial of 10 = 3628800
 ```
 
-在此程序中，我们使用循环来循环遍历 1 至给定数字`num`（10）之间的所有数字，并将每个数字的乘积直到`num`存储在 变量`factorial`。
+在此程序中，我们使用循环来循环遍历 1 至给定数字`num`（10）之间的所有数字，并将每个数字的乘积存储在变量`factorial`，直到`i <= num`。
 
 我们使用了`long`而不是`int`来存储较大的阶乘结果。 但是，它仍然不足以存储较大数字（例如 100）的值。
 

docs/java/24.md

@@ -96,7 +96,7 @@ modifier static returnType nameOfMethod (parameters) {
     例如，标准[`Math`类](https://docs.oracle.com/javase/8/docs/api/java/lang/Math.html "Math class")的`sqrt()`方法是静态的。 因此，我们可以直接调用`Math.sqrt()`，而无需创建`Math`类的实例。
 *   `returnType` - 它指定方法返回的值的类型。例如，如果某个方法具有`int`返回类型，则它返回一个整数值。
 
-    一种方法可以返回本机​​数据类型（`int`，`float`，`double`等），本机对象（`String`，`Map`，`List`等）或任何其他 内置和用户定义的对象。
+    一种方法可以返回本机​​数据类型（`int`，`float`，`double`等），本机对象（`String`，`Map`，`List`等）或任何其他内置和用户定义的对象。
 
     如果该方法未返回值，则其返回类型为`void`。
 *   `nameOfMethod` - 它是[标识符](/java-programming/keywords-identifiers#identifiers "Java Identifier")，用于引用程序中的特定方法。

docs/java/31.md

@@ -118,7 +118,7 @@ Is a1 an instance of the Object class: true
 Is c1 an instance of the Object class: true
 ```
 
-在上述示例中，我们创建了`Animal`，`Dog`类的`a1`，`d1`和`c1`对象 和`Cat`。 我们已经使用`instanceof`运算符来检查这些对象`a1`，`d1`和`c1`是否也是`Object`类的对象 。 全部输出结果为`true`。
+在上述示例中，我们创建了`Animal a1`，`Dog`类的`d1`和`Cat c1`。 我们已经使用`instanceof`运算符来检查这些对象`a1`，`d1`和`c1`是否也是`Object`类的对象 。 全部输出结果为`true`。
 
 这是因为`Object`类是`java.lang`包中定义的根类。 所有其他类都是`Object`类的子类，在 Java 中形成层次结构。
 

docs/kotlin/26.md

@@ -206,7 +206,7 @@ val t1 = MathTeacher(25, "Jack")
 
 ## 覆盖成员的函数和属性
 
-如果基类和派生类包含名称相同的成员函数（或属性），则可能需要使用`override`关键字覆盖派生类的成员函数，并使用`open`关键字作为 基类。
+如果基类和派生类包含名称相同的成员函数（或属性），则可能需要使用`override`关键字覆盖派生类的成员函数，并对基类使用`open`关键字。
 
 * * *
 

docs/py/33.md

@@ -16,7 +16,7 @@ Python 字典是无序的项目集合。 字典的每个项目都有一个键值
 
 项具有`key`和表示为一对的相应`value`（**键值**）。
 
-虽然值可以是任何数据类型并且可以重复，但是键必须是不可变类型（[字符串](/python-programming/string)，[数字](/python-programming/numbers)或[元组](/python-programming/tuple)具有不可变元素）并且必须是 独特。
+虽然值可以是任何数据类型并且可以重复，但是键必须是不可变类型（[字符串](/python-programming/string)，[数字](/python-programming/numbers)或[元组](/python-programming/tuple)具有不可变元素）并且必须是唯一的。
 
 ```py
 # empty dictionary

docs/py/45.md

@@ -87,7 +87,7 @@ print(p1)
 (2, 3)
 ```
 
-这样更好 事实证明，当我们使用内置函数`str()`或`format()`时，将调用相同的方法。
+这样更好，事实证明，当我们使用内置函数`str()`或`format()`时，将调用相同的方法。
 
 ```py
 >>> str(p1)

docs/py/93.md

@@ -51,7 +51,7 @@ The HCF. is 6
 
 在每次迭代中，我们检查我们的数字是否完美地划分了两个输入数字。 如果是这样，我们将数字存储为 HCF。 循环结束时，我们得到最大的数字，该数字完美地将两个数字相除。
 
-上述方法易于理解和实现，但是效率不高。 查找 HCF 的更有效方法 是欧几里得算法。
+上述方法易于理解和实现，但是效率不高。 查找 HCF 的更有效方法是欧几里得算法。
 
 ## 欧几里得算法
 

docs/swift/10.md

@@ -91,7 +91,7 @@ So you can calculate using in built data types for more accurate value
 
     ```
 
-    上面的写注释方法是正确的，但不建议这样做，因为如果注释大于 一条线。 更好的书写方式是将多行注释用作：
+    上面的写注释方法是正确的，但不建议这样做，因为如果注释大于一行，更好的书写方式是使用多行注释，如下：
 
     ```swift
     /* This is a comment.

docs/swift/13.md

@@ -134,7 +134,7 @@ print(x)
 200
 ```
 
-在上面的程序中，表达式是从左到右计算的，因为运算符属于乘法优先级组，并且具有左关联性。 因此，除法运算较早进行，您会得到结果 **200** 。 如果要先执行乘法怎么办？ 您需要将`2 * 10`表达式包装为（）大括号，如下所示：
+在上面的程序中，表达式是从左到右计算的，因为运算符属于乘法优先级组，并且具有左关联性。 因此，除法运算较早进行，您会得到结果 **200** 。 如果要先执行乘法怎么办？ 您需要将`2 * 10`表达式包装在`()`括号中，如下所示：
 
 ```swift
 let x =  40  / (2 * 10)

docs/swift/15.md

@@ -127,7 +127,7 @@ print(0b11111110)
 
 它由`&`表示，可以应用于两个操作数。 与运算符比较两个位，如果两个位均为 1，则返回 1，否则返回 0。
 
-如果`x`和`y`是变量/常数，且保持二进制值（即 0 或 1），则`x`和`y`的按位与运算可以 如下表所示：
+如果`x`和`y`是变量/常数，且保持二进制值（即 0 或 1），则`x`和`y`的按位与运算如下表所示：
 
 AND
 
@@ -169,7 +169,7 @@ Binary: 10000011
 
 它表示为`|`，可以应用于两个操作数。 如果按位或运算符的一个或多个输入为 1，则将两个位进行比较，并生成结果 1；否则为 0。
 
-如果`x`和`y`是变量/常数，且保持二进制值，即 0 或 1。则`x`和`y`的按位或运算可以 如下表所示：
+如果`x`和`y`是变量/常数，且保持二进制值，即 0 或 1。则`x`和`y`的按位或运算如下表所示：
 
 OR
 
@@ -209,7 +209,7 @@ Binary: 11111111
 
 它表示为`^`，可以应用于两个操作数。 如果异或运算符的输入之一恰好是 1，则异或运算符将比较两个位并生成结果 1，否则返回 0。
 
-如果`x`和`y`是变量/常数，且保持二进制值，即 0 或 1。则`x`和`y`的按位异或运算可以 如下表所示：
+如果`x`和`y`是变量/常数，且保持二进制值，即 0 或 1。则`x`和`y`的按位异或运算如下表所示：
 
 XOR
 

docs/swift/19.md

@@ -28,7 +28,7 @@ print("Hello, World!")
 print("Hello, World!")
 ```
 
-嗯 完成五次相似的代码来完成相同的工作看起来很耗时。 如果是这样，如果有人要求您编写一个在屏幕上输出数百甚至上百万次`"Hello, World!"`的程序，您将怎么办？ 
+嗯，完成五次相似的代码来完成相同的工作看起来很耗时。 如果是这样，如果有人要求您编写一个在屏幕上输出数百甚至上百万次`"Hello, World!"`的程序，您将怎么办？ 
 
 一种幼稚的解决方案是将`print`语句写入给定的次数。 听起来很疯狂吧？ 但是，使用`for-in`循环和以下几行代码可以找到更好的解决方案：
 

docs/swift/24.md

@@ -109,7 +109,7 @@ Hello after function call
 
 ## 示例 4：带有可选项的`guard`
 
-我们已经在[Swift `Optional`](/swift-programming/optionals "Swift Optionals")中看到了`if-let`的使用，以展开可选项。 但是，我们也可以使用`guard`语句 代替`if-let`来展开具有一个优点的可选项。 展开带`guard`的可选项而不是`if-let`的主要优点是，我们可以扩大展开的变量的范围。
+我们已经在[Swift `Optional`](/swift-programming/optionals "Swift Optionals")中看到了`if-let`的使用，以展开可选项。 但是，我们也可以使用`guard`语句代替`if-let`，来展开具有一个优点的可选项。 展开带`guard`的可选项而不是`if-let`的主要优点是，我们可以扩大展开的变量的范围。
 
 让我们在下面的示例中看到这一点：
 
@@ -133,7 +133,7 @@ changeOptionalStringToUpperCase()
 Name is nil. Cannot process
 ```
 
-在上述程序中，您可以看到在`guard`语句 定义的范围之外使用了未包装的值`temp`。 由于`name`被定义为可选并且包含`nil`值，因此`guard`语句无法解包该值。
+在上述程序中，您可以看到，在`guard`语句定义的范围之外使用了未包装的值`temp`。 由于`name`被定义为可选并且包含`nil`值，因此`guard`语句无法解包该值。
 
 因此，将执行后卫内部的语句，该语句打印`Name is nil. Cannot process`，并使用`return`语句终止函数。 上述`guard`语句`if-else`语句的等效代码是：
 

docs/swift/3.md

@@ -62,7 +62,7 @@ Hello, World!
 
 ## 要记住的事情
 
-1.  如果您熟悉 C，C++ ，Java 等其他编程语言，则需要在每个语句的末尾添加**分号（`;`）**。 但是，添加分号`";"`是可选的 在 Swift 语句的末尾。 也不建议这样做。
+1.  如果您熟悉 C，C++ ，Java 等其他编程语言，则需要在每个语句的末尾添加**分号（`;`）**。 但是，在 Swift 语句的末尾添加分号`";"`是可选的。 也不建议这样做。
 
     如果需要在一行中添加多个语句，则必须包括`";"`。 在声明的末尾。
 

docs/swift/30.md

@@ -80,7 +80,7 @@ func function_name(args...) -> ReturnType {
 
 ![How function works in Swift?](img/3a063dc181815fe61258a3e3a2487e2d.png "How function works in Swift?")
 
-在上图中，语句`function_name(args)`调用/调用带有参数值`args`的函数，然后该函数离开代码的当前部分（即停止执行其下面的语句）并开始执行内部的第一行 函数。
+在上图中，语句`function_name(args)`调用/调用带有参数值`args`的函数，然后该函数离开代码的当前部分（即停止执行其下面的语句）并开始执行函数内部的第一行。
 
 1.  程序进入代码`func function_name(Args...)`的行，并接受在函数调用`function_name(args)`期间传递的值`args`。
 2.  然后程序执行函数内部定义的语句`statementsInsideFunction`。

docs/swift/37.md

@@ -394,7 +394,7 @@ closure called
 
 在上面的示例中，我们声明了一个变量`ClosureArr`，它可以存储类型为`()->()`的闭包数组。
 
-现在，如果将在函数范围内定义的闭包`myClosure`附加到在函数外部定义的`ClosureArr`，则闭包`myClosure`需要逸出主体 功能的
+现在，如果将在函数范围内定义的闭包`myClosure`附加到在函数外部定义的`ClosureArr`，则闭包`myClosure`需要逸出函数主体。
 
 因此，闭包需要逃逸并标记为`@escaping`关键字。