Skip to content

P
programiz-zh

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

通知 0
Star 48
Fork 7
P
programiz-zh

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

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

2020-07-09 17:53:49

上级 1e21b9d7
隐藏空白更改
内联 并排
Showing with 67 addition and 72 deletion
docs/dsal/12.md
浏览文件 @ 9f22c937
......@@ -40,7 +40,7 @@ Circular queue representation
* 初始化队列时，我们将`FRONT`和`REAR`的值设置为 -1。
* 在对元素进行排队时，我们循环增加`REAR`索引的值，并将新元素放置在`REAR`指向的位置。
* 在元素出队时，我们返回`FRONT`指向的值，并循环增加`FRONT`索引。
* 在排队之前，我们检查队列是否已满。
* 在入队之前，我们检查队列是否已满。
* 在出队之前，我们检查队列是否已经为空。
* 当对第一个元素进行排队时，我们将`FRONT`的值设置为 0。
* 使最后一个元素出队时，我们将`FRONT`和`REAR`的值重置为 -1。
......
docs/dsal/13.md
浏览文件 @ 9f22c937
......@@ -58,7 +58,7 @@ The highest priority element dequeued first
2. 堆肥树。
2. 对树建堆。
![Inserting an element into priority queue](img/9e16a7d0bf48a44639ccd14467b8cdcf.png "Priority queue insertion")
......@@ -110,7 +110,7 @@ heapify the array
4. 堆肥树。
4. 对树建堆。
![Deleting an element into priority queue](img/dc6d6b65a63b6d85c93a484a8eb2528e.png "Priority queue deletion")
......
docs/dsal/14.md
浏览文件 @ 9f22c937
......@@ -719,6 +719,6 @@ int main()
## 和应用
1. 在对软件的撤消操作中。
1. 软件中的撤消操作。
2. 在浏览器中存储历史记录。
3. 为了实现[栈](https://www.programiz.com/dsa/stack)和[队列](https://www.programiz.com/dsa/queue)。
\ No newline at end of file
docs/dsal/17.md
浏览文件 @ 9f22c937
......@@ -8,8 +8,8 @@
请记住两个要点：
* `头`指向链表的第一个节点
* 最后一个节点的`下一个`指针是`NULL`，因此，如果下一个当前节点是`NULL`，我们已经到达链表的末尾。
* `head`指向链表的第一个节点
* 最后一个节点的`next`指针是`NULL`，因此，如果下一个当前节点是`NULL`，我们已经到达链表的末尾。
在所有示例中，我们将假定链表具有三个节点`1 --->2 --->3`，其节点结构如下：
......@@ -56,8 +56,8 @@ List elements are -
* 为新节点分配内存
* 存储数据
* 更改新节点的下一个指向头
* 将头更改为指向最近创建的节点
* 更改新节点的`next`指向`head`
* 将`head`更改为指向最近创建的节点
```
struct node *newNode;
......@@ -72,7 +72,7 @@ head = newNode;
* 为新节点分配内存
* 存储数据
* 遍历到最后一个节点
* 将最后一个节点的下一个更改为最近创建的节点
* 将最后一个节点的`next`更改为最近创建的节点
```
struct node *newNode;
......@@ -91,8 +91,8 @@ temp->next = newNode;
### 添加到中间
* 分配内存并存储新节点的数据
* 在新节点所需位置之前遍历到节点
* 更改下一个指针以在其间包括新节点
* 遍历到新节点所需位置之前的节点
* 更改`next`指针以在其间包含新节点
```
struct node *newNode;
......@@ -118,7 +118,7 @@ temp->next = newNode;
### 从头删除
* 将头指向第二个节点
* 将`head`指向第二个节点
```
head = head->next;
......@@ -127,7 +127,7 @@ head = head->next;
### 从结尾删除
* 遍历到倒数第二个元素
* 将其下一个指针更改为`null`
* 将其`next`指针更改为`null`
```
struct node* temp = head;
......@@ -139,8 +139,8 @@ temp->next = NULL;
### 从中间删除
* 在要删除的元素之前遍历到元素
* 更改下一个指针以将节点从链中排除
* 遍历到要删除的元素之前的元素
* 更改`next`指针以将节点从链中排除
```
for(int i=2; i< position; i++) {
......
docs/dsal/19.md
浏览文件 @ 9f22c937
......@@ -534,6 +534,6 @@ if m = 2p, then h(k) = p lower bits of m
哈希表在以下位置实现
* 需要持续的时间查找和插入
* 需要常数时间的查找和插入
* 密码学应用
* 需要索引数据
\ No newline at end of file
docs/dsal/20.md
浏览文件 @ 9f22c937
......@@ -33,17 +33,17 @@ Heapify 是从二叉树创建堆数据结构的过程。 它用于创建最小
1. 令输入数组为
![heap initial array](img/6af3ddf91fe1df082edec39e4e06c7c3.png "Initial Array")
2. 从数组
![Complete binary tree](img/c1b5076eb739b03daad9670073f24096.png "Complete binary tree")创建完整的二叉树
2. 从数组创建完整的二叉树
![Complete binary tree](img/c1b5076eb739b03daad9670073f24096.png "Complete binary tree")
3. 从索引为`n/2 - 1`的非叶节点的第一个索引开始。
![heapify](img/bf67c94834b80cdf6caed4ad031d7b8d.png "start from the first on leaf node")
4. 将当前元素`i`设置为`largest`。
5. 左子索引由`2i + 1`给出，右子索引由`2i + 2`给出。
如果`leftChild`大于`currentElement`（即位于`ith`索引处的元素），则将`leftChildIndex`设置为最大。
如果`rightChild`大于`largest`中的元素，请将`rightChildIndex`设置为`largest`。
6. 将`largest`与`currentElement`
![heapify](img/f6c6bfa0ccd34a0d1c62696befa5a6dd.png "swap if necessary")交换
6. 将`largest`与`currentElement`交换
7. 重复步骤 3-7，直到子树也被堆积。
![heapify](img/f6c6bfa0ccd34a0d1c62696befa5a6dd.png "swap if necessary")
**算法**
......@@ -88,7 +88,7 @@ heapify the array
1. 在树的末尾插入新元素。
![insertion in heap](img/1e518ee0fcb3c0b3e1726033d765fc28.png "insert at the end")
2. 堆肥树。
2. 对树建堆。
![insertion in heap](img/ac49517672e7f5f1e914281698dc618f.png "heapify the array")
......@@ -115,7 +115,7 @@ heapify the array
![deletion in heap](img/3951bdd6bbc68e8a38d88c7f803f0c8c.png "swap with the last element")
3. 删除最后一个元素。
![deletion in heap](img/d0830fe692ebdb1879e060cc3929f2b0.png "remove the last element")
4. 堆肥树。
4. 对树建堆。
![deletion in heap](img/89d7769837df6eca33df0491dcd76052.png "heapify the array")
......
docs/dsal/21.md
浏览文件 @ 9f22c937
......@@ -141,7 +141,7 @@ Union of two heaps
![Unite those having the same degrees](img/ec518c25dc523192ec7855d4b3bc6f11.png "Extract min operation")
团结那些具有相同度数的人
合并那些具有相同度数的人
......@@ -149,7 +149,7 @@ Union of two heaps
![Unite those having the same degrees](img/1f1aea1a3ce3a3335a5853b55e785f3c.png "Extract min operation")
团结那些具有相同度数的人
合并那些具有相同度数的人
......@@ -157,7 +157,7 @@ Union of two heaps
![Unite those having the same degrees](img/0817eb28d2524b82ec8d1224b4dd351d.png "Extract min operation")
团结那些具有相同度数的人
合并那些具有相同度数的人
......@@ -173,16 +173,12 @@ Union of two heaps
![Unite those having the same degrees](img/de2e1d7300359c638c68471aef0cae23.png "Extract min operation")
将具有相同度数的
合并
9. 同样，将 21 和 18 结合在一起。
将具有相同度数的合并
9. 同样，将 21 和 18 组合在一起。
![Unite those having the same degrees](img/d73428403351477a4931f2c8a3788ab7.png "Extract min operation")
将具有相同度数的那些结合在一起
将具有相同度数的那些组合在一起
......
docs/dsal/27.md
浏览文件 @ 9f22c937
......@@ -25,13 +25,13 @@ Let, i = the number of internal nodes
λ = number of levels
```
1. 叶数为`i + 1`。
1. 叶子数为`i + 1`。
2. 节点总数为`2i + 1`。
3. 内部节点数为`(n – 1) / 2`。
4. 叶数为`(n + 1) / 2`。
4. 叶子数为`(n + 1) / 2`。
5. 节点总数为`2l – 1`。
6. 内部节点数为`l – 1`。
7. 叶数最多为`2^(λ - 1)`。
7. 叶子数最多为`2^(λ - 1)`。
* * *
......
docs/dsal/30.md
浏览文件 @ 9f22c937
......@@ -10,7 +10,7 @@
1. 任何节点的左和右子树之间的差异不超过一个
2. 左子树是平衡的
3. 正确的子树是平衡的
3. 右子树是平衡的
![Balanced Binary Tree Example](img/6b3a16aa5b603083d29631902c7795d9.png "Balanced Binary Tree")
......
docs/dsal/31.md
浏览文件 @ 9f22c937
......@@ -193,7 +193,7 @@ Final tree
1. 获取该节点的有序后继。
2. 将节点替换为有序后继节点。
3. 从原始位置卸下有序后继器。
3. 从原始位置卸下有序后继。
![3 is to be deleted](img/a0f38c40a574fdaacf5b0d9a62ba5c45.png "Deletion operation on a BST")
......
docs/dsal/32.md
浏览文件 @ 9f22c937
......@@ -135,7 +135,7 @@ Avl tree
2. 在`y-z`上右旋转。
2. 在`y-z`上向右旋转。
![left-right rotate](img/673135c0cd0b054d0b7f6b5514e376d2.png "right rotate z-y")
......@@ -145,7 +145,7 @@ Avl tree
在左右旋转时，这些布置首先向右移动，然后向左移动。
1. 在`x-y`上右旋转。
1. 在`x-y`上向右旋转。
![right-left rotate](img/0d086122b84eb5b2b7ba38e00a73a864.png "right rotate x-y")
......
docs/dsal/37.md
浏览文件 @ 9f22c937
......@@ -18,8 +18,8 @@ Multilevel Indexing using B+ tree
## B+ 树的属性
1. 所有叶子处于同一水平。
2. 根至少有两个孩子。
1. 所有叶子处于同一级别。
2. 根至少有两个子级。
3. 除根节点外，每个节点最多可以包含`m`个子级，并且至少具有`m / 2`个子级。
4. 每个节点最多可以包含`m -1`键，以及最小`⌈m/2⌉ -1`键。
......@@ -97,11 +97,10 @@ B+ tree
5. 找到了`k`。 找到
5. 找到了`k`。
![B+ tree search](img/e11e5ef800de1c09975e72c51aecc5f3.png "B+ tree search")
k
......@@ -1873,5 +1872,5 @@ int main() {
## B+ 树应用
* 多级索引
* 在树上更快的操作（插入，删除，搜索）
* 树上的更快操作（插入，删除，搜索）
* 数据库索引
\ No newline at end of file
docs/dsal/38.md
浏览文件 @ 9f22c937
......@@ -14,7 +14,7 @@
在将元素插入 B+ 树之前，必须牢记这些属性。
* 根至少有两个孩子。
* 根至少有两个子级。
* 除根节点外，每个节点最多可以有`m`个子级，并且至少有`m / 2`个子级。
* 每个节点最多可以包含`m-1`个键，最少可以包含`m / 2/2-1`个键。
......@@ -31,7 +31,7 @@
1. 如果叶子已满，请按递增顺序将键插入叶子节点，并按以下方式平衡树。
2. 在`m / 2`位置断开节点。
3. 也将`m / 2th`键添加到父节点。
3. 也将第`m / 2`个键添加到父节点。
4. 如果父节点已满，请执行步骤 4 至 6。
* * *
......
docs/dsal/40.md
浏览文件 @ 9f22c937
......@@ -26,8 +26,8 @@ Red Black Tree
* 颜色
* 键
* leftChild
* rightChild
* 左子级
* 右子级
* 父级（根节点除外）
* * *
......
docs/dsal/44.md
浏览文件 @ 9f22c937
......@@ -92,6 +92,6 @@ Adjacency list representation
最常见的图形操作是：
* 检查图中是否存在该元素
* 图遍历
* 图的遍历
* 向图形添加元素（顶点，边）
* 寻找从一个顶点到另一个顶点的路径
\ No newline at end of file
docs/dsal/54.md
浏览文件 @ 9f22c937
......@@ -283,7 +283,7 @@ int main() {
在以下情况下使用选择排序：
* 一个小清单要排序
* 要排序的一个小列表
* 交换成本无所谓
* 必须对所有要素进行检查
* 写入存储器的成本就像闪存一样重要（与冒泡排序的`O(n^2)`相比，写入/交换的次数为`O(n)`）
\ No newline at end of file
docs/dsal/56.md
浏览文件 @ 9f22c937
# 合并排序算法
# 归并排序算法
> 原文： [https://www.programiz.com/dsa/merge-sort](https://www.programiz.com/dsa/merge-sort)
#### 在本教程中，您将学习合并排序。 此外，您还将找到合并类别 C，C++ ，Java 和 Python 的工作示例。
#### 在本教程中，您将学习归并排序。 此外，您还将找到合并类别 C，C++ ，Java 和 Python 的工作示例。
合并排序是计算机编程中的一种“分治”算法。 它是最流行的排序算法之一，也是建立对构建递归算法的信心的一种好方法。
归并排序是计算机编程中的一种“分治”算法。 它是最流行的排序算法之一，也是建立对构建递归算法的信心的一种好方法。
![merge sort example](img/3440debe7e017472b6e3ed61c62d7b39.png "Merge sort example")
......@@ -49,7 +49,7 @@ MergeSort(A, p, r):
要对整个数组进行排序，我们需要调用`MergeSort(A, 0, length(A)-1)`。
如下图所示，合并排序算法将数组递归地分成两半，直到我们得到具有 1 个元素的数组的基本情况。 之后，合并功能将拾取排序后的子数组并将其合并以逐渐对整个数组进行排序。
如下图所示，归并排序算法将数组递归地分成两半，直到我们得到具有 1 个元素的数组的基本情况。 之后，合并功能将拾取排序后的子数组并将其合并以逐渐对整个数组进行排序。
![merge sort algorithm visualization](img/b260d5acdfeb1a0b67e39a34777a1ab5.png "Merge sort in action")
......@@ -59,7 +59,7 @@ Merge sort in action
### 合并步骤
每个递归算法都依赖于基本情况以及将基本情况的结果进行组合的能力。 合并排序没有什么不同。 您猜对了，合并排序算法最重要的部分是合并步骤。
每个递归算法都依赖于基本情况以及将基本情况的结果进行组合的能力。 归并排序没有什么不同。 您猜对了，归并排序算法最重要的部分是合并步骤。
合并步骤是解决合并两个排序列表（数组）以构建一个大排序列表（数组）这一简单问题的解决方案。
......@@ -85,7 +85,7 @@ Merge step
## 编写合并算法代码
我们上面描述的合并步骤和用于合并排序的步骤之间的明显区别是，我们仅对连续的子数组执行合并功能。
我们上面描述的合并步骤和用于归并排序的步骤之间的明显区别是，我们仅对连续的子数组执行合并功能。
这就是为什么我们只需要数组，第一个位置，第一个子数组的最后一个索引（我们可以计算第二个子数组的第一个索引）和第二个子数组的最后一个索引的原因。
......@@ -602,7 +602,7 @@ int main() {
* * *
## 合并排序复杂度
## 归并排序复杂度
### 时间复杂度
......@@ -614,11 +614,11 @@ int main() {
### 空间复杂度
合并排序的空间复杂度为`O(n)`。
归并排序的空间复杂度为`O(n)`。
* * *
## 合并排序应用程序
## 归并排序应用程序
* 倒数问题
* 外部分类
......
docs/dsal/61.md
浏览文件 @ 9f22c937
......@@ -487,7 +487,7 @@ Swap, Remove, and Heapify
同样，由于`build_max_heap`和`heap_sort`步骤是一个接一个地执行的，因此算法复杂度不会增加，而是保持在`nlog n`的顺序。
它还在`O(1)`空间复杂度中执行排序。 与快速排序相比，它具有更好的最坏情况`( O(nlog n) )`。 对于最坏的情况，快速排序具有复杂度`O(n^2)`。 但是在其他情况下，快速排序速度很快。 `Introsort`是堆排序的替代方案，它结合了快速排序和堆排序以保留两者的优势：最坏情况下的堆排序速度和平均速度。
它还在`O(1)`空间复杂度中执行排序。 与快速排序相比，它具有更好的最坏情况`( O(nlog n) )`。 对于最坏的情况，快速排序具有复杂度`O(n^2)`。 但是在其他情况下，快速排序速度很快。 `Introsort`是堆排序的替代方案，它组合了快速排序和堆排序以保留两者的优势：最坏情况下的堆排序速度和平均速度。
* * *
......@@ -495,4 +495,4 @@ Swap, Remove, and Heapify
涉及安全性的系统和嵌入式系统（例如 Linux Kernel）使用堆排序，因为堆排序的运行时间上限为`O(n log n)`，辅助存储的上限为`O(1)`上限。
尽管即使在最坏的情况下，堆排序也具有`O(n log n)`时间复杂度，但它没有更多的应用程序（与其他排序算法（如快速排序，合并排序）相比）。 但是，如果我们要从项目列表中提取最小（或最大）的数据，而无需保持其余项目按排序顺序的开销，则可以有效地使用其基础数据结构堆。 例如，优先队列。
\ No newline at end of file
尽管即使在最坏的情况下，堆排序也具有`O(n log n)`时间复杂度，但它没有更多的应用程序（与其他排序算法（如快速排序，归并排序）相比）。 但是，如果我们要从项目列表中提取最小（或最大）的数据，而无需保持其余项目按排序顺序的开销，则可以有效地使用其基础数据结构堆。 例如，优先队列。
\ No newline at end of file
docs/dsal/67.md
浏览文件 @ 9f22c937
......@@ -466,4 +466,4 @@ int main() {
* 输水管道
* 二分匹配问题
* 按需流通
\ No newline at end of file
* 按需流动
\ No newline at end of file
docs/dsal/68.md
浏览文件 @ 9f22c937
......@@ -591,6 +591,6 @@ void RemoveEdge(vector<Edge*>& edges, Edge* edge) {
## Dijkstra 的算法应用
* 寻找最短路径
* 在社交网络中的应用
* 社交网络中的应用
* 在电话网中
* 在地图上查找位置
\ No newline at end of file
docs/dsal/7.md
浏览文件 @ 9f22c937
......@@ -28,13 +28,13 @@
让我们借助示例来理解这个概念。
在这里，我们将使用分治的方法对数组进行排序（即[合并排序](https://www.programiz.com/dsa/merge-sort)）。
在这里，我们将使用分治的方法对数组进行排序（即[归并排序](https://www.programiz.com/dsa/merge-sort)）。
1. 假设给定数组为：
![initial array for merge sort](img/74e697391779ecae83309faf7adb2146.png "Array for merge sort")
合并排序数组
归并排序数组
......@@ -80,7 +80,7 @@ f(n) = cost of the work done outside the recursive call, which includes the cost
让我们举一个例子来发现递归问题的时间复杂度。
对于合并排序，等式可以写成：
对于归并排序，等式可以写成：
```
T(n) = aT(n/b) + f(n)
......@@ -144,7 +144,7 @@ fib(n)
## 分治法
* [二分搜索](https://www.programiz.com/dsa/binary-search)
* [合并排序](https://www.programiz.com/dsa/merge-sort)
* [归并排序](https://www.programiz.com/dsa/merge-sort)
* [快速排序](https://www.programiz.com/dsa/quick-sort)
* Strassen 的矩阵乘法
* 唐津算法
\ No newline at end of file
docs/dsal/74.md
浏览文件 @ 9f22c937
......@@ -305,7 +305,7 @@ Floyd-Warshall 算法的空间复杂度为`O(n^2)`。
## Floyd Warshall 算法应用
* 找到最短路径是有向图
* 找到有向图的最短路径
* 查找有向图的传递闭包
* 查找实矩阵的求逆
* 用于测试无向图是否是二部图
\ No newline at end of file
* 查找实矩阵的逆
* 测试无向图是否是二分图
\ No newline at end of file
docs/dsal/9.md
浏览文件 @ 9f22c937
......@@ -12,9 +12,9 @@ Stack representation in the form of pile of plates
想一想用这样一堆盘子可以做的事情
想一想用这样一堆板子可以做的事情
* 在上面放一个新盘子
* 在上面放一个新板
* 卸下顶板
如果要使板位于底部，则必须先卸下顶部的所有板。 这种安排称为**后进先出**-放置的最后一个项目是第一个要出去的项目。
......
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或