Skip to content

P
programiz-zh

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

通知 0
Star 48
Fork 7
P
programiz-zh

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

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

2020-07-09 18:26:21

上级 f50546cf
隐藏空白更改
内联 并排
Showing with 122 addition and 122 deletion
docs/dsal/10.md
浏览文件 @ a14acbc3
......@@ -22,7 +22,7 @@ FIFO representation
* * *
## 队列规格
## 队列规范
队列是一个对象，或更具体地说，是一个允许执行以下操作的抽象数据结构（ADT）：
......@@ -59,7 +59,7 @@ Working of queue operations
最常见的队列实现是使用数组，但是也可以使用列表来实现。
[Python](#python-code)[Java](#java-code)[C](#c-code)[C+](#cpp-code)
```
# Queue implementation in Python
......@@ -411,7 +411,7 @@ Limitation of a queue
* * *
## 队列申请
## 队列应用
* CPU 调度，磁盘调度
* 在两个进程之间异步传输数据时，使用队列进行同步。 例如：IO 缓冲区，管道，文件 IO 等
......
docs/dsal/11.md
浏览文件 @ a14acbc3
......@@ -42,7 +42,7 @@ Circular queue
## 优先队列
优先级队列是一种特殊的队列，其中每个元素都与一个优先级相关联，并根据其优先级进行服务。 如果出现具有相同优先级的元素，则会根据其在队列中的顺序为其提供服务。
优先队列是一种特殊的队列，其中每个元素都与一个优先级相关联，并根据其优先级进行服务。 如果出现具有相同优先级的元素，则会根据其在队列中的顺序为其提供服务。
![Priority queue](img/d83164c6c98b6c9d201ca288a380b2da.png "Priority queue")
......@@ -52,9 +52,9 @@ Priority queue
插入根据值的到达发生，而删除根据优先级发生。
请访问[优先级队列](https://www.programiz.com/dsa/priority-queue)，以了解有关优先级队列的更多信息。
请访问[优先队列](https://www.programiz.com/dsa/priority-queue)，以了解有关优先队列的更多信息。
## 双端队列或双端队列
## 双端队列
双端队列是一种队列类型，其中可以从前面或后面执行元素的插入和删除。 因此，它不遵循 FIFO 规则（先进先出）。
......
docs/dsal/12.md
浏览文件 @ a14acbc3
......@@ -64,7 +64,7 @@ Working of circular queue
最常见的队列实现是使用数组，但是也可以使用列表来实现。
[Python](#python-code)[Java](#java-code)[C](#c-code)[C+](#cpp-code)
```
# Circular Queue implementation in Python
......
docs/dsal/13.md
浏览文件 @ a14acbc3
......@@ -2,9 +2,9 @@
> 原文： [https://www.programiz.com/dsa/priority-queue](https://www.programiz.com/dsa/priority-queue)
#### 在本教程中，您将学习什么是优先级队列。 另外，您还将找到 C，C++ ，Java 和 Python 中优先级队列操作的工作示例。
#### 在本教程中，您将学习什么是优先队列。 另外，您还将找到 C，C++ ，Java 和 Python 中优先队列操作的工作示例。
优先级队列是一种特殊的队列，其中每个元素都与一个优先级相关联，并根据其优先级进行服务。 如果出现具有相同优先级的元素，则会根据其在队列中的顺序为其提供服务。
优先队列是一种特殊的队列，其中每个元素都与一个优先级相关联，并根据其优先级进行服务。 如果出现具有相同优先级的元素，则会根据其在队列中的顺序为其提供服务。
通常，元素本身的值被认为用于分配优先级。
......@@ -18,17 +18,17 @@ The highest priority element dequeued first
* * *
### 优先级队列与队列有何不同？
### 优先队列与队列有何不同？
在队列中，实现**先进先出规则**，而在优先级队列中，基于优先级删除值**。 优先级最高的元素将首先被删除。**
在队列中，实现**先进先出规则**，而在优先队列中，基于优先级删除值**。 优先级最高的元素将首先被删除。**
* * *
## 优先队列的实现
可以使用数组，链表，堆数据结构或二叉搜索树来实现优先级队列。 在这些数据结构中，堆数据结构提供了优先级队列的有效实现。
可以使用数组，链表，堆数据结构或二叉搜索树来实现优先队列。 在这些数据结构中，堆数据结构提供了优先队列的有效实现。
下面给出优先级队列的不同实现的比较分析。
下面给出优先队列的不同实现的比较分析。
|   | 获取 | 插入 | 删除 |
| --- | --- | --- | --- |
......@@ -40,15 +40,15 @@ The highest priority element dequeued first
## 优先队列操作
优先级队列的基本操作是插入，删除和查看元素。
优先队列的基本操作是插入，删除和查看元素。
在研究优先级队列之前，请参考[堆数据结构](/dsa/heap-data-structure)，以更好地了解二叉堆，因为该二叉堆用于实现本文中的优先级队列。
在研究优先队列之前，请参考[堆数据结构](/dsa/heap-data-structure)，以更好地了解二叉堆，因为该二叉堆用于实现本文中的优先队列。
* * *
### 从优先级队列插入元素
### 从优先队列插入元素
通过以下步骤将元素插入优先级队列（最大堆）。
通过以下步骤将元素插入优先队列（最大堆）。
1. 在树的末尾插入新元素。
......@@ -66,7 +66,7 @@ The highest priority element dequeued first
将元素插入优先级队列的算法（最大堆）
将元素插入优先队列的算法（最大堆）
```
If there is no node,
......@@ -81,9 +81,9 @@ heapify the array
* * *
### 从优先级队列中删除元素
### 从优先队列中删除元素
从优先级队列（最大堆）中删除元素的操作如下：
从优先队列（最大堆）中删除元素的操作如下：
1. 选择要删除的元素。
......@@ -118,7 +118,7 @@ heapify the array
删除优先级队列中元素的算法（最大堆）
删除优先队列中元素的算法（最大堆）
```
If nodeToBeDeleted is the leafNode
......@@ -133,7 +133,7 @@ heapify the array
* * *
### 从优先队列中偷看（查找最大值/最小值）
### 从优先队列中窥视（查找最大值/最小值）
窥视操作从最大堆中返回最大元素，或者从最小堆中返回最小元素，而不删除节点。
......@@ -145,7 +145,7 @@ return rootNode
* * *
### 从优先级队列中提取最大/最小
### 从优先队列中提取最大/最小
从最大堆中删除节点后，`Extract-Max`返回具有最大值的节点，而从最小堆中删除节点后，`Extract-Min`返回具有最小值的节点。
......@@ -153,7 +153,7 @@ return rootNode
## Python，Java，C/C++ 示例
[Python](#python-code)[Java](#java-code)[C](#c-code)[C+](#cpp-code)
```
# Max-Heap data structure in Python
......@@ -489,9 +489,9 @@ int main() {
* * *
## 优先队列申请
## 优先队列应用
优先级队列的一些应用程序是：
优先队列的一些应用程序是：
* Dijkstra 算法
* 用于实现栈
......
docs/dsal/14.md
浏览文件 @ a14acbc3
# 和
# 双端队列
> 原文： [https://www.programiz.com/dsa/deque](https://www.programiz.com/dsa/deque)
......@@ -23,9 +23,9 @@ Deque or Double Ended Queue
* * *
## 计票操作
## 双端队列操作
下面是[圆形双端数组](https://www.programiz.com/dsa/circular-queue)实现的双端队列。 在圆形数组中，如果数组已满，我们将从头开始。
下面是[循环双端数组](https://www.programiz.com/dsa/circular-queue)实现的双端队列。 在圆形数组中，如果数组已满，我们将从头开始。
但是在线性数组实现中，如果数组已满，则无法插入更多元素。 在下面的每个操作中，如果数组已满，则会引发“溢出消息”。
......@@ -69,7 +69,7 @@ Initialize an array and pointers
### 插入后方
### 在后面插入
此操作在后部增加了一个元素。
......@@ -121,7 +121,7 @@ Initialize an array and pointers
### 从后方删除
### 从后面删除
此操作从背面删除一个元素。
......@@ -156,7 +156,7 @@ Initialize an array and pointers
## Python，Java 和 C/C++ 示例
[Python](#python-code)[Java](#java-code)[C](#c-code)[C+](#cpp-code)
```
# Deque operations in python
......@@ -711,13 +711,13 @@ int main()
* * *
## 和复杂度
## 双端队列复杂度
所有上述操作的时间复杂度是恒定的，即`O(1)`。
* * *
## 和应用
## 双端队列应用
1. 软件中的撤消操作。
2. 在浏览器中存储历史记录。
......
docs/dsal/16.md
浏览文件 @ a14acbc3
......@@ -104,7 +104,7 @@ Simple linked list with three nodes
## Python，Java 和 C/C++ 示例
[Python](#python-code)[Java](#java-code)[C](#c-code)[C+](#cpp-code)
```
# Linked list implementation in Python
......
docs/dsal/17.md
浏览文件 @ a14acbc3
......@@ -156,7 +156,7 @@ temp->next = temp->next->next;
## 完整的链表操作程序
[Python](#python-code)[Java](#java-code)[C](#c-code)[C+](#cpp-code)
```
# Linked list operations in Python
......
docs/dsal/18.md
浏览文件 @ a14acbc3
# 链表的类型-单链，双链和循环链
# 链表的类型 - 单链，双链和循环链
> 原文： [https://www.programiz.com/dsa/linked-list-types](https://www.programiz.com/dsa/linked-list-types)
......@@ -116,7 +116,7 @@ head = one;
* * *
## 通报链表
## 循环链表
循环链表是链表的变体，其中最后一个元素链接到第一个元素。 这形成一个循环。
......
docs/dsal/19.md
浏览文件 @ a14acbc3
......@@ -477,7 +477,7 @@ if m = 2p, then h(k) = p lower bits of m
```
### 乘法法
### 乘法
`h(k) = ⌊m(kA mod 1)⌋`
其中，
......
docs/dsal/20.md
浏览文件 @ a14acbc3
......@@ -4,9 +4,9 @@
#### 在本教程中，您将学习什么是堆数据结构。 此外，您还将找到在 C，C++ ，Java 和 Python 中进行堆操作的工作示例。
堆数据结构是满足**堆属性**的完整二叉树，也称为二叉堆。
堆数据结构是满足**堆属性**的完全二叉树，也称为二叉堆。
完整的二叉树是一种特殊的二叉树，其中
完全二叉树是一种特殊的二叉树，其中
* 除最后一个级别外，每个级别都已填充
* 所有节点都尽可能地向左
......@@ -27,13 +27,13 @@
下面将对在堆上执行的一些重要操作及其算法进行描述。
### 堆肥
### 建堆
Heapify 是从二叉树创建堆数据结构的过程。 它用于创建最小堆或最大堆。
建堆是从二叉树创建堆数据结构的过程。 它用于创建最小堆或最大堆。
1. 令输入数组为
![heap initial array](img/6af3ddf91fe1df082edec39e4e06c7c3.png "Initial Array")
2. 从数组创建完整的二叉树
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")
......@@ -475,6 +475,6 @@ int main()
## 堆数据结构应用
* 在实现优先级队列时使用堆。
* 在实现优先队列时使用堆。
* Dijkstra 算法
* 堆排序
\ No newline at end of file
docs/dsal/21.md
浏览文件 @ a14acbc3
......@@ -97,7 +97,7 @@ Union of two heaps
### 提取物最小值
### 提取最小值
这是斐波那契堆上最重要的操作。 在此操作中，从堆中删除了具有最小值的节点，并重新调整了树。
......@@ -206,7 +206,7 @@ Union of two heaps
## Python，Java 和 C/C++ 示例
[Python](#python-code)[Java](#java-code)[C](#c-code)[C+](#cpp-code)
```
# Fibonacci Heap in python
......
docs/dsal/22.md
浏览文件 @ a14acbc3
# 减少斐波那契堆上的键并删除节点操作
# 减小斐波那契堆上的键和删除节点的操作
> 原文： [https://www.programiz.com/dsa/decrease-key-and-delete-node-from-a-fibonacci-heap](https://www.programiz.com/dsa/decrease-key-and-delete-node-from-a-fibonacci-heap)
#### 在本教程中，您将学习减小键和删除节点操作的工作方式。 此外，您还将在 C，C++ ，Java 和 Python 的斐波那契堆上找到这些操作的工作示例。
在斐波那契堆中，减少键和删除节点是重要的操作。 这些操作将在下面讨论。
在斐波那契堆中，减小键和删除节点是重要的操作。 这些操作将在下面讨论。
* * *
## 减少键
## 减小键
在减少键操作中，键的值被减小到较低的值。
在减小键操作中，键的值被减小到较低的值。
以下功能用于减小按键。
### 降低键
### 减小键
1. 选择要减少的节点`x`，并将其值更改为新值`k`。
1. 选择要减小的节点`x`，并将其值更改为新值`k`。
2. 如果`x`的父级`y`不为空，并且父级的键大于`k`的键，则调用`C ut(x)`和`C ascading- C ut(y)`随后。
3. 如果`x`的键小于`min`的键，则将`x`标记为`min`。
### 切
### 剪裁
1. 从当前位置删除`x`并将其添加到根列表中。
2. 如果标记了`x`，则将其标记为`false`。
......@@ -33,11 +33,11 @@
* * *
## 减少键示例
## 减小键示例
在以下示例中可以理解上述操作。
### 示例：将 46 减少到 15。
### 示例：将 46 减小到 15。
1. 将值减小 46 到 15。
2. **剪裁部分**：由于`24 ≠ nill`和`15 < its parent`，将其剪裁并将其添加到根列表中。 **级联剪裁部分**：标记为 24。
......@@ -48,7 +48,7 @@
### 示例：将 35 减少到 5
### 示例：将 35 减小到 5
1. 将值减小 35 到 5。
......@@ -105,7 +105,7 @@
## Python，Java 和 C/C++ 示例
[Python](#python-code)[Java](#java-code)[C](#c-code)[C+](#cpp-code)
```
# Fibonacci Heap in python
......
docs/dsal/24.md
浏览文件 @ a14acbc3
......@@ -64,7 +64,7 @@ Height and depth of each node in a tree
### 节点度
### 节点的度
节点的度数是该节点的分支总数。
......@@ -91,7 +91,7 @@ Creating forest from a tree
* * *
## 树遍历
## 树的遍历
为了对树执行任何操作，您需要到达特定节点。 树遍历算法有助于访问树中的所需节点。
......@@ -99,7 +99,7 @@ Creating forest from a tree
* * *
## 树木应用
## 树的应用
* 二叉搜索树（BST）用于快速检查元素是否存在于集合中。
* 堆是一种用于堆排序的树。
......
docs/dsal/25.md
浏览文件 @ a14acbc3
# 树遍历-顺序，前顺序和后顺序
# 树遍历 - 中序，前序和后序
> 原文： [https://www.programiz.com/dsa/tree-traversal](https://www.programiz.com/dsa/tree-traversal)
......@@ -59,7 +59,7 @@ Left and Right Subtree
* * *
## 顺序遍历
## 中序遍历
1. 首先，访问左侧子树中的所有节点
2. 然后是根节点
......@@ -73,7 +73,7 @@ inorder(root->right)
* * *
## 预定遍历
## 前序遍历
1. 访问根节点
2. 访问左侧子树中的所有节点
......@@ -87,7 +87,7 @@ preorder(root->right)
* * *
## 邮购遍历
## 后序遍历
1. 访问左侧子树中的所有节点
2. 访问右侧子树中的所有节点
......@@ -149,7 +149,7 @@ Final Stack
## Python，Java 和 C/C++ 示例
[Python](#python-code)[Java](#java-code)[C](#c-code)[C+](#cpp-code)
```
# Tree traversal in Python
......
docs/dsal/26.md
浏览文件 @ a14acbc3
# 二叉树
# 满二叉树
> 原文： [https://www.programiz.com/dsa/binary-tree](https://www.programiz.com/dsa/binary-tree)
......@@ -18,9 +18,9 @@ Binary Tree
## 二叉树的类型
### 全二叉树
### 满二叉树
完整的二叉树是二叉树的一种特殊类型，其中每个父节点/内部节点都有两个或没有子节点。
满二叉树是二叉树的一种特殊类型，其中每个父节点/内部节点都有两个或没有子节点。
![Full binary tree](img/49f25c60eff30f77913dd5fa576496c1.png "Full binary tree")
......@@ -28,9 +28,9 @@ Full Binary Tree
要了解更多信息，请访问[完整的二叉树](http://programiz.com/dsa/full-binary-tree)。
要了解更多信息，请访问[满二叉树](http://programiz.com/dsa/full-binary-tree)。
### 完美的二叉树
### 完美二叉树
完美的二叉树是一种二叉树，其中每个内部节点恰好有两个子节点，而所有叶节点都处于同一级别。
......@@ -42,13 +42,13 @@ Perfect Binary Tree
要了解更多信息，请访问[完美二叉树](http://programiz.com/dsa/perfect-binary-tree)。
### 完整的二叉树
### 完全二叉树
完整的二叉树就像完整的二叉树，但有两个主要区别
完全二叉树就像满二叉树，但有两个主要区别
1. 每个级别都必须完全填满
2. 所有叶子元素都必须向左倾斜。
3. 最后一个叶子元素可能没有正确的同级，即完整的二叉树不必是完整的二叉树。
3. 最后一个叶子元素可能没有正确的同级，即满完全二叉树不必是满二叉树。
![Complete Binary Tree](img/0b89bc3fa19185c45b18fd3f571da193.png "Complete Binary Tree")
......@@ -56,9 +56,9 @@ Complete Binary Tree
要了解更多信息，请访问[完整的二叉树](http://programiz.com/dsa/complete-binary-tree)。
要了解更多信息，请访问[完全二叉树](http://programiz.com/dsa/complete-binary-tree)。
### 退化树或病理树
### 退化树或病态树
退化或病态的树是具有左右一个独生子的树。
......@@ -70,7 +70,7 @@ Degenerate Binary Tree
### 偏二叉树
偏斜的二叉树是一种病态/退化的树，其中该树由左节点或右节点支配。 因此，存在两种类型的斜二叉树：**左斜二叉树**和**右斜二叉树**。
偏二叉树是一种病态/退化的树，其中该树由左节点或右节点支配。 因此，存在两种类型的斜二叉树：**左斜二叉树**和**右斜二叉树**。
![Skewed Binary Tree](img/33a3e3ea69a23289bc2a7282f43792f3.png "Skewed Binary Tree")
......@@ -115,7 +115,7 @@ Binary Tree Representation
## Python，Java 和 C/C++ 示例
[Python](#python-code)[Java](#java-code)[C](#c-code)[C+](#cpp-code)
```
# Binary Tree in Python
......
docs/dsal/27.md
浏览文件 @ a14acbc3
# 全二叉树
# 满二叉树
> 原文： [https://www.programiz.com/dsa/full-binary-tree](https://www.programiz.com/dsa/full-binary-tree)
#### 在本教程中，您将学习完整的二叉树及其不同的定理。 此外，您还将找到一些工作示例，以检查 C，C++ ，Java 和 Python 中的完整二进制树。
#### 在本教程中，您将学习满二叉树及其不同的定理。 此外，您还将找到一些工作示例，以检查 C，C++ ，Java 和 Python 中的完整二进制树。
完整的二叉树是二叉树的一种特殊类型，其中每个父节点/内部节点都有两个或没有子节点。
满二叉树是二叉树的一种特殊类型，其中每个父节点/内部节点都有两个或没有子节点。
**也称为适当的二叉树。**
......@@ -16,7 +16,7 @@ Full Binary Tree
* * *
## 完整二叉树定理
## 满二叉树定理
```
Let, i = the number of internal nodes
......@@ -37,9 +37,9 @@ Let, i = the number of internal nodes
## Python，Java 和 C/C++ 示例
以下代码用于检查树是否为完整的二叉树。
以下代码用于检查树是否为满二叉树。
[Python](#python-code)[Java](#java-code)[C](#c-code)[C+](#cpp-code)
```
# Checking if a binary tree is a full binary tree in Python
......
docs/dsal/29.md
浏览文件 @ a14acbc3
# 完整的二叉树
# 完全二叉树
> 原文： [https://www.programiz.com/dsa/complete-binary-tree](https://www.programiz.com/dsa/complete-binary-tree)
#### 在本教程中，您将学习完整的二叉树及其不同类型。 此外，您还将在 C，C++ ，Java 和 Python 中找到完整的二叉树的工作示例。
#### 在本教程中，您将学习完全二叉树及其不同类型。 此外，您还将在 C，C++ ，Java 和 Python 中找到完全二叉树的工作示例。
完整的二叉树是一棵二叉树，其中所有级别均已完全填充，但最低级别可能会从左侧填充。
完全二叉树是一棵二叉树，其中所有级别均已完全填充，但最低级别可能会从左侧填充。
完整的二叉树就像完整的二叉树，但有两个主要区别
完全二叉树就像满二叉树，但有两个主要区别
1. 所有叶子元素都必须向左倾斜。
2. 最后一个叶子元素可能没有正确的同级，即完整的二叉树不必是完整的二叉树。
2. 最后一个叶子元素可能没有正确的同级，即完全二叉树不必是满二叉树。
![Complete Binary Tree](img/0b89bc3fa19185c45b18fd3f571da193.png "Complete Binary Tree")
......@@ -19,7 +19,7 @@ Complete Binary Tree
* * *
## 完整二叉树 vs 完整二叉树
## 完全二叉树 vs 满二叉树
![Comparison between full binary tree and complete binary tree](img/41d9dd7ec5f9366619865f1f46e85606.png "Comparison between full binary tree and complete binary tree")
......@@ -47,7 +47,7 @@ Comparison between full binary tree and complete binary tree
* * *
## 如何创建完整的二叉树？
## 如何创建完全二叉树？
1. 选择列表的第一个元素作为根节点。 （级别 I 上的元素数：1）
......@@ -305,7 +305,7 @@ int main() {
## 数组索引和树元素之间的关系
完整的二叉树具有一个有趣的属性，我们可以用来查找任何节点的子代和父代。
完全二叉树具有一个有趣的属性，我们可以用来查找任何节点的子代和父代。
如果数组中任何元素的索引为`i`，则索引`2i+1`中的元素将成为左子元素，而`2i+2`索引中的元素将成为右子元素。 同样，索引为`i`的任何元素的父级都由`(i-1)/2`的下限给出。
......@@ -356,7 +356,7 @@ Parent of 12 (position 1)
* * *
## 完整的二叉树应用
## 完全二叉树应用
* 基于堆的数据结构
* [堆排序](https://www.programiz.com/dsa/heap-sort)
\ No newline at end of file
docs/dsal/4.md
浏览文件 @ a14acbc3
......@@ -126,9 +126,9 @@ int sum(int N) {
* * *
### 有关可伸缩性的更多信息
### 有关可扩展性的更多信息
可伸缩性是规模加能力，这意味着处理较大问题的算法/系统的质量。
可扩展性是规模加能力，这意味着处理较大问题的算法/系统的质量。
考虑建立一个有 50 个学生的教室的问题。 最简单的解决方案之一是预订房间，拿起黑板，几支粉笔，问题就解决了。
......@@ -144,7 +144,7 @@ int sum(int N) {
考虑一个像 [Khanacademy](https://www.khanacademy.org/) 这样的网站，数百万学生可以同时观看视频，阅读答案，并且不需要更多资源。 因此，该解决方案可以解决资源紧缩下规模较大的问题。
如果您看到我们找到第一个`N`个自然数之和的第一个解决方案，则该解决方案不可扩展。 这是因为它要求时间随时间线性增长，而问题的大小则线性增长。 这种算法也称为线性可伸缩算法。
如果您看到我们找到第一个`N`个自然数之和的第一个解决方案，则该解决方案不可扩展。 这是因为它要求时间随时间线性增长，而问题的大小则线性增长。 这种算法也称为线性可扩展算法。
我们的第二个解决方案具有很高的可扩展性，不需要花费更多的时间来解决更大的问题。 这些被称为恒定时间算法。
......@@ -164,12 +164,12 @@ int sum(int N) {
只需对[二分搜索算法](https://www.programiz.com/dsa/binary-search)进行少许修改，即可轻松解决诸如找到某个年龄段的人的问题（假设数据已排序）。
天真的算法可以遍历所有人，然后检查它是否属于给定的年龄组，因此可以线性扩展。 而二分搜索声称自己是对数可缩放的算法。 这意味着，如果问题的大小是平方的，那么解决问题的时间只会增加一倍。
朴素的算法可以遍历所有人，然后检查它是否属于给定的年龄组，因此可以线性扩展。 而二分搜索声称自己是对数可缩放的算法。 这意味着，如果问题的大小是平方的，那么解决问题的时间只会增加一倍。
假设要花 1000 秒才能找到某个年龄段的所有人口，则需要 1 秒。然后，对于 100 万人口，
* 二分搜索算法仅需 2 秒钟即可解决问题
* 天真的算法可能需要一百万秒，大约需要 12 天
* 朴素的算法可能需要一百万秒，大约需要 12 天
相同的二分搜索算法用于查找数字的平方根。
......@@ -219,6 +219,6 @@ DNA 是携带遗传信息的分子。 它们由较小的单位组成，用罗马
如果您不太了解算法，则将无法确定是否可以优化当前正在编写的代码。 您应该事先了解它们，并在可能和重要的情况下应用它们。
我们专门讨论了算法的可伸缩性。 一个软件系统由许多这样的算法组成。 优化其中任何一个都会带来更好的系统。
我们专门讨论了算法的可扩展性。 一个软件系统由许多这样的算法组成。 优化其中任何一个都会带来更好的系统。
但是，必须注意，这并不是使系统可伸缩的唯一方法。 例如，一种称为[分布式计算](https://en.wikipedia.org/wiki/Distributed_computing)的技术允许程序的独立部分同时运行到多台计算机，从而使其更具可伸缩性。
\ No newline at end of file
但是，必须注意，这并不是使系统可扩展的唯一方法。 例如，一种称为[分布式计算](https://en.wikipedia.org/wiki/Distributed_computing)的技术允许程序的独立部分同时运行到多台计算机，从而使其更具可扩展性。
\ No newline at end of file
docs/dsal/47.md
浏览文件 @ a14acbc3
......@@ -52,7 +52,7 @@ Adjacency matrix from a graph
如果您知道如何创建二维数组，那么您还将知道如何创建邻接矩阵。
[Python](#python-code)[Java](#java-code)[C](#c-code)[C+](#cpp-code)
```
# Adjacency Matrix representation in Python
......
docs/dsal/49.md
浏览文件 @ a14acbc3
......@@ -101,7 +101,7 @@ init() {
下面显示了深度优先搜索算法的代码和示例。 代码已经简化，因此我们可以专注于算法而不是其他细节。
[Python](#python-code)[Java](#java-code)[C](#c-code)[C+](#cpp-code)
```
# DFS algorithm in Python
......
docs/dsal/5.md
浏览文件 @ a14acbc3
......@@ -72,7 +72,7 @@ O(g(n)) = { f(n): there exist positive constants c and n0
* * *
## Ω表示法（Ω表示法）
## Ω 表示法（Ω表示法）
Ω表示算法运行时间的下限。 因此，它提供了算法的最佳情况复杂度。
......
docs/dsal/50.md
浏览文件 @ a14acbc3
......@@ -96,7 +96,7 @@ while Q is non-empty
广度优先搜索算法的代码示例如下。 代码已经简化，因此我们可以专注于算法而不是其他细节。
[Python](#python-code)[Java](#java-code)[C](#c-code)[C+](#cpp-code)
```
# BFS algorithm in Python
......
docs/dsal/53.md
浏览文件 @ a14acbc3
......@@ -236,7 +236,7 @@ end bubbleSort
### 优化的冒泡排序示例
[Python](#python-code)[Java](#java-code)[C](#c-code)[C+](#cpp-code)
```
# Optimized bubble sort in python
......
docs/dsal/57.md
浏览文件 @ a14acbc3
......@@ -112,7 +112,7 @@ return storeIndex + 1
## Python，Java 和 C/C++ 示例
[Python](#python-code)[Java](#java-code)[C](#c-code)[C+](#cpp-code)
```
# Quick sort in Python
......
docs/dsal/6.md
浏览文件 @ a14acbc3
# 大师定理
# 主定理
> 原文： [https://www.programiz.com/dsa/master-theorem](https://www.programiz.com/dsa/master-theorem)
......@@ -27,7 +27,7 @@ Here, a ≥ 1 and b > 1 are constants, and f(n) is an asymptotically positive fu
* * *
## 大师定理
## 主定理
如果`a ≥ 1`和`b > 1`是常数，并且`f(n)`是渐近正函数，则递归关系的时间复杂度由下式给出：
......@@ -53,7 +53,7 @@ where, T(n) has the following asymptotic bounds:
* * *
## 母定理的求解示例
## 主定理的求解示例
```
T(n) = 3T(n/2) + n2
......@@ -73,7 +73,7 @@ Thus, T(n) = f(n) = Θ(n2)
* * *
## 大师定理的局限性
## 主定理的局限性
在以下情况下，不能使用主定理：
......
docs/dsal/61.md
浏览文件 @ a14acbc3
......@@ -8,15 +8,15 @@
我们要排序的初始数字集存储在一个数组中，例如`[10, 3, 76, 34, 23, 32]`，排序后，我们得到一个排序数组`[3,10,23,32,34,76]`
堆排序的工作原理是将数组的元素可视化为一种特殊的完整二叉树，称为堆。
堆排序的工作原理是将数组的元素可视化为一种特殊的完全二叉树，称为堆。
前提条件是，您必须了解[完整的二叉树](/dsa/complete-binary-tree)和[堆数据结构](/dsa/heap-data-structure)。
前提条件是，您必须了解[完全二叉树](/dsa/complete-binary-tree)和[堆数据结构](/dsa/heap-data-structure)。
* * *
## 数组索引和树元素之间的关系
完整的二叉树具有一个有趣的属性，我们可以用来查找任何节点的子代和父代。
完全二叉树具有一个有趣的属性，我们可以用来查找任何节点的子代和父代。
如果数组中任何元素的索引为`i`，则索引`2i+1`中的元素将成为左子元素，而`2i+2`索引中的元素将成为右子元素。 同样，索引为`i`的任何元素的父级都由`(i-1)/2`的下限给出。
......@@ -75,7 +75,7 @@ Parent of 12 (position 1)
堆是一种特殊的基于树的数据结构。 如果满足以下条件，则据说二叉树遵循堆数据结构：
* 它是[完整的二叉树](/dsa/complete-binary-tree)
* 它是[完全二叉树](/dsa/complete-binary-tree)
* 树中的所有节点都遵循其大于子节点的属性，即最大元素位于根及其子节点且小于根，依此类推。 这样的堆称为最大堆。 相反，如果所有节点都小于其子节点，则称为最小堆
以下示例图显示了最大堆和最小堆。
......@@ -92,7 +92,7 @@ Max Heap and Min Heap
## 如何“堆肥”一棵树
从完整的二叉树开始，我们可以通过在堆的所有非叶元素上运行一个称为`heapify`的函数，将其修改为最大堆。
从完全二叉树开始，我们可以通过在堆的所有非叶元素上运行一个称为`heapify`的函数，将其修改为最大堆。
由于`heapify`使用递归，因此可能很难掌握。 因此，让我们首先考虑如何只用三个元素堆放一棵树。
......@@ -210,7 +210,7 @@ Steps to build max heap for heap sort
1. 由于树满足最大堆属性，因此最大的项存储在根节点上。
2. **交换**：删除根元素，并将其放在数组的末尾（第`n`个位置）。将树的最后一项（堆）放在空白处。
3. **删除**：将堆大小减小 1。
4. **堆化**：再次堆化根元素，以使我们的根元素最高。
4. **建堆**：再次建堆根元素，以使我们的根元素最高。
5. 重复此过程，直到对列表中的所有项目进行排序为止。
![procedures for implementing heap sort](img/1e7348280393ecb6c2ee05cc288fb211.png "We need to repeatedly exchange root element with last element and heapify the root element to implement heap sort ")
......@@ -475,7 +475,7 @@ Swap, Remove, and Heapify
对于所有情况（最佳情况，平均情况和最坏情况），堆排序都具有`O(nlog n)`时间复杂度。
让我们了解原因。 包含`n`个元素的完整二叉树的高度为`log n`
让我们了解原因。 包含`n`个元素的完全二叉树的高度为`log n`
如我们先前所见，要完全堆积其子树已经是最大堆的元素，我们需要继续比较该元素及其左，右子元素，并将其向下推，直到其两个子元素均小于其大小。
......
docs/dsal/68.md
浏览文件 @ a14acbc3
......@@ -86,7 +86,7 @@ Repeat until all the vertices have been visited
算法结束后，我们可以从目标顶点回溯到源顶点以找到路径。
最小优先级队列可用于以最小路径距离有效接收顶点。
最小优先队列可用于以最小路径距离有效接收顶点。
```
function dijkstra(G, S)
......
docs/dsal/7.md
浏览文件 @ a14acbc3
......@@ -64,7 +64,7 @@
* * *
## 复杂
## 复杂度
分治法的复杂度是使用[主定理](https://www.programiz.com/dsa/master-theorem)计算的。
......
docs/dsal/71.md
浏览文件 @ a14acbc3
......@@ -40,7 +40,7 @@ Initial string
2. 按频率升序对字符进行排序。 这些存储在优先级队列`Q`中。
2. 按频率升序对字符进行排序。 这些存储在优先队列`Q`中。
![huffman coding](img/56441afa8eb4e3ff2628d5d9ad39a6c2.png "characters sorted in according to the frequency")
......@@ -645,7 +645,7 @@ int main() {
基于每个唯一字符的频率进行编码的时间复杂度为`O(nlog n)`。
从优先级队列中提取最小频率发生`2*(n-1)`次，其复杂度为`O(log n)`。 因此，总体复杂度为`O(nlog n)`。
从优先队列中提取最小频率发生`2*(n-1)`次，其复杂度为`O(log n)`。 因此，总体复杂度为`O(nlog n)`。
* * *
......
docs/dsal/9.md
浏览文件 @ a14acbc3
......@@ -72,7 +72,7 @@ Stack Operations
最常见的栈实现是使用数组，但也可以使用列表来实现。
[Python](#python-code)[Java](#java-code)[C](#c-code)[C+](#cpp-code)
```
# Stack implementation in python
......
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或