From 9942291f2671066b14d20e7de47aa756cdb68ea3 Mon Sep 17 00:00:00 2001 From: mgna17 Date: Wed, 15 Feb 2017 12:52:06 +0800 Subject: [PATCH 1/4] =?UTF-8?q?2.3=20=E9=94=99=E5=88=AB=E5=AD=97=E4=BF=AE?= =?UTF-8?q?=E6=AD=A3?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../2.3.\345\244\247O\347\254\246\345\217\267/README.md" | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git "a/2.\347\256\227\346\263\225\345\210\206\346\236\220/2.3.\345\244\247O\347\254\246\345\217\267/README.md" "b/2.\347\256\227\346\263\225\345\210\206\346\236\220/2.3.\345\244\247O\347\254\246\345\217\267/README.md" index 00dbf4f..9a6d59b 100644 --- "a/2.\347\256\227\346\263\225\345\210\206\346\236\220/2.3.\345\244\247O\347\254\246\345\217\267/README.md" +++ "b/2.\347\256\227\346\263\225\345\210\206\346\236\220/2.3.\345\244\247O\347\254\246\345\217\267/README.md" @@ -3,7 +3,7 @@ 计算机科学家更喜欢将这种分析技术进一步。事实证明，操作步骤数量不如确定 \(T(n)\) 最主要的部分来的重要。换句话说，当问题规模变大时， \(T(n)\) 函数某些部分的分量会超过其他部分。函数的数量级表示了随着 n 的值增加而增加最快的那些部分。数量级通常称为大O符号，并写为 \(O(f(n))\)。它表示对计算中的实际步数的近似。函数 \(f(n)\) 提供了 \(T(n)\) 最主要部分的表示方法。 -在上述示例中，\(T(n)=1+n\)。当 n 变大时，常熟 1 对于最终结果变得越来越不重要。如果我们找的是 \(T(n)\) 的近似值，我们可以删除 1， 运行时间是\(O(n)\)。要注意，1 对于 \(T(n)\) 肯定是重要的。但是当 n 变大时，如果没有它，我们的近似也是准确的。 +在上述示例中，\(T(n)=1+n\)。当 n 变大时，常数 1 对于最终结果变得越来越不重要。如果我们找的是 \(T(n)\) 的近似值，我们可以删除 1， 运行时间是\(O(n)\)。要注意，1 对于 \(T(n)\) 肯定是重要的。但是当 n 变大时，如果没有它，我们的近似也是准确的。 另外一个示例，假设对于一些算法，确定的步数是 T(n)=5n^2 +27n+1005。当 n 很小时, 例如 1 或 2 ，常数 1005 似乎是函数的主要部分。然而，随着 n 变大，\(n^2\) 这项变得越来越重要。事实上，当 n 真的很大时，其他两项在它们确定最终结果中所起的作用变得不重要。当 n 变大时，为了近似\(T(n)\)，我们可以忽略其他项，只关注 \(5n^2 \)。系数 5 也变得不重要。我们说，\(T(n)\) 具有的数量级为 f(n)=n^2。 或者 O( n^2 ) 。 @@ -39,7 +39,7 @@ d = 33 ```` *Listing 2* -分配操作数分为四个项的总和。第一个项是常熟 3, 表示片段开始的三个赋值语句。第二项是 3n^2, 因为由于嵌套迭代，有三个语句执行 n^2 次。第三项是 2n, 两个语句迭代 n 次。最后，第四项是常数 1，表示最终赋值语句。最后得出 T(n)=3+3n^(2)+2n+1=3n^2 + 2n+4，通过查看指数，我们可以看到 n^2 项是显性的，因此这个代码段是 O(n^ 2 )。当 n 增大时，所有其他项以及主项上的系数都可以忽略。 +分配操作数分为四个项的总和。第一个项是常数 3, 表示片段开始的三个赋值语句。第二项是 3n^2, 因为由于嵌套迭代，有三个语句执行 n^2 次。第三项是 2n, 两个语句迭代 n 次。最后，第四项是常数 1，表示最终赋值语句。最后得出 T(n)=3+3n^(2)+2n+1=3n^2 + 2n+4，通过查看指数，我们可以看到 n^2 项是显性的，因此这个代码段是 O(n^ 2 )。当 n 增大时，所有其他项以及主项上的系数都可以忽略。 ![newplot2](assets/newplot2.png) *Figure 2* From 9bf72acfb8594fce8d3fad1d275cede0aa90bc7e Mon Sep 17 00:00:00 2001 From: facert Date: Wed, 15 Feb 2017 15:18:42 +0800 Subject: [PATCH 2/4] fix typo --- .../1.1.\347\233\256\346\240\207/README.md" | 2 +- .../README.md" | 6 ++++-- .../README.md" | 2 +- .../README.md" | 15 ++++++++------- .../README.md" | 6 +++--- 5 files changed, 17 insertions(+), 14 deletions(-) diff --git "a/1.\344\273\213\347\273\215/1.1.\347\233\256\346\240\207/README.md" "b/1.\344\273\213\347\273\215/1.1.\347\233\256\346\240\207/README.md" index e180dae..5297212 100644 --- "a/1.\344\273\213\347\273\215/1.1.\347\233\256\346\240\207/README.md" +++ "b/1.\344\273\213\347\273\215/1.1.\347\233\256\346\240\207/README.md" @@ -1,7 +1,7 @@ ## 1.1.目标 -* 回顾计算机科学的思想, 提高编程和解决问题的 能力。 +* 回顾计算机科学的思想, 提高编程和解决问题的能力。 * 理解抽象化以及它在解决问题过程中发挥的作用 * 理解和实现抽象数据类型的概念 * 回顾 Python 编程语言 diff --git "a/1.\344\273\213\347\273\215/1.5.\344\270\272\344\273\200\344\271\210\350\246\201\345\255\246\344\271\240\346\225\260\346\215\256\347\273\223\346\236\204\345\222\214\346\212\275\350\261\241\346\225\260\346\215\256\347\261\273\345\236\213/README.md" "b/1.\344\273\213\347\273\215/1.5.\344\270\272\344\273\200\344\271\210\350\246\201\345\255\246\344\271\240\346\225\260\346\215\256\347\273\223\346\236\204\345\222\214\346\212\275\350\261\241\346\225\260\346\215\256\347\261\273\345\236\213/README.md" index 3f2dd4e..eca0fff 100644 --- "a/1.\344\273\213\347\273\215/1.5.\344\270\272\344\273\200\344\271\210\350\246\201\345\255\246\344\271\240\346\225\260\346\215\256\347\273\223\346\236\204\345\222\214\346\212\275\350\261\241\346\225\260\346\215\256\347\261\273\345\236\213/README.md" +++ "b/1.\344\273\213\347\273\215/1.5.\344\270\272\344\273\200\344\271\210\350\246\201\345\255\246\344\271\240\346\225\260\346\215\256\347\273\223\346\236\204\345\222\214\346\212\275\350\261\241\346\225\260\346\215\256\347\261\273\345\236\213/README.md" @@ -2,10 +2,12 @@ 为了管理问题的复杂性和解决问题的过程，计算机科学家使用抽象使他们能够专注于 “大局” 而不会迷失在细节中。通过创建问题域的模型，我们能够利用更好和更有效的问题解决过程。这些模型允许我们以更加一致的方式描述我们的算法将要处理的数据。 -之前，我们将过程抽象称为隐藏特定函数的细节的过程，以允许用户或客户端在高层查看它。我们现在将注意力转向类似的思想，即数据抽象的思想。`抽象数据类型`（有时缩写为 ADT ）是对我们如何查看数据和允许的操作的逻辑描述，而不y用考虑如何实现它们。这意味着我们只关心数据表示什么，而不关心它最终将如何构造。通过提供这种级别的抽象，我们围绕数据创建一个封装。通过封装实现细节，我们将它们从用户的视图中隐藏。这称为信息隐藏。 +之前，我们将过程抽象称为隐藏特定函数的细节的过程，以允许用户或客户端在高层查看它。我们现在将注意力转向类似的思想，即数据抽象的思想。`抽象数据类型`（有时缩写为 ADT ）是对我们如何查看数据和允许的操作的逻辑描述，而不用考虑如何实现它们。这意味着我们只关心数据表示什么，而不关心它最终将如何构造。通过提供这种级别的抽象，我们围绕数据创建一个封装。通过封装实现细节，我们将它们从用户的视图中隐藏。这称为信息隐藏。 -Figure 2 展示了抽象数据类型是什么以及如何操作。用户与接口交互，使用抽象数据类型指定的操作。抽象数据类型是用户与之交互的 shell。实现是隐藏在更深的底层。用户不关心实现的细节。 +Figure 2 展示了抽象数据类型是什么以及如何操作。用户与接口交互，使用抽象数据类型指定的操作。抽象数据类型是用户与之交互的 shell。实现隐藏在更深的底层。用户不关心实现的细节。 ![1.5.为什么要学习数据结构和抽象数据类型.figure2](assets/1.5.%E4%B8%BA%E4%BB%80%E4%B9%88%E8%A6%81%E5%AD%A6%E4%B9%A0%E6%95%B0%E6%8D%AE%E7%BB%93%E6%9E%84%E5%92%8C%E6%8A%BD%E8%B1%A1%E6%95%B0%E6%8D%AE%E7%B1%BB%E5%9E%8B.figure2.png) + + *Figure 2* 抽象数据类型（通常称为数据结构）的实现将要求我们使用一些程序构建和原始数据类型的集合来提供数据的物理视图。 正如我们前面讨论的，这两个视角的分离将允许我们将问题定义复杂的数据模型，而不给出关于模型如何实际构建的细节。 这提供了独立于实现的数据视图。由于通常有许多不同的方法来实现抽象数据类型，所以这种实现独立性允许程序员在不改变数据的用户与其交互的方式的情况下切换实现的细节。 用户可以继续专注于解决问题的过程。 diff --git "a/1.\344\273\213\347\273\215/1.6.\344\270\272\344\273\200\344\271\210\350\246\201\345\255\246\344\271\240\347\256\227\346\263\225/README.md" "b/1.\344\273\213\347\273\215/1.6.\344\270\272\344\273\200\344\271\210\350\246\201\345\255\246\344\271\240\347\256\227\346\263\225/README.md" index 8fac8b7..f3e2380 100644 --- "a/1.\344\273\213\347\273\215/1.6.\344\270\272\344\273\200\344\271\210\350\246\201\345\255\246\344\271\240\347\256\227\346\263\225/README.md" +++ "b/1.\344\273\213\347\273\215/1.6.\344\270\272\344\273\200\344\271\210\350\246\201\345\255\246\344\271\240\347\256\227\346\263\225/README.md" @@ -1,6 +1,6 @@ ## 1.6.为什么要学习算法 -计算机科学家通过经验学习。我们通过看别人解决问题和自己解决问题来学习。接触不同的问题解决技术，看不同的算法设计有助于我们承担下一个具有挑战性的问题。通过思考许多不同的算法，我们可以开始开发模式识别，以便下一次出现类似的问题时，我们能够更好地解决它。 +计算机科学家经常通过经验学习。我们通过看别人解决问题和自己解决问题来学习。接触不同的问题解决技术，看不同的算法设计有助于我们承担下一个具有挑战性的问题。通过思考许多不同的算法，我们可以开始开发模式识别，以便下一次出现类似的问题时，我们能够更好地解决它。 算法通常彼此完全不同。考虑前面看到的 `sqrt` 的例子。完全可能的是，存在许多不同的方式来实现细节以计算平方根函数。一种算法可以使用比另一种更少的资源。一个算法可能需要 10 倍的时间来返回结果。我们想要一些方法来比较这两个解决方案。即使他们都工作，一个可能比另一个“更好”。我们建议使用一个更高效，或者一个只是工作更快或使用更少的内存的算法。当我们研究算法时，我们可以学习分析技术，允许我们仅仅根据自己的特征而不是用于实现它们的程序或计算机的特征来比较和对比解决方案。 diff --git "a/2.\347\256\227\346\263\225\345\210\206\346\236\220/2.2.\344\273\200\344\271\210\346\230\257\347\256\227\346\263\225\345\210\206\346\236\220/README.md" "b/2.\347\256\227\346\263\225\345\210\206\346\236\220/2.2.\344\273\200\344\271\210\346\230\257\347\256\227\346\263\225\345\210\206\346\236\220/README.md" index 385b891..7501973 100644 --- "a/2.\347\256\227\346\263\225\345\210\206\346\236\220/2.2.\344\273\200\344\271\210\346\230\257\347\256\227\346\263\225\345\210\206\346\236\220/README.md" +++ "b/2.\347\256\227\346\263\225\345\210\206\346\236\220/2.2.\344\273\200\344\271\210\346\230\257\347\256\227\346\263\225\345\210\206\346\236\220/README.md" @@ -30,13 +30,12 @@ print(foo(10)) ```` *ActiveCode 2* -先前我们提出一个问题是哪个函数更好，答案取决于你的标准。如果你关注可读性，函数 sumOfN 肯定比 foo 好。事实上，你可能已经在你介绍编程的课程中看到过很多例子，他们的目标之一就是帮助你编写易于阅读和理解的程序。在本课程中，我们对如何表示算法感兴趣（当然我们希望你继续努力编写可读的，易于理解的代码）。 +先前我们提出一个问题是哪个函数更好，答案取决于你的标准。如果你关注可读性，函数 sumOfN 肯定比 foo 好。事实上，你可能已经在介绍编程的课程中看到过很多例子，他们的目标之一就是帮助你编写易于阅读和理解的程序。在本课程中，我们对如何表示算法感兴趣（当然我们希望你继续努力编写可读的，易于理解的代码）。 -算法分析涉及基于每个算法使用的计算资源量来比较算法。我们比较两个算法，说一个比另一个算法好的原因在于它在使用资源方面更有效率，或者仅仅使用的资源更少。从这个角度来看，上面两个函数看起来很相似。它们都使用基本相同的算法来求解问题。在这点上，更重要的是我们如何考虑真正意义上的计算资源。有两个方法，一种是考虑算法所需的空间或者内存。所需的空间通常由问题本身决定。但是，算法会有一些特殊的空间需求，我们可以细细观察解释这些变动。 +算法分析涉及基于每个算法使用的计算资源量来比较算法。我们比较两个算法，说一个比另一个算法好的原因在于它在使用资源方面更有效率，或者仅仅使用的资源更少。从这个角度来看，上面两个函数看起来很相似。它们都使用基本相同的算法来求解问题。在这点上，更重要的是我们如何考虑真正意义上的计算资源。有两种方法，一种是考虑算法所需的空间或者内存。所需的空间通常由问题本身决定。但是，算法会有一些特殊的空间需求，我们可以细细观察解释这些变动。 作为空间需求的一种替代方法，我们可以基于时间来分析算法。这种度量有时被称为算法的‘执行时间’或’运行时间‘。我们可以通过基准分析来测量函数 SumOfN 的执行时间。这意味着我们将记录程序计算所需的实际时间。在 Python 中，我们可以通过记录相对于系统的开始时间和结束时间来对函数进行基准测试。在时间模块中有一个时间函数，它将返回系统时钟时间（以秒为单位）。通过在开始和结束的时候调用时间函数，然后计算差异，就可以得到一个精确地秒数（大多数情况下）。 -#### Listing 1 ```` python import time @@ -52,8 +51,10 @@ def sumOfN2(n): return theSum,end-start ```` +*Listing 1* -Listing 1 嵌入了时间函数，函数返回一个包含结果和消耗时间的数组。如果我们 执行这个函数 5 次，每次计算前 10,000 个整数的和，将得到一下结果： + +Listing 1 嵌入了时间函数，函数返回一个包含结果和消耗时间的数组。如果我们执行这个函数 5 次，每次计算前 10,000 个整数的和，将得到如下结果： ```` >>>for i in range(5): @@ -102,7 +103,7 @@ print(sumOfN3(10)) ```` *ActiveCode 3* -如果我们对 sumOfN3 做同样的基准测试，使用 5 个不同的 n(10,000, 100,000, 1,000,000, 100,000,000), 我们得到如下结果 +如果我们对 sumOfN3 做同样的基准测试，使用 5 个不同的 n `(10,000, 100,000, 1,000,000, 100,000,000)`, 我们得到如下结果 ```` python Sum is 50005000 required 0.00000095 seconds @@ -112,9 +113,9 @@ Sum is 50000005000000 required 0.00000095 seconds Sum is 5000000050000000 required 0.00000119 seconds ```` -有两点关注下，首先上面记录的时间比上面任何例子都短， 另外他们的时间和 n 无关， 看来 sumOfN3 几乎不受 n 的影响。 +有两点关注下，首先上面记录的时间比上面任何例子都短，另外他们的时间和 n 无关，看来 sumOfN3 几乎不受 n 的影响。 -但是这个基准测试告诉我们什么？我们可以直观的看到用迭代的方案在做更多的工作，因为一些步骤重复。这可能是它需要更长时间的原因。此外，迭代所需时间随着 n 递增。还有个问题，如果我们在不同计算机上或者使用不用的编程语言运行这个函数，我们也可能得到不同的结果。如果用老计算机，可能需要更长时间才能执行完 sumOfN3。 +但是这个基准测试告诉我们什么？我们可以直观的看到用迭代的方案需要做更多的工作，因为一些步骤重复。这可能是它需要更长时间的原因。此外，迭代所需时间随着 n 递增。还有个问题，如果我们在不同计算机上或者使用不用的编程语言运行这个函数，我们也可能得到不同的结果。如果用老计算机，可能需要更长时间才能执行完 sumOfN3。 我们需要一个更好的方法来表征这些算法的执行时间。基准测试计算的是执行的实际时间。它并不真正提供给我们一个有用的测量，因为它取决于特定的机器，程序，时间，编译器和编程语言。 相反，我们希望具有独立于所使用的程序或计算机的特性。不过基准度量将有助于单独判断算法，并且可以用于在方案之间比较算法。 diff --git "a/2.\347\256\227\346\263\225\345\210\206\346\236\220/2.3.\345\244\247O\347\254\246\345\217\267/README.md" "b/2.\347\256\227\346\263\225\345\210\206\346\236\220/2.3.\345\244\247O\347\254\246\345\217\267/README.md" index 00dbf4f..25b1281 100644 --- "a/2.\347\256\227\346\263\225\345\210\206\346\236\220/2.3.\345\244\247O\347\254\246\345\217\267/README.md" +++ "b/2.\347\256\227\346\263\225\345\210\206\346\236\220/2.3.\345\244\247O\347\254\246\345\217\267/README.md" @@ -1,9 +1,9 @@ ## 2.3.大O符号 -当我们试图通过执行时间来表征算法的效率时，并且独立于任何特定程序或计算机，重要的是量化算法需要的操作或者步骤的数量。选择适当的基本计算单位是个复杂的问题，并且将取决于如何实现算法。对于先前的求和算法，一个比较好的基本计算单位是对执行语句进行计数。在 sumOfN 中，赋值语句的计数为 1 (\(theSum = 0\)) 加上 n 的值（我们执行 \(theSum=theSum+i\) 的次数）。我们通过函数 T 表示 \(T(n)=1 + n\)。参数 n 通常称为‘问题的规模’，我们称作 ‘T(n) 是解决问题大小为 n 所花费的时间，即 1+n 步长’。在上面的求和函数中，使用 n 来表示问题大小是有意义的。我们可以说，100,000 个整数和比 1000 个问题规模大。因此，所需时间也更长。我们的目标是表示出算法的执行时间是如何相对问题规模大小而改变的。 +当我们试图通过执行时间来表征算法的效率时，并且独立于任何特定程序或计算机，重要的是量化算法需要的操作或者步骤的数量。选择适当的基本计算单位是个复杂的问题，并且将取决于如何实现算法。对于先前的求和算法，一个比较好的基本计算单位是对执行语句进行计数。在 sumOfN 中，赋值语句的计数为 1 `(theSum = 0)` 加上 n 的值（我们执行 `theSum=theSum+i` 的次数）。我们通过函数 T 表示 `T(n)=1 + n`。参数 n 通常称为‘问题的规模’，我们称作 ‘T(n) 是解决问题大小为 n 所花费的时间，即 1+n 步长’。在上面的求和函数中，使用 n 来表示问题大小是有意义的。我们可以说，100,000 个整数和比 1000 个问题规模大。因此，所需时间也更长。我们的目标是表示出算法的执行时间是如何相对问题规模大小而改变的。 -计算机科学家更喜欢将这种分析技术进一步。事实证明，操作步骤数量不如确定 \(T(n)\) 最主要的部分来的重要。换句话说，当问题规模变大时， \(T(n)\) 函数某些部分的分量会超过其他部分。函数的数量级表示了随着 n 的值增加而增加最快的那些部分。数量级通常称为大O符号，并写为 \(O(f(n))\)。它表示对计算中的实际步数的近似。函数 \(f(n)\) 提供了 \(T(n)\) 最主要部分的表示方法。 +计算机科学家更喜欢将这种分析技术进一步扩展。事实证明，操作步骤数量不如确定 T(n) 最主要的部分来的重要。换句话说，当问题规模变大时，T(n) 函数某些部分的分量会超过其他部分。函数的数量级表示了随着 n 的值增加而增加最快的那些部分。数量级通常称为大O符号，写为 `O(f(n))`。它表示对计算中的实际步数的近似。函数 f(n) 提供了 T(n) 最主要部分的表示方法。 -在上述示例中，\(T(n)=1+n\)。当 n 变大时，常熟 1 对于最终结果变得越来越不重要。如果我们找的是 \(T(n)\) 的近似值，我们可以删除 1， 运行时间是\(O(n)\)。要注意，1 对于 \(T(n)\) 肯定是重要的。但是当 n 变大时，如果没有它，我们的近似也是准确的。 +在上述示例中，`T(n)=1+n`。当 n 变大时，常熟 1 对于最终结果变得越来越不重要。如果我们找的是 \(T(n)\) 的近似值，我们可以删除 1， 运行时间是\(O(n)\)。要注意，1 对于 \(T(n)\) 肯定是重要的。但是当 n 变大时，如果没有它，我们的近似也是准确的。 另外一个示例，假设对于一些算法，确定的步数是 T(n)=5n^2 +27n+1005。当 n 很小时, 例如 1 或 2 ，常数 1005 似乎是函数的主要部分。然而，随着 n 变大，\(n^2\) 这项变得越来越重要。事实上，当 n 真的很大时，其他两项在它们确定最终结果中所起的作用变得不重要。当 n 变大时，为了近似\(T(n)\)，我们可以忽略其他项，只关注 \(5n^2 \)。系数 5 也变得不重要。我们说，\(T(n)\) 具有的数量级为 f(n)=n^2。 或者 O( n^2 ) 。 From 728ca68183b607e526559b4a089ec5dbcbc6bb91 Mon Sep 17 00:00:00 2001 From: facert Date: Wed, 15 Feb 2017 16:03:10 +0800 Subject: [PATCH 3/4] fix typo --- .../README.md" | 16 ++++++---------- .../README.md" | 16 ++++++++-------- .../2.6.\345\210\227\350\241\250/README.md" | 12 ++++++------ .../2.7.\345\255\227\345\205\270/README.md" | 6 +++--- 4 files changed, 23 insertions(+), 27 deletions(-) diff --git "a/2.\347\256\227\346\263\225\345\210\206\346\236\220/2.3.\345\244\247O\347\254\246\345\217\267/README.md" "b/2.\347\256\227\346\263\225\345\210\206\346\236\220/2.3.\345\244\247O\347\254\246\345\217\267/README.md" index 8f76fb5..f8a7bb5 100644 --- "a/2.\347\256\227\346\263\225\345\210\206\346\236\220/2.3.\345\244\247O\347\254\246\345\217\267/README.md" +++ "b/2.\347\256\227\346\263\225\345\210\206\346\236\220/2.3.\345\244\247O\347\254\246\345\217\267/README.md" @@ -3,16 +3,12 @@ 计算机科学家更喜欢将这种分析技术进一步扩展。事实证明，操作步骤数量不如确定 T(n) 最主要的部分来的重要。换句话说，当问题规模变大时，T(n) 函数某些部分的分量会超过其他部分。函数的数量级表示了随着 n 的值增加而增加最快的那些部分。数量级通常称为大O符号，写为 `O(f(n))`。它表示对计算中的实际步数的近似。函数 f(n) 提供了 T(n) 最主要部分的表示方法。 -<<<<<<< HEAD -在上述示例中，`T(n)=1+n`。当 n 变大时，常熟 1 对于最终结果变得越来越不重要。如果我们找的是 \(T(n)\) 的近似值，我们可以删除 1， 运行时间是\(O(n)\)。要注意，1 对于 \(T(n)\) 肯定是重要的。但是当 n 变大时，如果没有它，我们的近似也是准确的。 -======= -在上述示例中，\(T(n)=1+n\)。当 n 变大时，常数 1 对于最终结果变得越来越不重要。如果我们找的是 \(T(n)\) 的近似值，我们可以删除 1， 运行时间是\(O(n)\)。要注意，1 对于 \(T(n)\) 肯定是重要的。但是当 n 变大时，如果没有它，我们的近似也是准确的。 ->>>>>>> e3ac537a1fb4277537aa0925e0371ff7f6e35aa7 +在上述示例中，`T(n)=1+n`。当 n 变大时，常数 1 对于最终结果变得越来越不重要。如果我们找的是 T(n) 的近似值，我们可以删除 1， 运行时间是 O(n)。要注意，1 对于 T(n) 肯定是重要的。但是当 n 变大时，如果没有它，我们的近似也是准确的。 -另外一个示例，假设对于一些算法，确定的步数是 T(n)=5n^2 +27n+1005。当 n 很小时, 例如 1 或 2 ，常数 1005 似乎是函数的主要部分。然而，随着 n 变大，\(n^2\) 这项变得越来越重要。事实上，当 n 真的很大时，其他两项在它们确定最终结果中所起的作用变得不重要。当 n 变大时，为了近似\(T(n)\)，我们可以忽略其他项，只关注 \(5n^2 \)。系数 5 也变得不重要。我们说，\(T(n)\) 具有的数量级为 f(n)=n^2。 或者 O( n^2 ) 。 +另外一个示例，假设对于一些算法，确定的步数是 `T(n)=5n^2 +27n+1005`。当 n 很小时, 例如 1 或 2 ，常数 1005 似乎是函数的主要部分。然而，随着 n 变大，n^2 这项变得越来越重要。事实上，当 n 真的很大时，其他两项在它们确定最终结果中所起的作用变得不重要。当 n 变大时，为了近似 T(n)，我们可以忽略其他项，只关注 5n^2 。系数 5 也变得不重要。我们说，T(n) 具有的数量级为 f(n)=n^2。 或者 O( n^2 ) 。 -虽然我们没有在求和示例中看到这一点，但有时算法的性能取决于数据的确切值，而不是问题规模的大小。对于这种类型的算法，我们需要根据最佳情况，最坏情况或平均情况来表征它们的性能。最坏情况是指算法性能特别差的特定数据集。而相同的算法不同数据集可能具有非常好的性能。大多数情况下，算法执行效率处在两个极端之间（平均情况）。对于计算机科学家而已，重要的是了解这些区别，使它们不被某一个特定的情况误导。 +虽然我们没有在求和示例中看到这一点，但有时算法的性能取决于数据的确切值，而不是问题规模的大小。对于这种类型的算法，我们需要根据最佳情况，最坏情况或平均情况来表征它们的性能。最坏情况是指算法性能特别差的特定数据集。而相同的算法不同数据集可能具有非常好的性能。大多数情况下，算法执行效率处在两个极端之间（平均情况）。对于计算机科学家而言，重要的是了解这些区别，使它们不被某一个特定的情况误导。 当你学习算法时，一些常见的数量级函数将会反复出现。见 Table 1。为了确定这些函数中哪个是最主要的部分，我们需要看到当 n 变大的时候它们如何相互比较。 @@ -20,7 +16,7 @@ *Table 1* -Figure 1 表示了 Table 1 中的函数图。注意，当 n 很小时，函数彼此间不是很好的定义。很难判断哪个是主导的。随着 n 的增长，就有一个很明确的关系，很容易看出它们之间的大小关系。 +Figure 1 表示了 Table 1 中的函数图。注意，当 n 很小时，函数彼此间不能很好的定义。很难判断哪个是主导的。随着 n 的增长，就有一个很明确的关系，很容易看出它们之间的大小关系。 ![newplot](assets/newplot.png) *Figure 1* @@ -43,11 +39,11 @@ d = 33 ```` *Listing 2* -分配操作数分为四个项的总和。第一个项是常数 3, 表示片段开始的三个赋值语句。第二项是 3n^2, 因为由于嵌套迭代，有三个语句执行 n^2 次。第三项是 2n, 两个语句迭代 n 次。最后，第四项是常数 1，表示最终赋值语句。最后得出 T(n)=3+3n^(2)+2n+1=3n^2 + 2n+4，通过查看指数，我们可以看到 n^2 项是显性的，因此这个代码段是 O(n^ 2 )。当 n 增大时，所有其他项以及主项上的系数都可以忽略。 +分配操作数分为四个项的总和。第一个项是常数 3, 表示片段开始的三个赋值语句。第二项是 3n^2, 因为由于嵌套迭代，有三个语句执行 n^2 次。第三项是 2n, 两个语句迭代 n 次。最后，第四项是常数 1，表示最终赋值语句。最后得出 T(n)=3+3n^2 +2n+1=3n^2 + 2n+4，通过查看指数，我们可以看到 n^2 项是显性的，因此这个代码段是 O(n^ 2 )。当 n 增大时，所有其他项以及主项上的系数都可以忽略。 ![newplot2](assets/newplot2.png) *Figure 2* -Figure 2 展示了一些常用的 大O 函数，跟上面讨论的 T(n) 函数比较，一开始的时候，T(n) 大于 三次函数，后来随着 n 的增长，三次函数超过了 T(n)。T(n) 随着二次函数继续增长。 +Figure 2 展示了一些常用的 大O 函数，跟上面讨论的 T(n) 函数比较，一开始的时候，T(n) 大于三次函数，后来随着 n 的增长，三次函数超过了 T(n)。T(n) 随着二次函数继续增长。 diff --git "a/2.\347\256\227\346\263\225\345\210\206\346\236\220/2.4.\344\270\200\344\270\252\345\233\236\346\226\207\345\255\227\347\254\246\344\270\262\346\243\200\346\237\245\347\232\204\344\276\213\345\255\220/README.md" "b/2.\347\256\227\346\263\225\345\210\206\346\236\220/2.4.\344\270\200\344\270\252\345\233\236\346\226\207\345\255\227\347\254\246\344\270\262\346\243\200\346\237\245\347\232\204\344\276\213\345\255\220/README.md" index e93c52d..1545c42 100644 --- "a/2.\347\256\227\346\263\225\345\210\206\346\236\220/2.4.\344\270\200\344\270\252\345\233\236\346\226\207\345\255\227\347\254\246\344\270\262\346\243\200\346\237\245\347\232\204\344\276\213\345\255\220/README.md" +++ "b/2.\347\256\227\346\263\225\345\210\206\346\236\220/2.4.\344\270\200\344\270\252\345\233\236\346\226\207\345\255\227\347\254\246\344\270\262\346\243\200\346\237\245\347\232\204\344\276\213\345\255\220/README.md" @@ -3,7 +3,7 @@ 显示不同量级的算法的一个很好的例子是字符串的回文检查。一个字符串是另一个字符串的回文。如果第二个字符串只是第一个的重新排列，例如，'heart' 和 'earth' 就是回文字符串。'python' 和 'typhon' 也是。为了简单起见，我们假设所讨论的两个字符串具有相等的长度，并且他们由 26 个小写字母集合组成。我们的目标是写一个布尔函数，它将两个字符串做参数并返回它们是不是回文。 ### 2.4.1.解法1:检查 -我们对回文问题的第一个解法是检查第一个字符串是不是出现在第二个字符串中。如果可以检验到每一个字符，那两个字符串一定是回文。可以通过用 None 替换字符来完成检查。但是，由于 Python 字符串是不可变的，所以第一步是将第二个字符串转换为列表。第一个字符串中的每个字符可以通过检查在第二个列表中检查元素是否存在，如果存在，替换成None。见 ActiveCode1 +我们对回文问题的第一个解法是检查第一个字符串是不是出现在第二个字符串中。如果可以检验到每一个字符，那两个字符串一定是回文。可以通过用 None 替换字符来完成检查。但是，由于 Python 字符串是不可变的，所以第一步是将第二个字符串转换为列表。第一个字符串中的每个字符可以通过检查在第二个列表中检查元素是否存在，如果存在，替换成 None。见 ActiveCode1 ```` def anagramSolution1(s1,s2): @@ -34,14 +34,14 @@ print(anagramSolution1('abcd','dcba')) ```` *ActiveCode1* -为了分析这个算法，我们注意到 s1 的每个字符都会在 s2 进行最多 n 个字符的迭代。列表中的 n 个位置将被访问一次来匹配来自 s1 的字符。访问次数可以写成 1 到 n 整数的和，可以写成 +为了分析这个算法，我们注意到 s1 的每个字符都会在 s2 中进行最多 n 个字符的迭代。s2 列表中的 n 个位置将被访问一次来匹配来自 s1 的字符。访问次数可以写成 1 到 n 整数的和，可以写成 ![2.4.1 求和](assets/2.4.1%20%E6%B1%82%E5%92%8C.png) 当 n 变大，n^2 这项占据主导，1/2 可以忽略。所以这个算法复杂度为 O(n^2 )。 ### 2.4.2.解法2:排序和比较 -另一个解决方案是利用这么一个事实，即使 s1,s2 不同，它们只有由完全相同的字符组成，它们才是回文。所以，如果我们按照字母顺序排列每个字符串，从 a 到 z, 如果两个字符串相同，则这两个字符串为回文。见 ActiveCode2。 +另一个解决方案是利用这么一个事实，即使 s1,s2 不同，它们只有由完全相同的字符组成，它们才是回文。所以，如果我们按照字母顺序排列每个字符串，从 a 到 z，如果两个字符串相同，则这两个字符串为回文。见 ActiveCode2。 ```` def anagramSolution2(s1,s2): @@ -66,17 +66,17 @@ print(anagramSolution2('abcde','edcba')) ```` *ActiveCode2* -首先你可能认为这个算法是 O(n), 因为只有一个简单的迭代来比较排序后的n个字符。但是，调用 Python 排序不是没有成本。正如我们将在后面的章节中看到的，排序通常是 O(n^2)或 O(nlogn)。所以排序操作比迭代花费更多。最后该算法跟排序过程有同样的量级。 +首先你可能认为这个算法是 O(n)，因为只有一个简单的迭代来比较排序后的 n 个字符。但是，调用 Python 排序不是没有成本。正如我们将在后面的章节中看到的，排序通常是 O(n^2 ) 或 O(nlogn)。所以排序操作比迭代花费更多。最后该算法跟排序过程有同样的量级。 ### 2.4.3.解法3: 穷举法 -解决这类问题的强力方法是穷举所有可能性。对于回文检测，我们可以生成所有 s1 的所有回文字符串列表，然后查看是不是有 s2。这种方法有一点困难。当 s1 生成所有可能的字符串时，第一个位置有 n 种可能，第二个位置有 n-1 种，第三个位置有 n-3 种，等等。总数为 n∗(n−1)∗(n−2)∗...∗3∗2∗1n∗(n−1)∗(n−2)∗...∗3∗2∗1， 即 n!。虽然一些字符串可能是重复的，程序也不可能提前知道这样，所以他仍然会生成 n! 个字符串。 +解决这类问题的强力方法是穷举所有可能性。对于回文检测，我们可以生成 s1 的所有回文字符串列表，然后查看是不是有 s2。这种方法有一点困难。当 s1 生成所有可能的字符串时，第一个位置有 n 种可能，第二个位置有 n-1 种，第三个位置有 n-3 种，等等。总数为 n∗(n−1)∗(n−2)∗...∗3∗2∗1n∗(n−1)∗(n−2)∗...∗3∗2∗1， 即 n!。虽然一些字符串可能是重复的，程序也不可能提前知道这样，所以他仍然会生成 n! 个字符串。 -事实证明，n! 比 n^2 增长还快，事实上，如果 s1 有 20个字符长，则将有 20! = 2,432,902,008,176,640,000 个字符串产生。如果我们每秒处理一种可能字符串，那么需要 77,146,816,596 才能过完整个列表。所以这不是很好的解决方案。 +事实证明，n! 比 n^2 增长还快，事实上，如果 s1 有 20个字符长，则将有 20! = 2,432,902,008,176,640,000 个字符串产生。如果我们每秒处理一种可能字符串，那么需要 77,146,816,596 年才能过完整个列表。所以这不是很好的解决方案。 ### 2.4.4.解法4: 计数和比较 -我们最终解决回文的方法是利用两个回文字符串具有相同的 a, b, c等等的事实。我们首先计算的是每个字母出现的次数。由于有 26 个可能的字符，我们就用 26 个列表，每个可能的字符一个。每次看到一个特定的字符，就增加该位置的计数器。最后如果两个列表的计数器一样，则字符串为回文字符串。见 ActiveCode 3 +我们最终解决回文的方法是利用两个回文字符串具有相同的 a, b, c 等等的事实。我们首先计算的是每个字母出现的次数。由于有 26 个可能的字符，我们就用 26 个列表，每个可能的字符一个。每次看到一个特定的字符，就增加该位置的计数器。最后如果两个列表的计数器一样，则字符串为回文字符串。见 ActiveCode 3 ```` python def anagramSolution4(s1,s2): @@ -106,7 +106,7 @@ print(anagramSolution4('apple','pleap')) ```` *ActiveCode 3* -同样，这个方案有多个迭代，但是和第一个解法不一样，它不是嵌套的。两个迭代都是 n, 第三个迭代，比较两个计数列表，需要 26个步，因为有 26个字母。一共 T(n)=2n+26T(n)=2n+26，即 O(n)，我们找到了一个线性量级的算法解决这个问题。 +同样，这个方案有多个迭代，但是和第一个解法不一样，它不是嵌套的。两个迭代都是 n, 第三个迭代，比较两个计数列表，需要 26 步，因为有 26个字母。一共 T(n)=2n+26T(n)=2n+26，即 O(n)，我们找到了一个线性量级的算法解决这个问题。 在结束这个例子之前，我们来讨论下空间花费，虽然最后一个方案在线性时间执行，但它需要额外的存储来保存两个字符计数列表。换句话说，该算法牺牲了空间以获得时间。 diff --git "a/2.\347\256\227\346\263\225\345\210\206\346\236\220/2.6.\345\210\227\350\241\250/README.md" "b/2.\347\256\227\346\263\225\345\210\206\346\236\220/2.6.\345\210\227\350\241\250/README.md" index 2fa6b35..bdbdb6c 100644 --- "a/2.\347\256\227\346\263\225\345\210\206\346\236\220/2.6.\345\210\227\350\241\250/README.md" +++ "b/2.\347\256\227\346\263\225\345\210\206\346\236\220/2.6.\345\210\227\350\241\250/README.md" @@ -28,7 +28,7 @@ def test4(): 要捕获我们的每个函数执行所需的时间，我们将使用 Python 的 timeit 模块。timeit 模块旨在允许 Python 开发人员通过在一致的环境中运行函数并使用尽可能相似的操作系统的时序机制来进行跨平台时序测量。 -要使用 timeit，您需要创建一个 Timer 对象，其参数是两个 Python 语句。第一个参数是一个你想要执行时间的 Python 语句; 第二个参数是一个将运行一次以设置测试的语句。然后 timeit 模块将计算执行语句所需的时间。默认情况下，timeit 将尝试运行语句一百万次。 当它完成时，它返回时间作为表示总秒数的浮点值。由于它执行语句一百万次，可以读取结果作为执行测试一次的微秒数。你还可以传递 timeit 一个参数名字为 number，允许您指定执行测试语句的次数。以下显示了运行我们的每个测试功能 1000 次需要多长时间。 +要使用 timeit，你需要创建一个 Timer 对象，其参数是两个 Python 语句。第一个参数是一个你想要执行时间的 Python 语句; 第二个参数是一个将运行一次以设置测试的语句。然后 timeit 模块将计算执行语句所需的时间。默认情况下，timeit 将尝试运行语句一百万次。 当它完成时，它返回时间作为表示总秒数的浮点值。由于它执行语句一百万次，可以读取结果作为执行测试一次的微秒数。你还可以传递 timeit 一个参数名字为 number，允许你指定执行测试语句的次数。以下显示了运行我们的每个测试功能 1000 次需要多长时间。 ```` t1 = Timer("test1()", "from __main__ import test1") @@ -52,15 +52,15 @@ list range 0.0655000209808 milliseconds 最后一点，你上面看到的时间都是包括实际调用函数的一些开销，但我们可以假设函数调用开销在四种情况下是相同的，所以我们仍然得到的是有意义的比较。因此，拼接字符串操作需要 6.54 毫秒并不准确，而是拼接字符串这个函数需要 6.54 毫秒。你可以测试调用空函数所需要的时间，并从上面的数字中减去它。 -现在我们已经看到了如何具体测试性能，见 Table2, 你可能想知道 pop 两个不同的时间。当列表末尾调用 pop 时，它需要 O(1), 但是当在列表中第一个元素或者中间任何地方调用 pop, 它是 O(n)。原因在于 Python 实现列表的方式，当一个项从列表前面取出，列表中的其他元素靠近开始移动一个位置。你会看到索引操作为 O(1)。python的实现者会权衡选择一个好的方案。 +现在我们已经看到了如何具体测试性能，见 Table2, 你可能想知道 pop 两个不同的时间。当列表末尾调用 pop 时，它需要 O(1), 但是当在列表中第一个元素或者中间任何地方调用 pop, 它是 O(n)。原因在于 Python 实现列表的方式，当一个项从列表前面取出，列表中的其他元素靠近起始位置移动一个位置。你会看到索引操作为 O(1)。python的实现者会权衡选择一个好的方案。 ![2.6.列表 Table2](assets/2.6.%E5%88%97%E8%A1%A8%20Table2.png) -作为一种演示性能差异的方法，我们用 timeit 来做一个实验。我们的目标是验证从列表从末尾 pop 元素和从开始 pop 元素的性能。同样，我们也想测量不同列表大小对这个时间的影响。我们期望看到的是，从列表末尾处弹出所需时间将保持不变，即使列表不断增长。而从列表开始出弹出元素时间将随列表增长而增加。 +作为一种演示性能差异的方法，我们用 timeit 来做一个实验。我们的目标是验证从列表从末尾 pop 元素和从开始 pop 元素的性能。同样，我们也想测量不同列表大小对这个时间的影响。我们期望看到的是，从列表末尾处弹出所需时间将保持不变，即使列表不断增长。而从列表开始处弹出元素时间将随列表增长而增加。 -Listing 4 展示了两种 pop 方式的比较。从第一个示例看书，从末尾弹出需要 0.0003 毫秒。从开始弹出要花费 4.82毫秒。对于一个 200万的元素列表，相差 16000 倍。 +Listing 4 展示了两种 pop 方式的比较。从第一个示例看出，从末尾弹出需要 0.0003 毫秒。从开始弹出要花费 4.82 毫秒。对于一个 200 万的元素列表，相差 16000 倍。 -Listing 4 需要注意的几点，第一， `from __main__ import x` , 虽然我们没有定义一个函数，我们确实希望能够在我们的测试中使用列表对象 x, 这种方法允许我们只计算单个弹出语句，获得该操作最精确的测量时间。因为 timer 重复了 1000 次，所以该列表每次循环大小都减1。但是由于初始列表大小为 200万，我们只减少总体大小的 0.05%。 +Listing 4 需要注意的几点，第一， `from __main__ import x` , 虽然我们没有定义一个函数，我们确实希望能够在我们的测试中使用列表对象 x, 这种方法允许我们只计算单个弹出语句，获得该操作最精确的测量时间。因为 timer 重复了 1000 次，该列表每次循环大小都减 1。但是由于初始列表大小为 200万，我们只减少总体大小的 0.05%。 ```` popzero = timeit.Timer("x.pop(0)", @@ -95,7 +95,7 @@ for i in range(1000000,100000001,1000000): ```` *Listing 5* -Figure 3 展示了我们实验的结果，你可以看到，随着列表变长，pop(0) 时间也增加，而pop() 时间保持非常平坦。这正是我们期望看到的 O(n)和 O(1) +Figure 3 展示了我们实验的结果，你可以看到，随着列表变长，pop(0) 时间也增加，而 pop() 时间保持非常平坦。这正是我们期望看到的 O(n)和 O(1) ![2.6.列表.poptime](assets/2.6.%E5%88%97%E8%A1%A8.poptime.png) diff --git "a/2.\347\256\227\346\263\225\345\210\206\346\236\220/2.7.\345\255\227\345\205\270/README.md" "b/2.\347\256\227\346\263\225\345\210\206\346\236\220/2.7.\345\255\227\345\205\270/README.md" index 89721a1..dca3360 100644 --- "a/2.\347\256\227\346\263\225\345\210\206\346\236\220/2.7.\345\255\227\345\205\270/README.md" +++ "b/2.\347\256\227\346\263\225\345\210\206\346\236\220/2.7.\345\255\227\345\205\270/README.md" @@ -5,9 +5,9 @@ python 中第二个主要的数据结构是字典。你可能记得，字典和 ![2.7.字典.table3](assets/2.7.%E5%AD%97%E5%85%B8.table3.png) *Table 3* -我们会在最后的实验中，将比较列表和字典之间的 contains 操作的性能。在此过程中，我们将确认列表的 contains 操作符是O（n），字典的 contains 操作符是O（1）。我们将在实验中列出一系列数字。然后随机选择数字，并检查数字是否在列表中。如果我们的性能表是正确的，列表越大，确定列表中是否包含任何一个数字应该花费的时间越长。 +我们会在最后的实验中，将比较列表和字典之间的 contains 操作的性能。在此过程中，我们将确认列表的 contains 操作符是 O(n)，字典的 contains 操作符是 O(1)。我们将在实验中列出一系列数字。然后随机选择数字，并检查数字是否在列表中。如果我们的性能表是正确的，列表越大，确定列表中是否包含任意一个数字应该花费的时间越长。 -Listing 6 实现了这个比较。注意，我们对容器中的数字执行完全相同的操作。区别在于在第7行上x是一个列表，第9行上的x是一个字典。 +Listing 6 实现了这个比较。注意，我们对容器中的数字执行完全相同的操作。区别在于在第 7 行上 x 是一个列表，第9行上的 x 是一个字典。 ```` import timeit @@ -25,7 +25,7 @@ for i in range(10000,1000001,20000): *Listing 6* -Figure 4 展示了 Listing6 的结果。你可以看到字典一直更快。 对于最小的列表大小为10,000个元素，字典是列表的89.4倍。对于最大的列表大小为990,000 个元素。字典是列表的11,603倍！你还可以看到列表上的contains运算符所花费的时间与列表的大小成线性增长。这验证了列表上的contains运算符是O（n）的断言。还可以看出，字典中的contains运算符的时间是恒定的，即使字典大小不断增长。事实上，对于字典大小为10,000个元素，contains操作占用0.004毫秒，对于字典大小为990,000个元素，它也占用0.004毫秒。 +Figure 4 展示了 Listing6 的结果。你可以看到字典一直更快。 对于最小的列表大小为10,000个元素，字典是列表的89.4倍。对于最大的列表大小为990,000 个元素。字典是列表的11,603倍！你还可以看到列表上的contains运算符所花费的时间与列表的大小成线性增长。这验证了列表上的contains运算符是 O(n) 的断言。还可以看出，字典中的 contains 运算符的时间是恒定的，即使字典大小不断增长。事实上，对于字典大小为10,000个元素，contains操作占用0.004毫秒，对于字典大小为990,000个元素，它也占用0.004毫秒。 ![2.7.字典.figure4](assets/2.7.%E5%AD%97%E5%85%B8.figure4.png) From 89396fee19e020ea30829793c948c636f82fb3a8 Mon Sep 17 00:00:00 2001 From: facert Date: Wed, 15 Feb 2017 17:01:00 +0800 Subject: [PATCH 4/4] fix typo --- .../README.md" | 4 ++-- .../3.1.\347\233\256\346\240\207/README.md" | 10 +++++----- .../README.md" | 2 +- .../README.md" | 8 +++++++- .../README.md" | 1 + .../README.md" | 4 ++-- .../README.md" | 6 ++++-- .../README.md" | 6 ++++-- .../README.md" | 12 ++++++++++++ ...50\241\250\350\276\276\345\274\217.figure10.png" | Bin ...50\241\250\350\276\276\345\274\217.figure11.png" | Bin ...350\241\250\350\276\276\345\274\217.figure6.png" | Bin ...350\241\250\350\276\276\345\274\217.figure7.png" | Bin ...350\241\250\350\276\276\345\274\217.figure8.png" | Bin ...350\241\250\350\276\276\345\274\217.figure9.png" | Bin ...\350\241\250\350\276\276\345\274\217.table2.png" | Bin ...50\241\250\350\276\276\345\274\217.table3-1.png" | Bin ...\350\241\250\350\276\276\345\274\217.table3.png" | Bin ...\350\241\250\350\276\276\345\274\217.table4.png" | Bin SUMMARY.md | 2 +- 20 files changed, 39 insertions(+), 16 deletions(-) rename "3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.9.\344\270\255\347\274\200\345\220\216\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217/README.md" => "3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.9.\344\270\255\347\274\200\345\211\215\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217/README.md" (99%) rename "3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.9.\344\270\255\347\274\200\345\220\216\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217/assets/3.9.\344\270\255\347\274\200\345\220\216\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217.figure10.png" => "3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.9.\344\270\255\347\274\200\345\211\215\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217/assets/3.9.\344\270\255\347\274\200\345\220\216\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217.figure10.png" (100%) rename "3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.9.\344\270\255\347\274\200\345\220\216\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217/assets/3.9.\344\270\255\347\274\200\345\220\216\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217.figure11.png" => "3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.9.\344\270\255\347\274\200\345\211\215\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217/assets/3.9.\344\270\255\347\274\200\345\220\216\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217.figure11.png" (100%) rename "3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.9.\344\270\255\347\274\200\345\220\216\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217/assets/3.9.\344\270\255\347\274\200\345\220\216\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217.figure6.png" => "3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.9.\344\270\255\347\274\200\345\211\215\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217/assets/3.9.\344\270\255\347\274\200\345\220\216\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217.figure6.png" (100%) rename "3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.9.\344\270\255\347\274\200\345\220\216\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217/assets/3.9.\344\270\255\347\274\200\345\220\216\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217.figure7.png" => "3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.9.\344\270\255\347\274\200\345\211\215\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217/assets/3.9.\344\270\255\347\274\200\345\220\216\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217.figure7.png" (100%) rename "3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.9.\344\270\255\347\274\200\345\220\216\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217/assets/3.9.\344\270\255\347\274\200\345\220\216\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217.figure8.png" => "3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.9.\344\270\255\347\274\200\345\211\215\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217/assets/3.9.\344\270\255\347\274\200\345\220\216\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217.figure8.png" (100%) rename "3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.9.\344\270\255\347\274\200\345\220\216\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217/assets/3.9.\344\270\255\347\274\200\345\220\216\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217.figure9.png" => "3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.9.\344\270\255\347\274\200\345\211\215\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217/assets/3.9.\344\270\255\347\274\200\345\220\216\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217.figure9.png" (100%) rename "3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.9.\344\270\255\347\274\200\345\220\216\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217/assets/3.9.\344\270\255\347\274\200\345\220\216\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217.table2.png" => "3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.9.\344\270\255\347\274\200\345\211\215\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217/assets/3.9.\344\270\255\347\274\200\345\220\216\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217.table2.png" (100%) rename "3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.9.\344\270\255\347\274\200\345\220\216\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217/assets/3.9.\344\270\255\347\274\200\345\220\216\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217.table3-1.png" => "3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.9.\344\270\255\347\274\200\345\211\215\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217/assets/3.9.\344\270\255\347\274\200\345\220\216\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217.table3-1.png" (100%) rename "3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.9.\344\270\255\347\274\200\345\220\216\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217/assets/3.9.\344\270\255\347\274\200\345\220\216\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217.table3.png" => "3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.9.\344\270\255\347\274\200\345\211\215\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217/assets/3.9.\344\270\255\347\274\200\345\220\216\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217.table3.png" (100%) rename "3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.9.\344\270\255\347\274\200\345\220\216\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217/assets/3.9.\344\270\255\347\274\200\345\220\216\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217.table4.png" => "3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.9.\344\270\255\347\274\200\345\211\215\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217/assets/3.9.\344\270\255\347\274\200\345\220\216\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217.table4.png" (100%) diff --git "a/2.\347\256\227\346\263\225\345\210\206\346\236\220/2.4.\344\270\200\344\270\252\345\233\236\346\226\207\345\255\227\347\254\246\344\270\262\346\243\200\346\237\245\347\232\204\344\276\213\345\255\220/README.md" "b/2.\347\256\227\346\263\225\345\210\206\346\236\220/2.4.\344\270\200\344\270\252\345\233\236\346\226\207\345\255\227\347\254\246\344\270\262\346\243\200\346\237\245\347\232\204\344\276\213\345\255\220/README.md" index 1545c42..3862681 100644 --- "a/2.\347\256\227\346\263\225\345\210\206\346\236\220/2.4.\344\270\200\344\270\252\345\233\236\346\226\207\345\255\227\347\254\246\344\270\262\346\243\200\346\237\245\347\232\204\344\276\213\345\255\220/README.md" +++ "b/2.\347\256\227\346\263\225\345\210\206\346\236\220/2.4.\344\270\200\344\270\252\345\233\236\346\226\207\345\255\227\347\254\246\344\270\262\346\243\200\346\237\245\347\232\204\344\276\213\345\255\220/README.md" @@ -76,7 +76,7 @@ print(anagramSolution2('abcde','edcba')) ### 2.4.4.解法4: 计数和比较 -我们最终解决回文的方法是利用两个回文字符串具有相同的 a, b, c 等等的事实。我们首先计算的是每个字母出现的次数。由于有 26 个可能的字符，我们就用 26 个列表，每个可能的字符一个。每次看到一个特定的字符，就增加该位置的计数器。最后如果两个列表的计数器一样，则字符串为回文字符串。见 ActiveCode 3 +我们最终解决回文的方法是利用两个回文字符串具有相同的 a, b, c 等等的事实。我们首先计算的是每个字母出现的次数。由于有 26 个可能的字符，我们就用 一个长度为 26 的列表，每个可能的字符占一个位置。每次看到一个特定的字符，就增加该位置的计数器。最后如果两个列表的计数器一样，则字符串为回文字符串。见 ActiveCode 3 ```` python def anagramSolution4(s1,s2): @@ -106,7 +106,7 @@ print(anagramSolution4('apple','pleap')) ```` *ActiveCode 3* -同样，这个方案有多个迭代，但是和第一个解法不一样，它不是嵌套的。两个迭代都是 n, 第三个迭代，比较两个计数列表，需要 26 步，因为有 26个字母。一共 T(n)=2n+26T(n)=2n+26，即 O(n)，我们找到了一个线性量级的算法解决这个问题。 +同样，这个方案有多个迭代，但是和第一个解法不一样，它不是嵌套的。两个迭代都是 n, 第三个迭代，比较两个计数列表，需要 26 步，因为有 26 个字母。一共 T(n)=2n+26T(n)=2n+26，即 O(n)，我们找到了一个线性量级的算法解决这个问题。 在结束这个例子之前，我们来讨论下空间花费，虽然最后一个方案在线性时间执行，但它需要额外的存储来保存两个字符计数列表。换句话说，该算法牺牲了空间以获得时间。 diff --git "a/3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.1.\347\233\256\346\240\207/README.md" "b/3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.1.\347\233\256\346\240\207/README.md" index 60fef85..cd6a103 100644 --- "a/3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.1.\347\233\256\346\240\207/README.md" +++ "b/3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.1.\347\233\256\346\240\207/README.md" @@ -1,14 +1,14 @@ ## 3.1.目标 -* 理解抽象数据类型的栈，队列，deque和列表。 +* 理解抽象数据类型的栈，队列，deque 和列表。 * 能够使用 Python 列表实现 ADT 堆栈，队列和 deque。 * 了解基本线性数据结构实现的性能。 * 了解前缀，中缀和后缀表达式格式。 -* 使用堆栈来实现后缀表达式。 -* 使用堆栈将表达式从中缀转换为后缀。 +* 使用栈来实现后缀表达式。 +* 使用栈将表达式从中缀转换为后缀。 * 使用队列进行基本时序仿真。 -* 能够识别问题中堆栈，队列和 deques 数据结构的适当使用。 -* 能够使用节点和参考模式将抽象数据类型列表实现为链接列表。 +* 能够识别问题中栈，队列和 deques 数据结构的适当使用。 +* 能够使用节点和引用将抽象数据类型列表实现为链表。 * 能够比较我们的链表实现与 Python 的列表实现的性能。 diff --git "a/3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.2.\344\273\200\344\271\210\346\230\257\347\272\277\346\200\247\346\225\260\346\215\256\347\273\223\346\236\204/README.md" "b/3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.2.\344\273\200\344\271\210\346\230\257\347\272\277\346\200\247\346\225\260\346\215\256\347\273\223\346\236\204/README.md" index 4f41ac7..b0e3688 100644 --- "a/3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.2.\344\273\200\344\271\210\346\230\257\347\272\277\346\200\247\346\225\260\346\215\256\347\273\223\346\236\204/README.md" +++ "b/3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.2.\344\273\200\344\271\210\346\230\257\347\272\277\346\200\247\346\225\260\346\215\256\347\273\223\346\236\204/README.md" @@ -1,7 +1,7 @@ ## 3.2.什么是线性数据结构 我们从四个简单但重要的概念开始研究数据结构。栈，队列，deques, 列表是一类数据的容器，它们数据项之间的顺序由添加或删除的顺序决定。一旦一个数据项被添加，它相对于前后元素一直保持该位置不变。诸如此类的数据结构被称为线性数据结构。 -线性数据结构有两端，有时被称为左右，某些情况被称为前后。你也可以称为顶部和底部，名字都不重要。将两个线性数据结构区分开的方法是添加和移除项目的方式，特别是添加和移除项目的位置。例如一些结构允许从一段添加项，另一些允许从另一端移除项。 +线性数据结构有两端，有时被称为左右，某些情况被称为前后。你也可以称为顶部和底部，名字都不重要。将两个线性数据结构区分开的方法是添加和移除项的方式，特别是添加和移除项的位置。例如一些结构允许从一端添加项，另一些允许从另一端移除项。 这些变种的形式产生了计算机科学最有用的数据结构。他们出现在各种算法中，并可以用于解决很多重要的问题。 diff --git "a/3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.3.\344\273\200\344\271\210\346\230\257\346\240\210/README.md" "b/3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.3.\344\273\200\344\271\210\346\230\257\346\240\210/README.md" index 777fb44..7a94314 100644 --- "a/3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.3.\344\273\200\344\271\210\346\230\257\346\240\210/README.md" +++ "b/3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.3.\344\273\200\344\271\210\346\230\257\346\240\210/README.md" @@ -1,20 +1,26 @@ ## 3.3.什么是栈 -栈（有时称为“后进先出栈”）是一个项的有序集合，其中添加移除新项目总发生在同一端。这一端通常称为“顶部”。与顶部对应的端称为“底部”。 +栈（有时称为“后进先出栈”）是一个项的有序集合，其中添加移除新项总发生在同一端。这一端通常称为“顶部”。与顶部对应的端称为“底部”。 栈的底部很重要，因为在栈中靠近底部的项是存储时间最长的。最近添加的项是最先会被移除的。这种排序原则有时被称为 LIFO，后进先出。它基于在集合内的时间长度做排序。较新的项靠近顶部，较旧的项靠近底部。 栈的例子很常见。几乎所有的自助餐厅都有一堆托盘或盘子，你从顶部拿一个，就会有一个新的托盘给下一个客人。想象桌上有一堆书(Figure 1), 只有顶部的那本书封面可见，要看到其他书的封面，只有先移除他们上面的书。Figure 2 展示了另一个栈，包含了很多 Python 对象。 ![3.3.什么是栈](assets/3.3.%E4%BB%80%E4%B9%88%E6%98%AF%E6%A0%88.png) + + *Figure 1* ![3.3.什么是栈.primitive](assets/3.3.%E4%BB%80%E4%B9%88%E6%98%AF%E6%A0%88.primitive.png) + + *Figure 2* 和栈相关的最有用的想法之一来自对它的观察。假设从一个干净的桌面开始，现在把书一本本叠起来，你在构造一个栈。考虑下移除一本书会发生什么。移除的顺序跟刚刚被放置的顺序相反。栈之所以重要是因为它能反转项的顺序。插入跟删除顺序相反，Figure 3 展示了 Python 数据对象创建和删除的过程，注意观察他们的顺序。 ![3.3.什么是栈.simplereversa](assets/3.3.%E4%BB%80%E4%B9%88%E6%98%AF%E6%A0%88.simplereversal.png) + + *Figure 3* 想想这种反转的属性，你可以想到使用计算机的时候所碰到的例子。例如，每个 web 浏览器都有一个返回按钮。当你浏览网页时，这些网页被放置在一个栈中（实际是网页的网址）。你现在查看的网页在顶部，你第一个查看的网页在底部。如果按‘返回’按钮，将按相反的顺序浏览刚才的页面。 diff --git "a/3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.4.\346\240\210\347\232\204\346\212\275\350\261\241\346\225\260\346\215\256\347\261\273\345\236\213/README.md" "b/3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.4.\346\240\210\347\232\204\346\212\275\350\261\241\346\225\260\346\215\256\347\261\273\345\236\213/README.md" index d2d3c20..ea07689 100644 --- "a/3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.4.\346\240\210\347\232\204\346\212\275\350\261\241\346\225\260\346\215\256\347\261\273\345\236\213/README.md" +++ "b/3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.4.\346\240\210\347\232\204\346\212\275\350\261\241\346\225\260\346\215\256\347\261\273\345\236\213/README.md" @@ -12,6 +12,7 @@ 例如，s 是已经创建的空栈，Table1 展示了栈操作序列的结果。栈中，顶部项列在最右边。 ![3.4.栈的抽象数据类型.table1](assets/3.4.%E6%A0%88%E7%9A%84%E6%8A%BD%E8%B1%A1%E6%95%B0%E6%8D%AE%E7%B1%BB%E5%9E%8B.table1.png) + *Table1* diff --git "a/3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.5.Python\345\256\236\347\216\260\346\240\210/README.md" "b/3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.5.Python\345\256\236\347\216\260\346\240\210/README.md" index 630c0d1..be321ec 100644 --- "a/3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.5.Python\345\256\236\347\216\260\346\240\210/README.md" +++ "b/3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.5.Python\345\256\236\347\216\260\346\240\210/README.md" @@ -30,11 +30,11 @@ class Stack: ```` *ActiveCode 1* -记住我们只定义类的实现，我们需要创建一个栈，然后使用它。ActiveCode 2 展示了我们通过实例化 Stack 类执行Table 1中的操作。注意，Stack 类的定义是从 pythonds 模块导入的。 +记住我们只定义类的实现，我们需要创建一个栈，然后使用它。ActiveCode 2 展示了我们通过实例化 Stack 类执行 Table 1中的操作。注意，Stack 类的定义是从 pythonds 模块导入的。 > **Note** -pythonds 模块包含本书中讨论的所有数据结构的实现。它根据以下部分构造：基本数据类型，树和图形。 该模块可以从 [pythonworks.org](http://www.pythonworks.org/pythonds)下载。 +pythonds 模块包含本书中讨论的所有数据结构的实现。它根据以下部分构造：基本数据类型，树和图。 该模块可以从 [pythonworks.org](http://www.pythonworks.org/pythonds)下载。 ```` from pythonds.basic.stack import Stack diff --git "a/3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.6.\347\256\200\345\215\225\346\213\254\345\217\267\345\214\271\351\205\215/README.md" "b/3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.6.\347\256\200\345\215\225\346\213\254\345\217\267\345\214\271\351\205\215/README.md" index d71d986..8a8dbae 100644 --- "a/3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.6.\347\256\200\345\215\225\346\213\254\345\217\267\345\214\271\351\205\215/README.md" +++ "b/3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.6.\347\256\200\345\215\225\346\213\254\345\217\267\345\214\271\351\205\215/README.md" @@ -1,5 +1,5 @@ ## 3.6.简单括号匹配 -我们现在把注意力转向使用栈来解决真正的计算机问题。你会这么写算术表达式 +我们现在把注意力转向使用栈解决真正的计算机问题。你会这么写算术表达式 `(5+6)∗(7+8)/(4+3)` @@ -33,9 +33,11 @@ 区分括号是否匹配的能力是识别很多编程语言结构的重要部分。具有挑战的是如何编写一个算法，能够从左到右读取一串符号，并决定符号是否平衡。为了解决这个问题，我们需要做一个重要的观察。从左到右处理符号时，最近开始符号必须与下一个关闭符号相匹配(见 Figure 4)。此外，处理的第一个开始符号必须等待直到其匹配最后一个符号。结束符号以相反的顺序匹配开始符号。他们从内到外匹配。这是一个可以用栈解决问题的线索。 ![3.6.简单括号匹配.simpleparcheck](assets/3.6.%E7%AE%80%E5%8D%95%E6%8B%AC%E5%8F%B7%E5%8C%B9%E9%85%8D.simpleparcheck.png) + + *Figure 4* -一旦你认为栈是保存括号的恰当的数据结构，算法是很直接的。从空栈开始，从左到右处理括号字符串。如果一个符号是一个开始符号，将其作为一个信号，对应的结束符号稍后会出现。另一方面，如果符号是结束符号，弹出栈，只要可以弹出栈的开始符号可以匹配每个结束符号，则括号保持匹配状态。如果任何时候栈上没有出现符合结束符号的开始符号，则字符串不匹配。最后，当所有符号都被处理后，栈应该是空的。实现此算法的 Python 代码见 ActiveCode 1。 +一旦你认为栈是保存括号的恰当的数据结构，算法是很直接的。从空栈开始，从左到右处理括号字符串。如果一个符号是一个开始符号，将其作为一个信号，对应的结束符号稍后会出现。另一方面，如果符号是结束符号，弹出栈，只要弹出栈的开始符号可以匹配每个结束符号，则括号保持匹配状态。如果任何时候栈上没有出现符合开始符号的结束符号，则字符串不匹配。最后，当所有符号都被处理后，栈应该是空的。实现此算法的 Python 代码见 ActiveCode 1。 ```` from pythonds.basic.stack import Stack diff --git "a/3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.8.\345\215\201\350\277\233\345\210\266\350\275\254\346\215\242\346\210\220\344\272\214\350\277\233\345\210\266/README.md" "b/3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.8.\345\215\201\350\277\233\345\210\266\350\275\254\346\215\242\346\210\220\344\272\214\350\277\233\345\210\266/README.md" index e747c3b..ed730c7 100644 --- "a/3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.8.\345\215\201\350\277\233\345\210\266\350\275\254\346\215\242\346\210\220\344\272\214\350\277\233\345\210\266/README.md" +++ "b/3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.8.\345\215\201\350\277\233\345\210\266\350\275\254\346\215\242\346\210\220\344\272\214\350\277\233\345\210\266/README.md" @@ -2,7 +2,7 @@ 在你学习计算机的过程中，你可能已经接触了二进制。二进制在计算机科学中是很重要的，因为存储在计算机内的所有值都是以 0 和 1 存储的。如果没有能力在二进制数和普通字符串之间转换，我们与计算机之间的交互非常棘手。 -整数值是常见的数据项。他们一直用于计算机程序和计算。我们在数学类中学习它们，当然最后用十进制或者基数 10 来表示它们。十进制 233^10 以及对应的二进制表示 11101001^2 分别解释为 +整数值是常见的数据项。他们一直用于计算机程序和计算。我们在数学课上学习它们，当然最后用十进制或者基数 10 来表示它们。十进制 233^10 以及对应的二进制表示 11101001^2 分别解释为 ![3.8.十进制转换成二进制.2](assets/3.8.%E5%8D%81%E8%BF%9B%E5%88%B6%E8%BD%AC%E6%8D%A2%E6%88%90%E4%BA%8C%E8%BF%9B%E5%88%B6.2.png) @@ -13,6 +13,8 @@ “除 2” 算法假定我们从大于 0 的整数开始。不断迭代的将十进制除以 2，并跟踪余数。第一个除以 2 的余数说明了这个值是偶数还是奇数。偶数有 0 的余数，记为 0。奇数有余数 1，记为 1.我们将得到的二进制构建为数字序列，第一个余数实际上是序列中的最后一个数字。见 Figure 5 , 我们再次看到了反转的属性，表示栈可能是解决这个问题的数据结构。 ![3.8.十进制转换成二进制.figure5](assets/3.8.%E5%8D%81%E8%BF%9B%E5%88%B6%E8%BD%AC%E6%8D%A2%E6%88%90%E4%BA%8C%E8%BF%9B%E5%88%B6.figure5.png) + + *Figure 5* Activecode 1 中的 Python 代码实现了 “除 2” 算法，函数 divideBy2 传入了一个十进制的参数，并重复除以 2。第 7 行使用内置的模运算符 % 来提取余数，第 8 行将余数压到栈上。当除到 0 后，11-13 行构造了一个二进制字符串。 @@ -39,7 +41,7 @@ print(divideBy2(42)) ```` *ActiveCode 1* -这个用于二进制转换的算法可以很容易的扩展以执行任何基数的转换。在计算可科学中，通常会使用很多不同的编码。其中最常见的是二级制，八进制和十六进制。 +这个用于二进制转换的算法可以很容易的扩展以执行任何基数的转换。在计算机科学中，通常会使用很多不同的编码。其中最常见的是二级制，八进制和十六进制。 十进制 233 和它对应的八进制和十六进制 352^8, E9^16 diff --git "a/3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.9.\344\270\255\347\274\200\345\220\216\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217/README.md" "b/3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.9.\344\270\255\347\274\200\345\211\215\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217/README.md" similarity index 99% rename from "3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.9.\344\270\255\347\274\200\345\220\216\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217/README.md" rename to "3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.9.\344\270\255\347\274\200\345\211\215\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217/README.md" index 4a84d2e..0acc737 100644 --- "a/3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.9.\344\270\255\347\274\200\345\220\216\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217/README.md" +++ "b/3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.9.\344\270\255\347\274\200\345\211\215\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217/README.md" @@ -18,17 +18,24 @@ 在后缀中，表达式将是 `A B C * +`，再次，操作的顺序被保留，因为 `*` 紧接在 B 和 C 之后出现，表示 `*` 具有高优先级，`+` 优先级低。虽然操作符在它们各自的操作数前后移动，但是顺序相对于彼此保持完全相同。 ![3.9.中缀后缀和后缀表达式.table2](assets/3.9.%E4%B8%AD%E7%BC%80%E5%90%8E%E7%BC%80%E5%92%8C%E5%90%8E%E7%BC%80%E8%A1%A8%E8%BE%BE%E5%BC%8F.table2.png) + + *Table 2* + 现在考虑中缀表达式 `(A + B) * C`，回想下，在这种情况下，中缀需要括号在乘法之前强制执行加法。然而，当 A+B 写到前缀中时，加法运算符简单的移动到操作数 `+ A B` 之前。这个操作的结果成为乘法的第一个操作数。乘法运算符移动到整个表达式的前面，得出 `* + A B C`，同样，在后缀 `A B +`中，强制先加法。可以直接对该结果和剩余的操作数 C 相乘。然后，得出后缀表达式为 `A B + C *`。 再次考虑这三个表达式(见 Table 3)，括号不见了。为什么在前缀和后缀的时候不需要括号了呢？答案是操作符对于他们的操作数不再模糊，只有中缀才需要括号，前缀和后缀表达式的操作顺序完全由操作符的顺序决定。 ![3.9.中缀后缀和后缀表达式.table3](assets/3.9.%E4%B8%AD%E7%BC%80%E5%90%8E%E7%BC%80%E5%92%8C%E5%90%8E%E7%BC%80%E8%A1%A8%E8%BE%BE%E5%BC%8F.table3.png) + + *Table 3* Table 4 展示了一些其他的例子 ![3.9.中缀后缀和后缀表达式.table4](assets/3.9.%E4%B8%AD%E7%BC%80%E5%90%8E%E7%BC%80%E5%92%8C%E5%90%8E%E7%BC%80%E8%A1%A8%E8%BE%BE%E5%BC%8F.table4.png) + + *Table 4* ### 3.9.1.中缀表达式转换前缀和后缀 @@ -39,10 +46,14 @@ Table 4 展示了一些其他的例子 看上面的子表达式`（B * C）`中的右括号。 如果我们将乘法符号移动到那个位置，并删除匹配的左括号，得到 `B C * `，我们实际上已经将子表达式转换为后缀符号。 如果加法运算符也被移动到其相应的右括号位置并且匹配的左括号被去除，则将得到完整的后缀表达式（见 Figure 6）。 ![3.9.中缀后缀和后缀表达式.figure6](assets/3.9.%E4%B8%AD%E7%BC%80%E5%90%8E%E7%BC%80%E5%92%8C%E5%90%8E%E7%BC%80%E8%A1%A8%E8%BE%BE%E5%BC%8F.figure6.png) + + *Figure 6* 如果我们不是将符号移动到右括号的位置，我们将它向左移动，我们得到前缀符号（见 Figure 7）。圆括号对的位置实际上是包含的运算符的最终位置的线索。 ![3.9.中缀后缀和后缀表达式.figure7](assets/3.9.%E4%B8%AD%E7%BC%80%E5%90%8E%E7%BC%80%E5%92%8C%E5%90%8E%E7%BC%80%E8%A1%A8%E8%BE%BE%E5%BC%8F.figure7.png) + + *Figure 7* 所以为了转换表达式，无论是对前缀还是后缀符号，先根据操作的顺序把表达式转换成完全括号表达式。然后将包含的运算符移动到左或右括号的位置，具体取决于需要前缀或后缀符号。 @@ -51,6 +62,7 @@ Table 4 展示了一些其他的例子 ![3.9.中缀后缀和后缀表达式.figure8](assets/3.9.%E4%B8%AD%E7%BC%80%E5%90%8E%E7%BC%80%E5%92%8C%E5%90%8E%E7%BC%80%E8%A1%A8%E8%BE%BE%E5%BC%8F.figure8.png) + *Figure 8* ### 3.9.2.中缀转后缀通用法 diff --git "a/3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.9.\344\270\255\347\274\200\345\220\216\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217/assets/3.9.\344\270\255\347\274\200\345\220\216\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217.figure10.png" "b/3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.9.\344\270\255\347\274\200\345\211\215\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217/assets/3.9.\344\270\255\347\274\200\345\220\216\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217.figure10.png" similarity index 100% rename from "3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.9.\344\270\255\347\274\200\345\220\216\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217/assets/3.9.\344\270\255\347\274\200\345\220\216\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217.figure10.png" rename to "3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.9.\344\270\255\347\274\200\345\211\215\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217/assets/3.9.\344\270\255\347\274\200\345\220\216\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217.figure10.png" diff --git "a/3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.9.\344\270\255\347\274\200\345\220\216\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217/assets/3.9.\344\270\255\347\274\200\345\220\216\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217.figure11.png" "b/3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.9.\344\270\255\347\274\200\345\211\215\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217/assets/3.9.\344\270\255\347\274\200\345\220\216\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217.figure11.png" similarity index 100% rename from "3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.9.\344\270\255\347\274\200\345\220\216\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217/assets/3.9.\344\270\255\347\274\200\345\220\216\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217.figure11.png" rename to "3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.9.\344\270\255\347\274\200\345\211\215\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217/assets/3.9.\344\270\255\347\274\200\345\220\216\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217.figure11.png" diff --git "a/3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.9.\344\270\255\347\274\200\345\220\216\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217/assets/3.9.\344\270\255\347\274\200\345\220\216\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217.figure6.png" "b/3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.9.\344\270\255\347\274\200\345\211\215\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217/assets/3.9.\344\270\255\347\274\200\345\220\216\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217.figure6.png" similarity index 100% rename from "3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.9.\344\270\255\347\274\200\345\220\216\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217/assets/3.9.\344\270\255\347\274\200\345\220\216\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217.figure6.png" rename to "3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.9.\344\270\255\347\274\200\345\211\215\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217/assets/3.9.\344\270\255\347\274\200\345\220\216\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217.figure6.png" diff --git "a/3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.9.\344\270\255\347\274\200\345\220\216\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217/assets/3.9.\344\270\255\347\274\200\345\220\216\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217.figure7.png" "b/3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.9.\344\270\255\347\274\200\345\211\215\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217/assets/3.9.\344\270\255\347\274\200\345\220\216\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217.figure7.png" similarity index 100% rename from "3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.9.\344\270\255\347\274\200\345\220\216\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217/assets/3.9.\344\270\255\347\274\200\345\220\216\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217.figure7.png" rename to "3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.9.\344\270\255\347\274\200\345\211\215\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217/assets/3.9.\344\270\255\347\274\200\345\220\216\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217.figure7.png" diff --git "a/3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.9.\344\270\255\347\274\200\345\220\216\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217/assets/3.9.\344\270\255\347\274\200\345\220\216\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217.figure8.png" "b/3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.9.\344\270\255\347\274\200\345\211\215\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217/assets/3.9.\344\270\255\347\274\200\345\220\216\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217.figure8.png" similarity index 100% rename from "3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.9.\344\270\255\347\274\200\345\220\216\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217/assets/3.9.\344\270\255\347\274\200\345\220\216\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217.figure8.png" rename to "3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.9.\344\270\255\347\274\200\345\211\215\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217/assets/3.9.\344\270\255\347\274\200\345\220\216\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217.figure8.png" diff --git "a/3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.9.\344\270\255\347\274\200\345\220\216\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217/assets/3.9.\344\270\255\347\274\200\345\220\216\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217.figure9.png" "b/3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.9.\344\270\255\347\274\200\345\211\215\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217/assets/3.9.\344\270\255\347\274\200\345\220\216\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217.figure9.png" similarity index 100% rename from "3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.9.\344\270\255\347\274\200\345\220\216\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217/assets/3.9.\344\270\255\347\274\200\345\220\216\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217.figure9.png" rename to "3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.9.\344\270\255\347\274\200\345\211\215\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217/assets/3.9.\344\270\255\347\274\200\345\220\216\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217.figure9.png" diff --git "a/3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.9.\344\270\255\347\274\200\345\220\216\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217/assets/3.9.\344\270\255\347\274\200\345\220\216\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217.table2.png" "b/3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.9.\344\270\255\347\274\200\345\211\215\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217/assets/3.9.\344\270\255\347\274\200\345\220\216\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217.table2.png" similarity index 100% rename from "3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.9.\344\270\255\347\274\200\345\220\216\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217/assets/3.9.\344\270\255\347\274\200\345\220\216\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217.table2.png" rename to "3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.9.\344\270\255\347\274\200\345\211\215\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217/assets/3.9.\344\270\255\347\274\200\345\220\216\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217.table2.png" diff --git "a/3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.9.\344\270\255\347\274\200\345\220\216\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217/assets/3.9.\344\270\255\347\274\200\345\220\216\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217.table3-1.png" "b/3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.9.\344\270\255\347\274\200\345\211\215\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217/assets/3.9.\344\270\255\347\274\200\345\220\216\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217.table3-1.png" similarity index 100% rename from "3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.9.\344\270\255\347\274\200\345\220\216\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217/assets/3.9.\344\270\255\347\274\200\345\220\216\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217.table3-1.png" rename to "3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.9.\344\270\255\347\274\200\345\211\215\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217/assets/3.9.\344\270\255\347\274\200\345\220\216\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217.table3-1.png" diff --git "a/3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.9.\344\270\255\347\274\200\345\220\216\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217/assets/3.9.\344\270\255\347\274\200\345\220\216\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217.table3.png" "b/3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.9.\344\270\255\347\274\200\345\211\215\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217/assets/3.9.\344\270\255\347\274\200\345\220\216\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217.table3.png" similarity index 100% rename from "3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.9.\344\270\255\347\274\200\345\220\216\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217/assets/3.9.\344\270\255\347\274\200\345\220\216\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217.table3.png" rename to "3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.9.\344\270\255\347\274\200\345\211\215\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217/assets/3.9.\344\270\255\347\274\200\345\220\216\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217.table3.png" diff --git "a/3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.9.\344\270\255\347\274\200\345\220\216\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217/assets/3.9.\344\270\255\347\274\200\345\220\216\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217.table4.png" "b/3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.9.\344\270\255\347\274\200\345\211\215\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217/assets/3.9.\344\270\255\347\274\200\345\220\216\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217.table4.png" similarity index 100% rename from "3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.9.\344\270\255\347\274\200\345\220\216\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217/assets/3.9.\344\270\255\347\274\200\345\220\216\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217.table4.png" rename to "3.\345\237\272\346\234\254\346\225\260\346\215\256\347\273\223\346\236\204/3.9.\344\270\255\347\274\200\345\211\215\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217/assets/3.9.\344\270\255\347\274\200\345\220\216\347\274\200\345\222\214\345\220\216\347\274\200\350\241\250\350\276\276\345\274\217.table4.png" diff --git a/SUMMARY.md b/SUMMARY.md index f36bd65..b130597 100644 --- a/SUMMARY.md +++ b/SUMMARY.md @@ -27,7 +27,7 @@ * [3.6.简单括号匹配](3.基本数据结构/3.6.简单括号匹配/README.md) * [3.7.符号匹配](3.基本数据结构/3.7.符号匹配/README.md) * [3.8.十进制转换成二进制](3.基本数据结构/3.8.十进制转换成二进制/README.md) - * [3.9.中缀后缀和后缀表达式](3.基本数据结构/3.9.中缀后缀和后缀表达式/README.md) + * [3.9.中缀前缀和后缀表达式](3.基本数据结构/3.9.中缀前缀和后缀表达式/README.md) * [3.10.什么是队列](3.基本数据结构/3.10.什么是队列/README.md) * [3.11.队列抽象数据类型](3.基本数据结构/3.11.队列抽象数据类型/README.md) * [3.12.Python实现队列](3.基本数据结构/3.12.Python实现队列/README.md)