2020-07-06 17:52:56

docs/dsal/21.md

@@ -8,7 +8,7 @@
 
 与二进制堆不同，一个节点可以有两个以上的子节点。
 
-斐波那契堆称为**斐波那契**堆，因为树的构建方式使得 n 阶树中至少有`F` `n+2`个节点，其中`F` `n+2`为`(n + 2)nd`斐波那契数。
+斐波那契堆称为**斐波那契**堆，因为树的构建方式使得 n 阶树中至少有`F n+2`个节点，其中`F n+2`为`(n + 2)nd`斐波那契数。
 
 ![Fibonacci Heap](img/43ea767d63a5e6b25af45fb938afcf36.png "Fibonacci Heap")
 

docs/dsal/22.md

@@ -17,7 +17,7 @@
 ### 降低键
 
 1.  选择要减少的节点`x`，并将其值更改为新值`k`。
-2.  如果`x`的父级`y`不为空，并且父级的密钥大于`k`的密钥，则调用`C` `ut(x)`和`C` `ascading-` `C` `ut(y)`随后。
+2.  如果`x`的父级`y`不为空，并且父级的密钥大于`k`的密钥，则调用`C ut(x)`和`C ascading- C ut(y)`随后。
 3.  如果`x`的密钥小于`min`的密钥，则将`x`标记为 min。
 
 ### 切

docs/dsal/31.md

@@ -21,7 +21,7 @@ A tree having a right subtree with one value smaller than the root is shown to d
 
 
 
-右边的二叉树不是二叉搜索树，因为节点“ 3”的右子树包含的值小于它。
+右边的二叉树不是二叉搜索树，因为节点“3”的右子树包含的值小于它。
 
 您可以对二进制搜索树执行两个基本操作：
 
@@ -74,7 +74,7 @@ If number > root->data
 
 如果找到该值，则返回该值，以便在每个递归步骤中将其传播，如下图所示。
 
-如果您可能已经注意到，我们已经四次调用 return search（struct node *）。 当我们返回新节点或 NULL 时，该值会一次又一次返回，直到 search（root）返回最终结果。
+如果您可能已经注意到，我们已经四次调用`return search(struct node *)`。 当我们返回新节点或`NULL`时，该值会一次又一次返回，直到`search(root)`返回最终结果。
 
 ![if the value is found in any of the subtrees, it is propagated up so that in the end it is returned, otherwise null is returned](img/6b854cf280b11a6cab8c1ac2e97186ec.png "Search operation in BST")
 
@@ -82,7 +82,7 @@ If the value is found in any of the subtrees, it is propagated up so that in the
 
 
 
-如果找不到该值，则最终到达叶节点的左或右子节点，该子节点为 NULL，并传播并返回。
+如果找不到该值，则最终到达叶节点的左或右子节点，该子节点为`NULL`，并传播并返回。
 
 * * *
 
@@ -90,7 +90,7 @@ If the value is found in any of the subtrees, it is propagated up so that in the
 
 在正确的位置插入值类似于搜索，因为我们尝试维护以下规则：左子树小于根，右子树大于根。
 
-我们继续根据值去右子树或左子树，当我们到达左或右子树为 null 的点时，将新节点放在那里。
+我们继续根据值去右子树或左子树，当我们到达左或右子树为`null`的点时，将新节点放在那里。
 
 **Algorithm:**
 
@@ -676,15 +676,15 @@ int main() {
 ### 时间复杂度
 
 | **操作** | **最佳案例复杂度** | **平均案件复杂度** | **最坏情况的复杂性** |
-| 搜索 | O（log n） | O(log n) | 上） |
-| 插入 | O(log n) | O(log n) | O(n) |
-| 删除中 | O(log n) | O(log n) | O(n) |
+| 搜索 | `O(log n)` | `O(log n)` | `O(n)` |
+| 插入 | `O(log n)` | `O(log n)` | `O(n)` |
+| 删除中 | `O(log n)` | `O(log n)` | `O(n)` |
 
 这里，`n`是树中的节点数。
 
 ### 空间复杂度
 
-所有操作的空间复杂度为`O（n）`。
+所有操作的空间复杂度为`O(n)`。
 
 * * *
 

docs/dsal/32.md

@@ -4,7 +4,7 @@
 
 #### 在本教程中，您将学习什么是 avl 树。 此外，您还将找到在 C，C++ ，Java 和 Python 的 avl 树上执行的各种操作的工作示例。
 
-AVL 树是一种自平衡二进制搜索树，其中每个节点都维护额外的信息，称为平衡因子，其值为-1、0 或+1。
+AVL 树是一种自平衡二进制搜索树，其中每个节点都维护额外的信息，称为平衡因子，其值为 -1、0 或 +1。
 
 AVL 树以其发明者 Georgy Adelson-Velsky 和 Landis 得名。
 
@@ -16,7 +16,7 @@ AVL 树中节点的平衡因子是该节点的左子树的高度和右子树的
 
 平衡因子=（左子树的高度-右子树的高度）或（右子树的高度-左子树的高度）
 
-Avl 树的自平衡属性由平衡因子保持。 平衡因子的值应始终为-1、0 或+1。
+Avl 树的自平衡属性由平衡因子保持。 平衡因子的值应始终为 -1、0 或 +1。
 
 平衡 avl 树的示例是：
 
@@ -58,7 +58,7 @@ Avl tree
 
     ![left-rotate](img/5b1e886c5d14719759eb1f481667d2ee.png "assign x as the parent of the left subtree of y")
 
-    将 x 分配为 y 的左子树的父级
+    将`x`分配为`y`的左子树的父级
 
     
 
@@ -68,7 +68,7 @@ Avl tree
 
     ![left-rotate](img/f6e31448c109d30b7d6e3618320db475.png "change the parent of x to that of y")
 
-    将 x 的父级更改为 y 的父级
+    将`x`的父级更改为`y`的父级
 
     
 
@@ -76,7 +76,7 @@ Avl tree
 
     ![left-rotate](img/83ea826e7239488e34587382477bdec1.png "Assign y as the parent of x.")
 
-    将 y 指定为 x 的父代。
+    将`y`指定为`x`的父代。
 
     
 
@@ -94,11 +94,11 @@ Avl tree
 
     
 
-2.  如果`x`具有右子树，则将 y 分配为`x`的右子树的父树。
+2.  如果`x`具有右子树，则将`y`分配为`x`的右子树的父树。
 
     ![right-rotate](img/06495b74d0fea430156a4de0972c18d2.png "assign y as the parent of the right subtree of x.")
 
-    将 y 分配为 x
+    将`y`分配为`x`
 
     
 
@@ -109,7 +109,7 @@ Avl tree
 
     ![right-rotate](img/ca09dbccdc5921e82f659a1a0e8c9b91.png "Assign the parent of y as the parent of x.")
 
-    将 y 的父级指定为 x 的父级。
+    将`y`的父级指定为`x`的父级。
 
     
 
@@ -117,7 +117,7 @@ Avl tree
 
     ![right-rotate](img/8b0933681c1070e1b4fad4ade6edcd34.png "assign x as the parent of y")
 
-    将 x 分配为 y 的父项
+    将`x`分配为`y`的父项
 
     
 
@@ -127,43 +127,43 @@ Avl tree
 
 在左右旋转时，首先将布置向左移动，然后向右移动。
 
-1.  在 x-y 上向左旋转。
+1.  在`x-y`上向左旋转。
 
     ![left-right rotate](img/18f5da24f3ebcbe6fd924d352740bb0f.png "left rotate x-y")
 
-    向左旋转 x-y
+    向左旋转`x-y`
 
     
 
-2.  在 y-z 上右旋转。
+2.  在`y-z`上右旋转。
 
     ![left-right rotate](img/673135c0cd0b054d0b7f6b5514e376d2.png "right rotate z-y")
 
-    向右旋转 z-y
+    向右旋转`z-y`
 
     
 
 在左右旋转时，这些布置首先向右移动，然后向左移动。
 
-1.  在 x-y 上右旋转。
+1.  在`x-y`上右旋转。
 
     ![right-left rotate](img/0d086122b84eb5b2b7ba38e00a73a864.png "right rotate x-y")
 
-    右旋转 x-y
+    右旋转`x-y`
 
     
 
-2.  在 z-y 上向左旋转。
+2.  在`z-y`上向左旋转。
 
     ![right-left rotate](img/14b47284fd526dee8c81e406e518a9d7.png "left rotate z-y")
 
-    向左旋转 z-y
+    向左旋转`z-y`
 
     
 
 * * *
 
-## 插入 newNode 的算法
+## 插入`newNode`的算法
 
 `newNode`始终作为平衡因子等于 0 的叶节点插入。
 
@@ -184,19 +184,19 @@ Avl tree
     
 
 2.  使用以下递归步骤转到相应的叶节点以插入`newNode`。 比较`newKey`与当前树的`rootKey`。
-    1.  如果`newKey` < `rootKey`，则在当前节点的左子树上调用插入算法，直到到达叶节点为止。
-    2.  否则，如果`newKey` > `rootKey`，则在当前节点的右子树上调用插入算法，直到到达叶节点为止。
+    1.  如果`newKey < rootKey`，则在当前节点的左子树上调用插入算法，直到到达叶节点为止。
+    2.  否则，如果`newKey > rootKey`，则在当前节点的右子树上调用插入算法，直到到达叶节点为止。
     3.  否则，返回`leafNode`。
 
         ![avl tree insertion](img/df0a4dd6fab731c162416335cf637093.png "finding the location to insert newNode")
 
-        查找插入 newNode 的位置
+        查找插入`newNode`的位置
 
         
 
 3.  将通过上述步骤获得的`leafKey`与`newKey`进行比较：
-    1.  如果`newKey` < `leafKey`，则将 newNode 设为`leafNode`的`leftChild`。
-    2.  否则，将`newNode`设为`leafNode`的 rightChild。
+    1.  如果`newKey < leafKey`，则将`newNode`设为`leafNode`的`leftChild`。
+    2.  否则，将`newNode`设为`leafNode`的`rightChild`。
 
         ![avl tree insertion](img/ff0d7ec5a7fea8ddf2a7249b0f504589.png "inserting the new node")
 
@@ -213,8 +213,8 @@ Avl tree
     
 
 5.  如果节点不平衡，请重新平衡该节点。
-    1.  如果`balanceFactor` >为 1，则表示左侧子树的高度大于右侧子树的高度。 因此，请向右旋转或向左旋转
-        1.  如果`newNodeKey` < `leftChildKey`进行右旋转。
+    1.  如果`balanceFactor > 1`，则表示左侧子树的高度大于右侧子树的高度。 因此，请向右旋转或向左旋转
+        1.  如果`newNodeKey < leftChildKey`进行右旋转。
         2.  否则，请左右旋转。
 
             ![insertion in avl tree](img/1cd142d5388320a5fd7322aa51d87301.png "balancing the tree with rotation")
@@ -229,8 +229,8 @@ Avl tree
 
             
 
-    2.  如果`balanceFactor` < -1，则意味着右子树的高度大于左子树的高度。 因此，请向右旋转或向左旋转
-        1.  如果`newNodeKey` > `rightChildKey`进行左旋转。
+    2.  如果`balanceFactor < -1`，则意味着右子树的高度大于左子树的高度。 因此，请向右旋转或向左旋转
+        1.  如果`newNodeKey > rightChildKey`进行左旋转。
         2.  否则，请左右旋转
 6.  最终的树是：
 
@@ -285,13 +285,13 @@ Avl tree
 
     ![update bf](img/f9ebf1bcaf5aa92d415fa87baa97cc3a.png "update bf")
 
-    更新 bf
+    更新`bf`
 
     
 
-4.  如果任何节点的平衡因子不等于-1、0 或 1，则重新平衡树。
-    1.  如果`currentNode` >的`balanceFactor`，
-        1.  如果`的`balanceFactor` leftChild` > = 0，请向右旋转。
+4.  如果任何节点的平衡因子不等于 -1、0 或 1，则重新平衡树。
+    1.  如果`currentNode > balanceFactor`，
+        1.  如果`leftChild`的`balanceFactor >= 0`，请向右旋转。
 
             ![right-rotate](img/4233e9dad28df24df3b06f28a4ced8cd.png "right-rotate for balancing the tree")
 
@@ -300,8 +300,8 @@ Avl tree
             
 
         2.  否则做左右旋转。
-    2.  如果`currentNode` <的`balanceFactor` -1，
-        1.  如果`rightChild` <的`balanceFactor` = 0，请向左旋转。
+    2.  如果`currentNode`的`balanceFactor < -1`，
+        1.  如果`rightChild`的`balanceFactor = 0`，请向左旋转。
         2.  否则做左右旋转。
 5.  最终的树是：
 
@@ -1080,7 +1080,7 @@ int main() {
 ## AVL 树上不同操作的复杂性
 
 | **插入** | **删除** | **搜索** |
-| O（log n） | O(log n) | O(log n) |
+| `O(log n)` | `O(log n)` | `O(log n)` |
 
 * * *
 

docs/dsal/34.md

@@ -29,12 +29,12 @@ B-tree
 ## B 树属性
 
 1.  对于每个节点`x`，密钥以升序存储。
-2.  在每个节点中，都有一个布尔值`x.leaf`，如果`x`是叶，则为 true。
+2.  在每个节点中，都有一个布尔值`x.leaf`，如果`x`是叶，则为`true`。
 3.  如果`n`是树的顺序，则每个内部节点最多可以包含`n-1`键以及指向每个子节点的指针。
-4.  除根节点外，每个节点最多可以有 n 个子节点，并且至少`n / 2`个子节点。
-5.  所有叶子具有相同的深度（即树的高度-h）。
+4.  除根节点外，每个节点最多可以有`n`个子节点，并且至少`n / 2`个子节点。
+5.  所有叶子具有相同的深度（即树的高度`h`）。
 6.  根至少有 2 个子节点，并且至少包含 1 个密钥。
-7.  如果`n≥1`，则对于任何高度为 h 且最小度为`t ≥ 2`的 n 键 B 树，`h ≥ log<sub>t</sub> (n+1)/2`。
+7.  如果`n≥1`，则对于任何高度为`h`且最小度为`t ≥ 2`的`n`键 B 树，`h ≥ log_t(n+1)/2`。
 
 * * *
 
@@ -44,12 +44,12 @@ B-tree
 
 在 B 树中搜索元素是在二叉搜索树中搜索元素的一般形式。 遵循以下步骤。
 
-1.  从根节点开始，将 k 与节点的第一个键进行比较。
+1.  从根节点开始，将`k`与节点的第一个键进行比较。
     如果为`k = the first key of the node`，则返回节点和索引。
 2.  如果为`k.leaf = true`，则返回`NULL`（即未找到）。
 3.  如果`k < the first key of the root node`，则递归搜索此键的左子级。
-4.  如果当前节点和`k > the first key`中有多个密钥，请将 k 与该节点中的下一个密钥进行比较。
-    如果为`k < next key`，则搜索该键的左子键（即 k 位于第一键和第二键之间）。
+4.  如果当前节点和`k > the first key`中有多个密钥，请将`k`与该节点中的下一个密钥进行比较。
+    如果为`k < next key`，则搜索该键的左子键（即`k`位于第一键和第二键之间）。
     否则，搜索密钥的右子级。
 5.  重复步骤 1 到 4，直到到达叶子。
 
@@ -79,7 +79,7 @@ B-tree
 
     
 
-4.  比较 k 与 16。由于`k > 16`，将 k 与下一个键 18 比较。
+4.  比较`k`与 16。由于`k > 16`，将 k 与下一个键 18 比较。
 
     ![Compare with the keys from left to right](img/95f1a664be4ae2332268bfc11227be82.png "Compare with the keys from left to right")
 
@@ -91,15 +91,15 @@ B-tree
 
     ![k lies in between 16 and 18](img/c57b75bb010a123fb128f8f742a74f60.png "k lies in between 16 and 18")
 
-    k 在 16 到 18 之间
+    `k`在 16 到 18 之间
 
     
 
-6.  找到了 k。 找到
+6.  找到了`k`。
 
     ![k is found](img/86dba3b98de675663a1c6323d168a854.png "k is found")
 
-    k
+    找到了`k`
 
     
 

docs/dsal/35.md

@@ -2,7 +2,7 @@
 
 > 原文： [https://www.programiz.com/dsa/insertion-into-a-b-tree](https://www.programiz.com/dsa/insertion-into-a-b-tree)
 
-#### 在本教程中，您将学习如何将密钥插入 btree。 此外，您还将找到在 C，C++ ，Java 和 Python 中将键插入 B 树的工作示例。
+#### 在本教程中，您将学习如何将密钥插入 B 树。 此外，您还将找到在 C，C++ ，Java 和 Python 中将键插入 B 树的工作示例。
 
 在 B 树上插入元素包括两个事件：**搜索适当的节点**以插入元素，以及**拆分节点**。如有必要，插入操作始终从下往上进行 方法。
 

docs/dsal/36.md

@@ -19,9 +19,9 @@
 
 ## 删除操作
 
-在执行以下步骤之前，必须了解有关度为 **m** 的 B 树的这些事实。
+在执行以下步骤之前，必须了解有关度为`m`的 B 树的这些事实。
 
-1.  一个节点最多可以有 m 个子节点。 （即 3）
+1.  一个节点最多可以有`m`个子节点。 （即 3）
 2.  一个节点最多可以包含`m - 1`个键。 （即 2）
 3.  一个节点至少应具有`⌈m/2⌉`个子节点。 （即 2）
 4.  一个节点（根节点除外）应至少包含`⌈m/2⌉ - 1`键。 （即 1）

docs/dsal/37.md

-# B +树
+# B+ 树
 
 > 原文： [https://www.programiz.com/dsa/b-plus-tree](https://www.programiz.com/dsa/b-plus-tree)
 
-#### 在本教程中，您将学习什么是 B +树。 此外，您还将找到在 C，C++ ，Java 和 Python 中对 B +树进行搜索操作的工作示例。
+#### 在本教程中，您将学习什么是 B+ 树。 此外，您还将找到在 C，C++ ，Java 和 Python 中对 B+ 树进行搜索操作的工作示例。
 
-B +树是自平衡树的高级形式，其中所有值都存在于叶级别中。
+B+ 树是自平衡树的高级形式，其中所有值都存在于叶级别中。
 
-学习 B +树之前要理解的重要概念是多级索引。 在多级索引中，索引索引如下图所示创建。 它使访问数据更容易，更快捷。
+学习 B+ 树之前要理解的重要概念是多级索引。 在多级索引中，索引索引如下图所示创建。 它使访问数据更容易，更快捷。
 
 ![Multilevel Indexing using B+ tree](img/cc386364962fa9b7440f95d826d6f439.png "Multilevel Indexing")
 
@@ -16,16 +16,16 @@ Multilevel Indexing using B+ tree
 
 * * *
 
-## B +树的属性
+## B+ 树的属性
 
 1.  所有叶子处于同一水平。
 2.  根至少有两个孩子。
-3.  除根节点外，每个节点最多可以包含`m 个`子级，并且至少具有`m` `/ 2`个子级。
-4.  每个节点最多可以包含`m` `-1`键，以及最小`⌈m/2⌉` `-1`键。
+3.  除根节点外，每个节点最多可以包含`m 个`子级，并且至少具有`m / 2`个子级。
+4.  每个节点最多可以包含`m -1`键，以及最小`⌈m/2⌉ -1`键。
 
 * * *
 
-## B 树和 B +树之间的比较
+## B 树和 B+ 树之间的比较
 
 ![B-tree](img/94253a9c38dc64e346782bfb60590260.png "B-tree")
 
@@ -39,30 +39,30 @@ B+ tree
 
 
 
-数据指针仅出现在 B +树的叶子节点上，而数据指针则出现在 B 树的内部，叶子或根节点上。
+数据指针仅出现在 B+ 树的叶子节点上，而数据指针则出现在 B 树的内部，叶子或根节点上。
 
-叶子在 B 树上不相互连接，而在 B +树上连接。
+叶子在 B 树上不相互连接，而在 B+ 树上连接。
 
-B +树上的操作比 B 树上的操作快。
+B+ 树上的操作比 B 树上的操作快。
 
 * * *
 
-## 在 B +树上搜索
+## 在 B+ 树上搜索
 
-遵循以下步骤以在顺序为`m`的 B +树中搜索数据。 令要搜索的数据为`k`。
+遵循以下步骤以在顺序为`m`的 B+ 树中搜索数据。 令要搜索的数据为`k`。
 
-1.  从根节点开始。 比较 k 与根节点`[k` `1` `，k` `2` `，k` `上的键 3` `，... k` `m-1` `]`。
-2.  如果`k < k` `1`，请转到根节点的左子节点。
-3.  否则，如果`k == k` `1`，则比较`k` `2`。 如果`k < k` `2`，则 k 位于`k` `1`和`k` `2`之间。 因此，搜索`k` `2`的左子级。
-4.  如果`k > k` `2`，则按照步骤 2 和步骤 6 中的`k3，k4，... k` `m-1`进行操作。 3。
+1.  从根节点开始。 比较 k 与根节点`[k 1 ，k 2 ，k 上的键 3 ，... k m-1 ]`。
+2.  如果`k < k 1`，请转到根节点的左子节点。
+3.  否则，如果`k == k 1`，则比较`k 2`。 如果`k < k 2`，则 k 位于`k 1`和`k 2`之间。 因此，搜索`k 2`的左子级。
+4.  如果`k > k 2`，则按照步骤 2 和步骤 6 中的`k3，k4，... k m-1`进行操作。 3。
 5.  重复上述步骤，直到到达叶节点。
 6.  如果 k 在叶节点中存在，则返回 true，否则返回 false。
 
 * * *
 
-## 在 B +树上搜索示例
+## 在 B+ 树上搜索示例
 
-让我们在以下 B +树上搜索`k =` `45`。
+让我们在以下 B+ 树上搜索`k = 45`。
 
 ![B+ tree](img/9f84d03f24ad9797c631eeb0102dbcc6.png "B+ tree")
 
@@ -1870,13 +1870,13 @@ int main() {
 
 ### 时间复杂度
 
-如果在节点内部实施线性搜索，则总复杂度为`Θ（log` `t` `n）`。
+如果在节点内部实施线性搜索，则总复杂度为`Θ（log t n）`。
 
-如果使用二进制搜索，则总复杂度为`Θ（log` `2` `t.log` `t` `n）`。
+如果使用二进制搜索，则总复杂度为`Θ（log 2 t.log t n）`。
 
 * * *
 
-## B +树应用
+## B+ 树应用
 
 *   多级索引
 *   在树上更快的操作（插入，删除，搜索）

docs/dsal/38.md

-# 在 B +树上插入
+# 在 B+ 树上插入
 
 > 原文： [https://www.programiz.com/dsa/insertion-on-a-b-plus-tree](https://www.programiz.com/dsa/insertion-on-a-b-plus-tree)
 
-#### 在本教程中，您将学习有关 B +树上的插入操作的信息。 此外，您还将找到在 C，C++ ，Java 和 Python 中将元素插入 B +树的工作示例。
+#### 在本教程中，您将学习有关 B+ 树上的插入操作的信息。 此外，您还将找到在 C，C++ ，Java 和 Python 中将元素插入 B+ 树的工作示例。
 
-将元素插入 [B +树](https://www.programiz.com/dsa/b%2Btree)包含三个主要事件：**搜索适当的叶子**，**插入**元素以及**平衡/拆分** 树。
+将元素插入 [B+ 树](https://www.programiz.com/dsa/b%2Btree)包含三个主要事件：**搜索适当的叶子**，**插入**元素以及**平衡/拆分** 树。
 
 让我们在下面了解这些事件。
 
@@ -12,7 +12,7 @@
 
 ## 插入操作
 
-在将元素插入 B +树之前，必须牢记这些属性。
+在将元素插入 B+ 树之前，必须牢记这些属性。
 
 *   根至少有两个孩子。
 *   除根节点外，每个节点最多可以有`m 个`子级，并且至少有`m / 2`个子级。

docs/dsal/39.md

-# 从 B +树中删除
+# 从 B+ 树中删除
 
 > 原文： [https://www.programiz.com/dsa/deletion-from-a-b-plus-tree](https://www.programiz.com/dsa/deletion-from-a-b-plus-tree)
 
-#### 在本教程中，您将了解有关 B +树的删除操作。 此外，您还将找到从 C，C++ ，Java 和 Python 中的 B +树中删除元素的工作示例。
+#### 在本教程中，您将了解有关 B+ 树的删除操作。 此外，您还将找到从 C，C++ ，Java 和 Python 中的 B+ 树中删除元素的工作示例。
 
-删除 B +树上的元素包括三个主要事件：**搜索**要删除的密钥所在的节点，删除密钥并根据需要平衡树。 **下溢**是节点中的密钥数量少于其应容纳的最小密钥数量的情况。
+删除 B+ 树上的元素包括三个主要事件：**搜索**要删除的密钥所在的节点，删除密钥并根据需要平衡树。 **下溢**是节点中的密钥数量少于其应容纳的最小密钥数量的情况。
 
 * * *
 
 ## 删除操作
 
-在执行以下步骤之前，必须了解有关度为 **m** 的 B +树的这些事实。
+在执行以下步骤之前，必须了解有关度为 **m** 的 B+ 树的这些事实。
 
 1.  一个节点最多可以有 m 个子节点。 （即 3）
 2.  一个节点最多可以包含`m - 1`个键。 （即 2）
 3.  一个节点至少应具有`⌈m/2⌉`个子节点。 （即 2）
 4.  一个节点（根节点除外）应至少包含`⌈m/2⌉ - 1`键。 （即 1）
 
-删除键时，我们还必须照顾内部节点（即索引）中存在的键，因为这些值在 B +树中是多余的。 搜索要删除的密钥，然后按照以下步骤操作。
+删除键时，我们还必须照顾内部节点（即索引）中存在的键，因为这些值在 B+ 树中是多余的。 搜索要删除的密钥，然后按照以下步骤操作。
 
 ### 案例一
 

docs/dsal/40.md

@@ -217,8 +217,8 @@ Red Black Tree
 
 如果 newNode 的插入违反了此属性，则此算法用于维护红黑树的属性。
 
-1.  进行以下操作，直到`newNode` `p`的父级为 RED。
-2.  如果`p`是`z`的`grandParent` `gP`的左孩子，请执行以下操作。
+1.  进行以下操作，直到`newNode p`的父级为 RED。
+2.  如果`p`是`z`的`grandParent gP`的左孩子，请执行以下操作。
     **案例一：**
     1.  如果`z`的`gP`的右子色为红色，则将`gP`的两个子色分别设置为黑色和`的颜色。 gP`为红色。
     2.  将`gP`分配给`newNode`。

docs/dsal/41.md

@@ -82,8 +82,8 @@
 
 如果插入 newNode 违反了该属性，则此算法用于维护红黑树的属性。
 
-1.  执行以下操作，直到`newNode` `p`的父代变为红色。
-2.  如果`p`是`newNode`的`grandParent` `gP`的左孩子，请执行以下操作。
+1.  执行以下操作，直到`newNode p`的父代变为红色。
+2.  如果`p`是`newNode`的`grandParent gP`的左孩子，请执行以下操作。
     **案例一：**
     1.  如果`newNode`的`gP`的右子级的颜色是红色，则将`gP`的子级的颜色都设置为 BLACK，将`gP`的颜色都设置为 RED。
 

docs/dsal/45.md

@@ -32,7 +32,7 @@ Connected Graph
 
 可以从完整图形创建的具有`n`顶点的生成树总数等于`n<sup>(n-2)</sup>`。
 
-如果我们有`n = 4`，则最大可能的生成树数等于`4<sup>4-2</sup>` `= 16`。 因此，可以从具有 4 个顶点的完整图形中形成 16 个生成树。
+如果我们有`n = 4`，则最大可能的生成树数等于`4<sup>4-2</sup> = 16`。 因此，可以从具有 4 个顶点的完整图形中形成 16 个生成树。
 
 * * *
 

docs/dsal/6.md

@@ -47,9 +47,9 @@ where, T(n) has the following asymptotic bounds:
 
 以上每个条件都可以解释为：
 
-1.  如果在每个级别上解决子问题的成本增加了某个因素，则`f(n)`的值将比`n` `logb a`减小几倍。 因此，时间复杂度受到最后一级的成本的压制。`n` `logb a`
-2.  如果在每个级别上解决子问题的成本几乎相等，则`f(n)`的值将为`n` `logb a`。 因此，时间复杂度将为`f(n)`乘以级别总数，即。`n` `logb a` `* log n`
-3.  如果解决每个级别上的子问题的成本降低了某个因素，则`f(n)`的值将比`n` `logb a`增大几倍。 因此，`f(n)`的成本抑制了时间复杂度。
+1.  如果在每个级别上解决子问题的成本增加了某个因素，则`f(n)`的值将比`n logb a`减小几倍。 因此，时间复杂度受到最后一级的成本的压制。`n logb a`
+2.  如果在每个级别上解决子问题的成本几乎相等，则`f(n)`的值将为`n logb a`。 因此，时间复杂度将为`f(n)`乘以级别总数，即。`n logb a * log n`
+3.  如果解决每个级别上的子问题的成本降低了某个因素，则`f(n)`的值将比`n logb a`增大几倍。 因此，`f(n)`的成本抑制了时间复杂度。
 
 * * *
 

docs/dsal/73.md

@@ -52,7 +52,7 @@ function fib(n)
     else
         var prevFib = 0, currFib = 1
         repeat n − 1 times
-            var newFib = prevFib + currFib
+            var newFib = prevFiB+  currFib
             prevFib = currFib
             currFib  = newFib
     return currentFib

docs/dsal/75.md

@@ -29,7 +29,7 @@ S1 = {B, C, D, A, A, C, D}
 S2 = {A, C, D, B, A, C}
 ```
 
-然后，常见的子序列是`{B, C}, {C, D, A, C}, {D, A, C}, {A, A, C}, {A, C}, {C, D},` `...`
+然后，常见的子序列是`{B, C}, {C, D, A, C}, {D, A, C}, {A, A, C}, {A, C}, {C, D}, ...`
 
 在这些子序列中，`{C, D, A, C}`是最长的公共子序列。 我们将使用动态编程来找到这个最长的公共子序列。