Skip to content

P
programiz-zh

OpenDocCN / programiz-zh
9 个月 前同步成功

通知 0
Star 48
Fork 7
P
programiz-zh

前往新版Gitcode，体验更适合开发者的 AI 搜索 >>

提交 ce398320 编写于 作者: W wizardforcel
浏览文件
操作

2020-07-09 17:27:07

上级 40bd9074
隐藏空白更改
内联 并排
Showing with 84 addition and 84 deletion
docs/dsal/13.md
浏览文件 @ ce398320
......@@ -8,7 +8,7 @@
通常，元素本身的值被认为用于分配优先级。
例如：具有最高值的元素被视为最高优先级元素。 但是，在其他情况下，我们可以将具有最低值的元素视为最高优先级元素。 在其他情况下，我们可以根据需要设置优先级。
例如：具有最高值的元素被视为最高优先级元素。 但是，在其他情况下，我们可以将具有最低值的元素视为最高优先级元素。 在其他情况下，我们可以按需设置优先级。
![The highest priority element dequeued first](img/164bb96650fb4d788e1664cbb10451a2.png "Priority Queue")
......
docs/dsal/31.md
浏览文件 @ ce398320
......@@ -92,7 +92,7 @@ If the value is found in any of the subtrees, it is propagated up so that in the
我们继续根据值去右子树或左子树，当我们到达左或右子树为`null`的点时，将新节点放在那里。
**Algorithm:**
**算法：**
```
If node == NULL
......@@ -146,7 +146,7 @@ Image showing the importance of returning the root element at the end so that th
从二分搜索树中删除节点的情况有三种。
### 案例一
### 情况一
在第一种情况下，要删除的节点是叶节点。 在这种情况下，只需从树中删除该节点即可。
......@@ -162,7 +162,7 @@ Delete the node
### 案例二
### 情况二
在第二种情况下，要删除的节点只有一个子节点。 在这种情况下，请执行以下步骤：
......@@ -187,11 +187,11 @@ Final tree
### 案例三
### 情况三
在第三种情况下，要删除的节点有两个孩子。 在这种情况下，请执行以下步骤：
1. 获取该节点的有序后继者。
1. 获取该节点的有序后继。
2. 将节点替换为有序后继节点。
3. 从原始位置卸下有序后继器。
......@@ -675,7 +675,7 @@ int main() {
### 时间复杂度
| **操作** | **最佳案例复杂度** | **平均案件复杂度** | **最坏情况的复杂性** |
| **操作** | **最佳情况复杂度** | **平均情况复杂度** | **最坏情况的复杂性** |
| 搜索 | `O(log n)` | `O(log n)` | `O(n)` |
| 插入 | `O(log n)` | `O(log n)` | `O(n)` |
| 删除中 | `O(log n)` | `O(log n)` | `O(n)` |
......
docs/dsal/34.md
浏览文件 @ ce398320
......@@ -765,11 +765,11 @@ int main() {
最坏情况下的时间复杂度：`Θ(log n)`
平均案例时间复杂度：`Θ(log n)`
平均情况时间复杂度：`Θ(log n)`
最佳情况时间复杂度：`Θ(log n)`
平均案例空间复杂度：`Θ(n)`
平均情况空间复杂度：`Θ(n)`
最坏情况的空间复杂度：`Θ(n)`
......
docs/dsal/35.md
浏览文件 @ ce398320
......@@ -4,7 +4,7 @@
#### 在本教程中，您将学习如何将密钥插入 B 树。 此外，您还将找到在 C，C++ ，Java 和 Python 中将键插入 B 树的工作示例。
在 B 树上插入元素包括两个事件**：搜索适当的节点**以插入元素，以及**拆分节点**。如有必要，插入操作始终从下往上进行 方法。
在 B 树上插入元素包括两个事件：搜索适当的节点**来插入元素**，以及**拆分节点**。如有必要，插入操作始终从下往上进行。
让我们在下面了解这些事件。
......
docs/dsal/36.md
浏览文件 @ ce398320
......@@ -4,16 +4,16 @@
#### 在本教程中，您将学习如何从 b 树中删除键。 此外，您还将找到在 C，C++ ，Java 和 Python 中从 B 树中删除键的工作示例。
删除 B 树上的元素包括三个主要事件**：搜索要删除的密钥存在的节点**，删除密钥并根据需要平衡树。
删除 B 树上的元素包括三个主要事件：**搜索要删除的键存在的节点**，删除键并按需平衡树。
删除树时，可能会发生称为**下溢**的条件。 当节点包含的数量少于其应持有的最小密钥数时，就会发生下溢。
删除树时，可能会发生称为**下溢**的条件。 当节点包含的数量少于其应持有的最小键数时，就会发生下溢。
在研究删除操作之前，应了解以下术语：
1. **有序前任**
节点左子级上的最大键称为其有序前任。
2. **有序后继者**
节点右子级上的最小键称为其有序后继者。
1. **有序前驱**
节点左子级上的最大键称为其有序前驱。
2. **有序后继**
节点右子级上的最小键称为其有序后继。
* * *
......@@ -28,49 +28,49 @@
B 树中的删除操作主要有三种情况。
### 案例一
### 情况一
要删除的密钥位于叶子中。 有两种情况。
要删除的键位于叶子中。 有两种情况。
1. 删除密钥不会违反节点应持有的最小密钥数的属性。
1. 删除键不会违反节点应持有的最小键数的属性。
在下面的树中，删除 32 不违反上述属性。
![Delete a key from a B-tree](img/86c9f28902ddce7307e93b92d70d31da.png "Delete 32 from B-tree")
从 B 树中删除叶子密钥（32）
从 B 树中删除叶子键（32）
2. 密钥的删除违反了节点应持有的最小密钥数的属性。 在这种情况下，我们以从左到右的顺序从其直接相邻的兄弟节点借用密钥。
2. 键的删除违反了节点应持有的最小键数的属性。 在这种情况下，我们以从左到右的顺序从其直接相邻的兄弟节点借用键。
首先，访问紧邻的左兄弟姐妹。 如果左兄弟节点的密钥数目超过最小数目，则从该节点借用密钥。
首先，访问紧邻的左兄弟姐妹。 如果左兄弟节点的键数目超过最小数目，则从该节点借用键。
否则，请检查以从紧邻的右同级节点借用。
在下面的树中，删除 31 将导致上述情况。 让我们从左侧兄弟节点借用一个密钥。
在下面的树中，删除 31 将导致上述情况。 让我们从左侧兄弟节点借用一个键。
![Delete a key from a B-tree](img/ce84f115ef0d202bbf777be203b1f79d.png "Delete 31 from a B-tree")
删除叶子密钥（31）
删除叶子键（31）
如果两个直接同级节点都已经具有最小数量的密钥，则将该节点与左同级节点或右同级节点合并 节点。 **此合并是通过父节点完成的。**
如果两个直接同级节点都已经具有最小数量的键，则将该节点与左同级节点或右同级节点合并 节点。 **此合并是通过父节点完成的。**
在上述情况下，删除 30 个结果。
![Delete a key from a B-tree](img/919d28c8826909998a737c2e1999dba1.png "Delete 30 from a B-tree")
删除叶子密钥（30）
删除叶子键（30）
### 案例二
### 情况二
如果要删除的密钥位于内部节点中，则会发生以下情况。
如果要删除的键位于内部节点中，则会发生以下情况。
1. 如果左子节点的键数超过最小数目，则删除的内部节点将替换为有序的前任节点。
1. 如果左子节点的键数超过最小数目，则删除的内部节点将替换为有序的前驱节点。
![Deleting an internal node](img/7d5e0803bbb7ef84b6cec6469aa965e2.png "Deleting an internal node")
......@@ -78,7 +78,7 @@ B 树中的删除操作主要有三种情况。
2. 如果正确的子项超过了最小数目的键，则删除的内部节点将被有序后继者替换。
2. 如果正确的子项超过了最小数目的键，则删除的内部节点将被有序后继替换。
3. 如果任一子项的键数恰好最小，则合并左子项和右子项。
![Deleting an internal node](img/ef4313da624bd17af67e6ef5d47b0198.png "Deleting an internal node")
......@@ -89,9 +89,9 @@ B 树中的删除操作主要有三种情况。
合并后，如果父节点的键数少于最小数目，则像情况 I 一样查找同级。
### 案例三
### 情况三
在这种情况下，树的高度会缩小。 如果目标密钥位于内部节点中，并且密钥的删除导致节点中密钥的数量减少（即少于所需的最小数量），则寻找有序前任和有序后继。 如果两个孩子都包含最少数量的钥匙，则无法进行借用。 这导致案例二（3），即合并孩子。
在这种情况下，树的高度会缩小。 如果目标键位于内部节点中，并且键的删除导致节点中键的数量减少（即少于所需的最小数量），则寻找有序前驱和有序后继。 如果两个孩子都包含最少数量的钥匙，则无法进行借用。 这导致情况二（3），即合并孩子。
同样，寻找同胞借用钥匙。 但是，如果同级也只有最少数量的键，则将同级节点与父级合并。 相应地安排孩子们（增加顺序）。
......@@ -1416,6 +1416,6 @@ int main() {
最佳情况时间复杂度：`Θ(log n)`
平均案例空间复杂度：`Θ(n)`
平均情况空间复杂度：`Θ(n)`
最坏情况的空间复杂度：`Θ(n)`
\ No newline at end of file
docs/dsal/38.md
浏览文件 @ ce398320
......@@ -4,7 +4,7 @@
#### 在本教程中，您将学习有关 B+ 树上的插入操作的信息。 此外，您还将找到在 C，C++ ，Java 和 Python 中将元素插入 B+ 树的工作示例。
将元素插入 [B+ 树](https://www.programiz.com/dsa/b%2Btree)包含三个主要事件**：搜索适当的叶子**，**插入**元素以及**平衡/拆分** 树。
将元素插入 [B+ 树](https://www.programiz.com/dsa/b%2Btree)包含三个主要事件：**搜索适当的叶子**，**插入**元素以及**平衡/拆分**树。
让我们在下面了解这些事件。
......@@ -21,15 +21,15 @@
按照以下步骤插入元素。
1. 由于每个元素都插入到叶节点中，因此请转到相应的叶节点。
2. 将密钥插入叶子节点。
2. 将键插入叶子节点。
### 案例一
### 情况一
1. 如果叶子未满，请按递增顺序将密钥插入叶子节点。
1. 如果叶子未满，请按递增顺序将键插入叶子节点。
### 案例二
### 情况二
1. 如果叶子已满，请按递增顺序将密钥插入叶子节点，并按以下方式平衡树。
1. 如果叶子已满，请按递增顺序将键插入叶子节点，并按以下方式平衡树。
2. 在`m / 2`位置断开节点。
3. 也将`m / 2th`键添加到父节点。
4. 如果父节点已满，请执行步骤 4 至 6。
......
docs/dsal/39.md
浏览文件 @ ce398320
......@@ -4,7 +4,7 @@
#### 在本教程中，您将了解有关 B+ 树的删除操作。 此外，您还将找到从 C，C++ ，Java 和 Python 中的 B+ 树中删除元素的工作示例。
删除 B+ 树上的元素包括三个主要事件**：搜索**要删除的密钥所在的节点，删除密钥并根据需要平衡树。 **下溢**是节点中的密钥数量少于其应容纳的最小密钥数量的情况。
删除 B+ 树上的元素包括三个主要事件：搜索**要删除的键所在的节点**，删除键并按需平衡树。 **下溢**是节点中的键数量少于其应容纳的最小键数量的情况。
* * *
......@@ -17,34 +17,34 @@
3. 一个节点至少应具有`⌈m/2⌉`个子节点。 （即 2）
4. 一个节点（根节点除外）应至少包含`⌈m/2⌉ - 1`键。 （即 1）
删除键时，我们还必须照顾内部节点（即索引）中存在的键，因为这些值在 B+ 树中是多余的。 搜索要删除的密钥，然后按照以下步骤操作。
删除键时，我们还必须照顾内部节点（即索引）中存在的键，因为这些值在 B+ 树中是多余的。 搜索要删除的键，然后按照以下步骤操作。
### 案例一
### 情况一
要删除的密钥仅存在于叶节点上，而不存在于索引（或内部节点）中。 有两种情况：
要删除的键仅存在于叶节点上，而不存在于索引（或内部节点）中。 有两种情况：
1. 节点中的密钥数目超过最小数目。 只需删除密钥。
1. 节点中的键数目超过最小数目。 只需删除键。
![Delete a key from a B+tree](img/26661d4f0c95938de743065fd15ff16b.png "Deletion from a B+ tree")
从 B 树删除 40
2. 节点中有确切的最小密钥数。 删除密钥并从直接同级中借用密钥。 将同级节点的中间键添加到父级。
2. 节点中有确切的最小键数。 删除键并从直接同级中借用键。 将同级节点的中间键添加到父级。
![Delete a key from a B+tree](img/81b5744e0c47f7af93ed6c88a5122885.png "Deletion from a B+ tree")
从 B 树中删除 5
### 案例二
### 情况二
内部节点中也存在要删除的密钥。 然后，我们也必须从内部节点中删除它们。 对于这种情况，有以下几种情况。
内部节点中也存在要删除的键。 然后，我们也必须从内部节点中删除它们。 对于这种情况，有以下几种情况。
1. 如果节点中的密钥数量超过最小数量，则只需从叶节点删除密钥，并从内部节点删除密钥即可。
用顺序后继者填充内部节点中的空白区域。
1. 如果节点中的键数量超过最小数量，则只需从叶节点删除键，并从内部节点删除键即可。
用顺序后继填充内部节点中的空白区域。
![Delete a key from a B+tree](img/0da0aa58e38326ce7ca8e6707fc30f9b.png "Deletion from a B+ tree")
从 B 树删除 45
2. 如果节点中的密钥数量确切最小，则删除该密钥并从其直接同级（通过父级）借用一个密钥。
2. 如果节点中的键数量确切最小，则删除该键并从其直接同级（通过父级）借用一个键。
使用借来的键填充在索引（内部节点）中创建的空白空间。
![Delete a key from a B+tree](img/545807ef2b89ec95ecce0bf5d280e816.png "Deletion from a B+ tree")
......@@ -52,13 +52,13 @@
从 B 树中删除 35
3. 这种情况与情况 II（1）相似，但是在此处，直接父节点上方会生成空白空间。
删除键后，将空白空间与其同级合并。
用顺序后继者填充祖父母节点中的空白区域。
用顺序后继填充祖父母节点中的空白区域。
![Delete a key from a B+tree](img/b735d929d2b05a58783584fe7b7f5bcf.png "Deletion from a B+ tree")
从 B 树中删除 25
### 案例三
### 情况三
在这种情况下，树的高度会缩小。 这有点复杂。从下面的树中删除 55 会导致这种情况。 在下面的插图中可以理解。
......
docs/dsal/40.md
浏览文件 @ ce398320
......@@ -219,13 +219,13 @@ Red Black Tree
1. 进行以下操作，直到`newNode p`的父级为红色。
2. 如果`p`是`z`的`grandParent gP`的左孩子，请执行以下操作。
**案例一**：
**情况一**：
1. 如果`z`的`gP`的右子色为红色，则将`gP`的两个子级分别设置为黑色和红色。
2. 将`gP`分配给`newNode`。
**案例 II**：
**情况 II**：
3. 否则，如果`newNode`是`p`的右子代，则将`p`分配给`newNode`。
4. 向左旋转`newNode`。
**案例 III**：
**情况 III**：
5. 将`p`的颜色设置为黑色，将`gP`的颜色设置为红色。
6. 右旋`gP`。
3. 否则，请执行以下操作。
......@@ -285,7 +285,7 @@ Red Black Tree
2. 如果`x`是其父级的左孩子，
1. 将`w`分配给`x`的同级。
2. 如果`x`的父级的右子是红色，则
**情况一**：
**情况 I**：
1. 将`x`的父级的右子级的颜色设置为黑色。
2. 将`x`的父级颜色设置为红色。
3. 左旋转`x`的父级。
......@@ -301,7 +301,7 @@ Red Black Tree
3. 向右旋转`w`。
4. 将`x`的父级的`rightChild`分配给`w`。
5. 如果以上情况均未发生，请执行以下操作。
**案例 IV**：
**情况 IV**：
1. 将`w`的颜色设置为`x`的父代的颜色。
2. 将`x`的父级的颜色设置为黑色。
3. 将`w`的右子元素的颜色设置为黑色。
......
docs/dsal/41.md
浏览文件 @ ce398320
......@@ -84,7 +84,7 @@
1. 执行以下操作，直到`newNode p`的父代变为红色。
2. 如果`p`是`newNode`的`grandParent gP`的左孩子，请执行以下操作。
**案例一**：
**情况一**：
1. 如果`newNode`的`gP`的右子级的颜色是红色，则将`gP`的子级的颜色都设置为黑色，将`gP`的颜色都设置为红色。
![insertion in a red-black tree](img/8488c5a2a75c52ece78f1827c4a5b0c0.png "color change")
......@@ -101,7 +101,7 @@
**案例 II**：
**情况 II**：
3. （在继续此步骤之前，将检查`while`循环。如果不满足条件，则循环会中断。）
否则，如果`newNode`是`p`的右子代，则将`p`分配给[ `newNode`。
......@@ -119,7 +119,7 @@
**案例 III**：
**情况 III**：
5. （在继续此步骤之前，检查循环。如果不满足条件，则循环中断。）
将`p`的颜色设置为黑色，将`gP`的颜色设置为红色。
......
docs/dsal/42.md
浏览文件 @ ce398320
......@@ -91,7 +91,7 @@
2. 如果`x`的同级是红色，则
**情况一**：
**情况 I**：
1. 将`x`的父级的右子级的颜色设置为黑色。
2. 将`x`的父级颜色设置为红色。
......@@ -149,7 +149,7 @@
5. 如果以上情况均未发生，请执行以下操作。
**案例 IV**：
**情况 IV**：
1. 将`w`的颜色设置为`x`的父代的颜色。
2. 将`x`的父级的父级颜色设置为黑色。
3. 将`w`的右子元素的颜色设置为黑色。
......
docs/dsal/44.md
浏览文件 @ ce398320
......@@ -41,7 +41,7 @@ G = {V, E}
## 图术语
* **相邻性**：如果存在一条连接顶点的边，则该顶点被称为与另一个顶点相邻。 顶点 2 和 3 不相邻，因为它们之间没有边。
* **相邻**：如果存在一条连接顶点的边，则该顶点被称为与另一个顶点相邻。 顶点 2 和 3 不相邻，因为它们之间没有边。
* **路径**：一条允许您从顶点`A`到顶点`B`的边序列称为路径。 0-1、1-2 和 0-2 是从顶点 0 到顶点 2 的路径。
* **有向图**：其中边`(u, v)`不一定意味着也有边`(v, u)`的图。 该图中的边缘由箭头表示，以显示边缘的方向。
......
docs/dsal/45.md
浏览文件 @ ce398320
......@@ -14,7 +14,7 @@ Undirected Graph
**连接图**是其中始终存在从顶点到任何其他顶点的路径的图。
**连通图**是其中始终存在从顶点到任何其他顶点的路径的图。
![Connected Graph](img/0f73a6491cca9899d7b69678dba221a1.png "Connected Graph")
......
docs/dsal/46.md
浏览文件 @ ce398320
# 紧密连接的组件
# 强连通的组件
> 原文： [https://www.programiz.com/dsa/strongly-connected-components](https://www.programiz.com/dsa/strongly-connected-components)
#### 在本教程中，您将学习如何形成紧密连接的组件。 此外，您还将在 C，C++ ，Java 和 Python 中找到 kosararju 算法的工作示例。
#### 在本教程中，您将学习如何形成强连通的组件。 此外，您还将在 C，C++ ，Java 和 Python 中找到 kosararju 算法的工作示例。
牢固连接的组件是有向图的一部分，其中从每个顶点到另一个顶点都有一条路径。 **仅适用于** [**有向图**](/dsa/graph) 。
强连通的组件是有向图的一部分，其中从每个顶点到另一个顶点都有一条路径。 仅适用于[**有向图**](/dsa/graph)。
例如：
......@@ -16,7 +16,7 @@ Initial graph
上图的牢固连接的组件是：
上图的强连通的组件是：
![Strongly connected components](img/7acb7991e5f198930acc668896e8d803.png "Strongly connected components")
......@@ -26,7 +26,7 @@ Strongly connected components
您可以观察到，在第一个强连接的组件中，每个顶点都可以通过定向路径到达另一个顶点。
可以使用 **Kosaraju 的算法**找到这些组件。
可以使用 **Kosaraju 算法**找到这些组件。
* * *
......@@ -83,7 +83,7 @@ Kosaraju 的算法基于[两次实现的深度优先搜索算法](/dsa/graph-dfs
上
3. 对反向图执行深度优先搜索。
从栈的顶部顶点开始。 遍历其所有子顶点。 一旦到达已经访问过的顶点，就会形成一个牢固连接的组件。
从栈的顶部顶点开始。 遍历其所有子顶点。 一旦到达已经访问过的顶点，就会形成一个强连通的组件。
例如：从栈中弹出顶点 0。 从顶点 0 开始，遍历其子顶点（依次为顶点 0，顶点 1，顶点 2，顶点 3）并将它们标记为已访问。 顶点 3 的子级已经被访问过，因此这些访问过的顶点形成一个强连接的组件。
......@@ -103,7 +103,7 @@ Kosaraju 的算法基于[两次实现的深度优先搜索算法](/dsa/graph-dfs
![reversed graph - strongly connected components](img/54ce7d5d6112c49854d34e8dd9ba4400.png "reversed graph - step-3")
牢固连接的组件
强连通的组件
......@@ -418,7 +418,7 @@ Kosaraju 的算法在线性时间即`O(V+E)`中运行。
* * *
## 紧密连接的组件应用
## 强连通的组件应用
* 车辆路线选择应用
* 地图
......
docs/dsal/48.md
浏览文件 @ ce398320
......@@ -88,7 +88,7 @@ class Graph
## 邻接表 Python
Python 得到如此多的爱是有原因的。 一个简单的顶点及其边的字典就足以表示一个图。 您可以根据需要使顶点本身复杂。
Python 得到如此多的爱是有原因的。 一个简单的顶点及其边的字典就足以表示一个图。 您可以按需使顶点本身复杂。
```
graph = {'A': set(['B', 'C']),
......
docs/dsal/53.md
浏览文件 @ ce398320
......@@ -440,7 +440,7 @@ int main() {
* **最佳情况复杂度**： `O(n)`
如果数组已经排序，则无需排序。
* **平均大小写复杂度**： `O(n^2)`
* **平均情况复杂度**： `O(n^2)`
当数组的元素处于混乱顺序（既不升也不降）时，会发生这种情况。
**空间复杂度**：
......
docs/dsal/54.md
浏览文件 @ ce398320
......@@ -267,7 +267,7 @@ int main() {
如果我们要以升序排序，而数组是以降序排序，那么会发生最坏情况。
* **最佳情况复杂度**： `O(n^2)`
在对数组进行排序时会发生
* **平均大小写复杂度**： `O(n^2)`
* **平均情况复杂度**： `O(n^2)`
当数组的元素处于混乱顺序（既不升也不降）时，会发生这种情况。
选择排序的时间复杂度在所有情况下都是相同的。 在每一步中，您都必须找到最小的元素并将其放在正确的位置。 直到没有到达数组的末尾，才知道最小元素。
......
docs/dsal/55.md
浏览文件 @ ce398320
......@@ -237,7 +237,7 @@ int main() {
因此，比较总数= `n*(n-1) ~ n^2`
* **最佳情况复杂度**： `O(n)`
当数组已经排序时，外循环运行`n`次数，而内循环则根本不运行。 因此，只有`n`个比较。 因此，复杂度是线性的。
* **平均大小写复杂度**： `O(n^2)`
* **平均情况复杂度**： `O(n^2)`
当数组的元素处于混乱顺序（既不升也不降）时，会发生这种情况。
**空间复杂度**
......
docs/dsal/56.md
浏览文件 @ ce398320
......@@ -20,7 +20,7 @@ Merge Sort example
假设我们必须对数组`A`进行排序。 一个子问题将是对该数组的一个子节进行排序，该子节开始于索引`p`，结束于索引`r`，表示为`A[p..r]`。
**除以**
**划分**
如果`q`是`p`和`r`之间的中点，则我们可以将子数组`A[p..r]`分成两个数组`A[p..q]`和`A[q + 1..r]`。
**解决**
......@@ -57,9 +57,9 @@ Merge sort in action
### **合并**合并步骤
### 合并步骤
每个递归算法都依赖于基本案例以及将基本案例的结果进行组合的能力。 合并排序没有什么不同。 您猜对了，合并排序算法最重要的部分是<samp>合并</samp>步骤。
每个递归算法都依赖于基本情况以及将基本情况的结果进行组合的能力。 合并排序没有什么不同。 您猜对了，合并排序算法最重要的部分是合并步骤。
合并步骤是解决合并两个排序列表（数组）以构建一个大排序列表（数组）这一简单问题的解决方案。
......@@ -606,11 +606,11 @@ int main() {
### 时间复杂度
最佳案例复杂度：`O(n * log n)`
最佳情况复杂度：`O(n * log n)`
最坏情况的复杂度：`O(n * log n)`
平均案件复杂度：`O(n * log n)`
平均情况复杂度：`O(n * log n)`
### 空间复杂度
......
docs/dsal/60.md
浏览文件 @ ce398320
......@@ -520,7 +520,7 @@ int main(void) {
当元素在桶中均匀分布且每个桶中元素数量几乎相等时，会发生这种情况。
如果存储桶中的元素已经被分类，那么复杂性就会变得更好。
如果使用插入排序对存储桶中的元素进行排序，则最佳情况下的总体复杂度将是线性的，即。`O(n+k)`。`O(n)`是制造存储桶的复杂度，`O(k)`是使用在最佳情况下具有线性时间复杂度的算法对存储桶的元素进行分类的复杂度。
* **平均大小写复杂度**： `O(n)`
* **平均情况复杂度**： `O(n)`
当元素在数组中随机分布时发生。 即使元素分布不均匀，存储桶排序也会在线性时间内运行。 直到铲斗尺寸的平方和在元素总数中呈线性关系时，它才成立。
* * *
......
docs/dsal/62.md
浏览文件 @ ce398320
......@@ -246,7 +246,7 @@ Shell 排序是一种不稳定的排序算法，因为该算法不会检查间
根据 Poonen 定理，Shell 排序的最坏情况复杂度是`Θ(Nlog N)^2/(log log N)^2)`或`Θ(Nlog N)^2/log log N)`或`Θ(N(log N)^2)`或介于两者之间。
* **最佳情况复杂度**：`O(n*log n)`
对数组进行排序后，每个时间间隔（或增量）的比较总数等于数组的大小。
* **平均案件复杂度**：`O(n*log n)`
* **平均情况复杂度**：`O(n*log n)`
在`O(n^1.25)`附近。
复杂程度取决于选择的间隔。 对于选择的不同增量序列，上述复杂度有所不同。 最佳递增顺序未知。
......
docs/dsal/64.md
浏览文件 @ ce398320
......@@ -411,7 +411,7 @@ int main(void) {
**时间复杂度**
* **最佳情况复杂度**：`O(1)`
* **平均案件复杂度**：`O(log n)`
* **平均情况复杂度**：`O(log n)`
* **最坏情况的复杂性**：`O(log n)`
**空间复杂度**
......
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或