fix typo

Author: facert

3.基本数据结构/3.10.什么是队列/README.md

@@ -6,6 +6,8 @@
 队列的最简单的例子是我们平时不时会参与的列。排队等待电影，在杂货店的收营台等待，在自助餐厅排队等待（这样我们可以弹出托盘栈）。行为良好的线或队列是有限制的，因为它只有一条路，只有一条出路。不能插队，也不能离开。你只有等待了一定的时间才能到前面。Figure 1 展示了一个简单的 Python 对象队列。
 
 ![3.10.什么是队列.figure1](assets/3.10.%E4%BB%80%E4%B9%88%E6%98%AF%E9%98%9F%E5%88%97.figure1.png)
+
+
 *Figure 1*
 
 计算机科学也有常见的队列示例。我们的计算机实验室有 30 台计算机与一台打印机联网。当学生想要打印时，他们的打印任务与正在等待的所有其他打印任务“一致”。第一个进入的任务是先完成。如果你是最后一个，你必须等待你前面的所有其他任务打印。我们将在后面更详细地探讨这个有趣的例子。

3.基本数据结构/3.11.队列抽象数据类型/README.md

@@ -10,5 +10,6 @@
 
 ![3.11.队列抽象数据类型.table1](assets/3.11.%E9%98%9F%E5%88%97%E6%8A%BD%E8%B1%A1%E6%95%B0%E6%8D%AE%E7%B1%BB%E5%9E%8B.table1.png)
 
+
 *Table 1*
 

3.基本数据结构/3.13.模拟：烫手山芋/README.md

@@ -6,11 +6,13 @@
 
 这个游戏相当于著名的约瑟夫问题，一个一世纪著名历史学家弗拉维奥·约瑟夫斯的传奇故事。故事讲的是，他和他的 39 个战友被罗马军队包围在洞中。他们决定宁愿死，也不成为罗马人的奴隶。他们围成一个圈，其中一人被指定为第一个人，顺时针报数到第七人，就将他杀死。约瑟夫斯是一个成功的数学家，他立即想出了应该坐到哪才能成为最后一人。最后，他加入了罗马的一方，而不是杀了自己。你可以找到这个故事的不同版本，有些说是每次报数 3 个人，有人说允许最后一个人逃跑。无论如何，思想是一样的。
 
-我们将模拟这个烫山芋的过程。我们的程序将输入名称列表和一个称为 num 常量用于报数。它将返回以 num 为单位重复报数后剩余的最后一个人的姓名。
+我们将模拟这个烫山芋的过程。我们的程序将输入名称列表和一个称为 num 常量用于报数。它将返回以 `num` 为单位重复报数后剩余的最后一个人的姓名。
 
 为了模拟这个圈，我们使用队列（见 Figure3）。假设拿着山芋的孩子在队列的前面。当拿到山芋的时候，这个孩子将先出列再入队列，把他放在队列的最后。经过 num 次的出队入队后，前面的孩子将被永久移除队列。并且另一个周期开始，继续此过程，直到只剩下一个名字（队列的大小为 1）。
 
 ![3.13.模拟：烫手山芋.figure3](assets/3.13.%E6%A8%A1%E6%8B%9F%EF%BC%9A%E7%83%AB%E6%89%8B%E5%B1%B1%E8%8A%8B.figure3.png)
+
+
 *Figure 3*
 
 ```` python
@@ -34,6 +36,6 @@ print(hotPotato(["Bill","David","Susan","Jane","Kent","Brad"],7))
 ````
 *Active code 1*
 
-请注意，在此示例中，计数常数的值大于列表中的名称数。这不是一个问题，因为队列像一个圈，计数会重新回到开始，直到达到计数值。另外，请注意，列表加载到队列中以使列表上的名字位于队列的前面。在这种情况下，Bill 是列表中的第一个项，因此他在队列的前面。
+请注意，在此示例中，计数常数的值大于列表中的名称数。这不是一个问题，因为队列像一个圈，计数会重新回到开始，直到达到计数值。另外，请注意，列表加载到队列中以使列表上的名字位于队列的前面。在这种情况下，`Bill` 是列表中的第一个项，因此他在队列的前面。
 
 

3.基本数据结构/3.14.模拟：打印机/README.md

@@ -5,24 +5,26 @@
 
 我们可以通过建立一个模拟实验来决定。我们将需要为学生，打印任务和打印机构建表现表示（Figure 4）。当学生提交打印任务时，我们将把他们添加到等待列表中，一个打印任务的队列。 当打印机完成任务时，它将检查队列，以检查是否有剩余的任务要处理。我们感兴趣的是学生等待他们的论文打印的平均时间。这等于任务在队列中等待的平均时间量。
 ![3.14.模拟：打印机.figure4](assets/3.14.%E6%A8%A1%E6%8B%9F%EF%BC%9A%E6%89%93%E5%8D%B0%E6%9C%BA.figure4.png)
+
+
 *Figure 4*
 
-为了建模这种情况，我们需要使用一些概率。例如，学生可以打印长度从1到20页的纸张。如果从1到20的每个长度同样可能，则可以通过使用1和20之间的随机数来模拟打印任务的实际长度。这意味着出现从1到20的任何长度的机会是平等的。
+为了为这种情况建模，我们需要使用一些概率。例如，学生可以打印长度从 1 到 20 页的纸张。如果从 1 到 20 的每个长度有同样的可能性，则可以通过使用 1 和 20 之间的随机数来模拟打印任务的实际长度。这意味着出现从 1 到 20 的任何长度的机会是平等的。
 
-如果实验室中有10个学生，每人打印两次，则平均每小时有20个打印任务。 在任何给定的秒，打印任务将被创建的机会是什么？ 回答这个问题的方法是考虑任务与时间的比率。 每小时20个任务意味着平均每180秒将有一个任务：
+如果实验室中有 10 个学生，每人打印两次，则平均每小时有 20 个打印任务。 在任何给定的秒，打印任务将被创建的机会是什么？ 回答这个问题的方法是考虑任务与时间的比率。每小时 20 个任务意味着平均每 180 秒将有一个任务：
 
 ![3.14.模拟：打印机.figure1](assets/3.14.%E6%A8%A1%E6%8B%9F%EF%BC%9A%E6%89%93%E5%8D%B0%E6%9C%BA.figure1.png)
 
-对于每一秒，我们可以通过生成1到180之间的随机数来模拟打印任务发生的机会。如果数字是180，我们说一个任务已经创建。请注意，可能会在一下子创建许多任务，或者需要等待一段时间才有任务。这就是模拟的本质。你想模拟真实的情况就需要尽可能接近一般参数。
+对于每一秒，我们可以通过生成 1 到 180 之间的随机数来模拟打印任务发生的机会。如果数字是 180，我们说一个任务已经创建。请注意，可能会在一下子创建许多任务，或者需要等待一段时间才有任务。这就是模拟的本质。你想模拟真实的情况就需要尽可能接近一般参数。
 
 ### 3.14.1.主要模拟步骤
 1. 创建打印任务的队列，每个任务都有个时间戳。队列启动的时候为空。
 2. 每秒（currentSecond）：
 
-    * 是否创建新的打印任务？如果是，将 currentSecond 作为时间戳添加到队列。
+    * 是否创建新的打印任务？如果是，将 `currentSecond` 作为时间戳添加到队列。
     * 如果打印机不忙并且有任务在等待
         * 从打印机队列中删除一个任务并将其分配给打印机
-        * 从 currentSecond 中减去时间戳，以计算该任务的等待时间。
+        * 从 `currentSecond` 中减去时间戳，以计算该任务的等待时间。
         * 将该任务的等待时间附件到列表中稍后处理。
         * 根据打印任务的页数，确定需要多少时间。
     * 打印机需要一秒打印，所以得从该任务的所需的等待时间减去一秒。
@@ -31,9 +33,9 @@
 
 
 ### 3.14.2 Python 实现
-为了设计此模拟，我们将为上述三个真实世界对象创建类：Printer, Task, PrintQueue
+为了设计此模拟，我们将为上述三个真实世界对象创建类：`Printer`, `Task`, `PrintQueue`
 
-Printer 类（Listing 2）需要跟踪它当前是否有任务。如果有，则它处于忙碌状态（13-17 行），并且可以从任务的页数计算所需的时间。构造函数允许初始化每分钟页面的配置，tick 方法将内部定时器递减直到打印机设置为空闲(11 行)
+`Printer` 类（Listing 2）需要跟踪它当前是否有任务。如果有，则它处于忙碌状态（13-17 行），并且可以从任务的页数计算所需的时间。构造函数允许初始化每分钟页面的配置，`tick` 方法将内部定时器递减直到打印机设置为空闲(11 行)
 
 ```` python
 class Printer:
@@ -60,7 +62,7 @@ class Printer:
 ````
 *Listing 2*
 
-Task 类（Listing 3）表示单个打印任务。创建任务时，随机数生成器将提供 1 到 20 页的长度。我们选择使用随机模块中的 randrange 函数。
+`Task` 类（Listing 3）表示单个打印任务。创建任务时，随机数生成器将提供 1 到 20 页的长度。我们选择使用随机模块中的 `randrange` 函数。
 
 ````
 >>> import random
@@ -70,7 +72,7 @@ Task 类（Listing 3）表示单个打印任务。创建任务时，随机数生
 8
 >>>
 ````
-每个任务还需要保存一个时间戳用于计算等待时间。此时间戳将表示任务被创建并放置到打印机队列中的时间。可以使用 waitTime 方法来检索在打印开始之前队列中花费的时间。
+每个任务还需要保存一个时间戳用于计算等待时间。此时间戳将表示任务被创建并放置到打印机队列中的时间。可以使用 `waitTime` 方法来检索在打印开始之前队列中花费的时间。
 
 ```` python
 import random
@@ -91,7 +93,7 @@ class Task:
 ````
 *Listing 3*
 
-Listing 4 实现了上述算法。PrintQueue 对象是我们现有队列 ADT 的一个实例。newPrintTask 决定是否创建一个新的打印任务。我们再次选择使用随机模块的 randrange 函数返回 1 到 180 之间的随机整数。打印任务每 180 秒到达一次。通过从随机整数（32 行）的范围中任意选择，我们可以模拟这个随机事件。模拟功能允许我们设置打印机的总时间和每分钟的页数。
+Listing 4 实现了上述算法。`PrintQueue` 对象是我们现有队列 ADT 的一个实例。`newPrintTask` 决定是否创建一个新的打印任务。我们再次选择使用随机模块的 `randrange` 函数返回 1 到 180 之间的随机整数。打印任务每 180 秒到达一次。通过从随机整数（32 行）的范围中任意选择，我们可以模拟这个随机事件。模拟功能允许我们设置打印机的总时间和每分钟的页数。
 
 ````
 from pythonds.basic.queue import Queue
@@ -134,7 +136,7 @@ for i in range(10):
 
 当我们运行模拟时，我们不应该担心每次的结果不同。这是由于随机数的概率性质决定的。 因为模拟的参数可以被调整，我们对调整后可能发生的趋势感兴趣。 这里有一些结果。
 
-首先，我们将使用每分钟五页的页面速率运行模拟60分钟（3,600秒）。 此外，我们将进行10次独立试验。记住，因为模拟使用随机数，每次运行将返回不同的结果。
+首先，我们将使用每分钟五页的页面速率运行模拟 60 分钟（3,600秒）。 此外，我们将进行 10 次独立试验。记住，因为模拟使用随机数，每次运行将返回不同的结果。
 
 ````
 >>>for i in range(10):
@@ -151,9 +153,9 @@ Average Wait  48.33 secs 0 tasks remaining.
 Average Wait  39.31 secs 3 tasks remaining.
 Average Wait 376.05 secs 1 tasks remaining.
 ````
-在运行 10 次实验后，我们可以看到，平均等待时间为 122.09 秒。 还可以看到平均等待时间有很大的变化，最小值为17.27秒，最大值为376.05秒。 你也可能注意到，只有两种情况所有任务都完成。
+在运行 10 次实验后，我们可以看到，平均等待时间为 122.09 秒。 还可以看到平均等待时间有很大的变化，最小值为 17.27 秒，最大值为 376.05 秒。 你也可能注意到，只有两种情况所有任务都完成。
 
-现在，我们将页面速率调整为每分钟10页，再次运行10次测试，页面速度更快，我们希望在一小时内完成更多的任务。
+现在，我们将页面速率调整为每分钟 10 页，再次运行 10 次测试，页面速度更快，我们希望在一小时内完成更多的任务。
 
 ````
 >>>for i in range(10):
@@ -175,15 +177,15 @@ Average Wait  18.17 secs 0 tasks remaining.
 
 我们试图回答一个问题，即当前打印机是否可以处理任务负载，如果它设置为打印更好的质量，较慢的页面速率。我们采用的方法是编写一个模拟打印任务作为各种页数和到达时间的随机事件的模拟。
 
-上面的输出显示，每分钟打印5页，平均等待时间从低的17秒到高的376秒（约6分钟）。使用更快的打印速率，低值为1秒，高值仅为28。此外，在 10 次运行中的8次，每分钟5页，打印任务在结束时仍在队列中等待。
+上面的输出显示，每分钟打印 5 页，平均等待时间从低的 17 秒到高的 376 秒（约 6 分钟）。使用更快的打印速率，低值为 1 秒，高值仅为 28。此外，在 10 次运行中的 8 次，每分钟 5 页，打印任务在结束时仍在队列中等待。
 
 因此，我们说减慢打印机的速度以获得更好的质量可能不是一个好主意。学生们不能等待他们的论文打印完，特别是当他们需要到下一个班级。六分钟的等待时间太长了。
 
 这种类型的模拟分析允许我们回答许多问题，通常被称为“如果”的问题。我们需要做的是改变模拟使用的参数，我们可以模拟任何数量。例如
-    * 如果入学人数增加，平均学生人数增加 20人 该怎么办？
+    * 如果入学人数增加，平均学生人数增加 20 人 该怎么办？
     * 如果是星期六，学生不需要上课怎么办？他们能负担得了吗？
-    * 如果平均打印任务的大小减少了，由于 Python是一个强大的语言，程序往往要短得多？
+    * 如果平均打印任务的大小减少了，由于 Python 是一个强大的语言，程序往往要短得多？
 
-这些问题都可以通过修改上述模拟来回答。然而，重要的是要记住，模拟有效取决于构建它的假设是没问题的。关于每小时打印任务的数量和每小时的学生数量的真实数据对于构建鲁棒的模拟是必要的。
+这些问题都可以通过修改上述模拟来回答。然而，重要的是要记住，模拟有效取决于构建它的假设是没问题的。关于每小时打印任务的数量和每小时的学生数量的真实数据对于构建鲁棒性的模拟是必要的。
 
 

3.基本数据结构/3.15.什么是Deque/README.md

@@ -5,6 +5,7 @@ deque（也称为双端队列）是与队列类似的项的有序集合。它有
 要注意，即使 deque 可以拥有栈和队列的许多特性，它不需要由那些数据结构强制的 LIFO 和 FIFO 排序。这取决于你如何持续添加和删除操作。
 ![3.15.什么是Deque.figure1](assets/3.15.%E4%BB%80%E4%B9%88%E6%98%AFDeque.figure1-1.png)
 
+
 *Figure 1*
 
 

3.基本数据结构/3.16.Deque抽象数据类型/README.md

@@ -13,6 +13,7 @@ deque 抽象数据类型由以下结构和操作定义。如上所述，deque 
 
 ![3.16.Deque抽象数据类型.table1](assets/3.16.Deque%E6%8A%BD%E8%B1%A1%E6%95%B0%E6%8D%AE%E7%B1%BB%E5%9E%8B.table1.png)
 
+
 *Table 1*
 
 

3.基本数据结构/3.17.Python实现Deque/README.md

@@ -29,6 +29,6 @@ class Deque:
 
 在 removeFront 中，我们使用 pop 方法从列表中删除最后一个元素。 但是，在removeRear中，pop(0)方法必须删除列表的第一个元素。同样，我们需要在 addRear 中使用insert方法（第12行），因为 append 方法在列表的末尾添加一个新元素。
 
-你可以看到许多与栈和队列中描述的 Python 代码相似之处。你也可能观察到，在这个实现中，从前面添加和删除项目是 O(1)，而从后面添加和删除是 O(n)。 考虑到添加和删除项目是出现的常见操作，这是可预期的。 同样，重要的是要确定我们知道在实现中前后都分配在哪里。
+你可以看到许多与栈和队列中描述的 Python 代码相似之处。你也可能观察到，在这个实现中，从前面添加和删除项是 O(1)，而从后面添加和删除是 O(n)。 考虑到添加和删除项是出现的常见操作，这是可预期的。 同样，重要的是要确定我们知道在实现中前后都分配在哪里。
 
 

3.基本数据结构/3.18.回文检查/README.md

@@ -1,10 +1,11 @@
 ## 3.18.回文检查
 
-使用 deque 数据结构可以容易地解决经典回文问题。 回文是一个字符串，读取首尾相同的字符，例如，`radar toot madam`。 我们想构造一个算法输入一个字符串，并检查它是否是一个回文。
+使用 deque 数据结构可以容易地解决经典回文问题。回文是一个字符串，读取首尾相同的字符，例如，`radar toot madam`。 我们想构造一个算法输入一个字符串，并检查它是否是一个回文。
 
 该问题的解决方案将使用 deque 来存储字符串的字符。我们从左到右处理字符串，并将每个字符添加到 deque 的尾部。在这一点上，deque 像一个普通的队列。然而，我们现在可以利用 deque 的双重功能。 deque 的首部保存字符串的第一个字符，deque 的尾部保存最后一个字符（见 Figure 2）。
 ![3.18.回文检查.figure2](assets/3.18.%E5%9B%9E%E6%96%87%E6%A3%80%E6%9F%A5.figure2.png)
 
+
 *Figure 2*
 
 我们可以直接删除并比较首尾字符，只有当它们匹配时才继续。如果可以持续匹配首尾字符，我们最终要么用完字符，要么留出大小为 1 的deque，取决于原始字符串的长度是偶数还是奇数。在任一情况下，字符串都是回文。 回文检查的完整功能在 ActiveCode 1 中。