Deployed 8bdb901 with MkDocs version: 1.0.4

Author: PegasusWang

01_抽象数据类型和面向对象编程/ADT_OOP/index.html

@@ -227,13 +227,12 @@
 
                 <h1 id="python">Python 一切皆对象</h1>
 <p>举个例子，在 python 中我们经常使用的 list</p>
-<pre><code class="py">l = list()    # 实例化一个 list 对象 l
+<pre><code class="language-py">l = list()    # 实例化一个 list 对象 l
 l.append(1)    # 调用 l 的 append 方法
 l.append(2)
 l.remove(1)
 print(len(l))    # 调用对象的 `__len__` 方法
 </code></pre>
-
 <p>在后面实现新的数据类型时，我们将使用 python 的 class 实现，它包含属性和方法。
 属性一般是使用某种特定的数据类型，而方法一般是对属性的操作。
 这里你只需了解这么多就行了， 我们不会使用继承等特性。</p>
@@ -242,11 +241,10 @@ <h1 id="adt">什么是抽象数据类型 ADT</h1>
 <p>ADT: Abstract Data Type，抽象数据类型，我们在组合已有的数据结构来实现一种新的数据类型， ADT 定义了类型的数据和操作。</p>
 <p>我们以抽象一个背包(Bag) 数据类型来说明，背包是一种容器类型，我们可以给它添加东西，也可以移除东西，并且我们想知道背包里
 有多少东西。于是我们可以定义一个新的数据类型叫做 Bag.</p>
-<pre><code class="py">class Bag:
+<pre><code class="language-py">class Bag:
     &quot;&quot;&quot; 背包类型 &quot;&quot;&quot;
     pass
 </code></pre>
-
 <h1 id="bag-adt">实现一个 Bag ADT</h1>
 <p>视频中我们将使用 python 的 class 来实现一个新的容器类型叫做 Bag。</p>
 <h1 id="adt_1">实现 ADT 我们应该注意什么？</h1>

03_链表/linked_list/index.html

@@ -242,19 +242,17 @@ <h1 id="_2">单链表</h1>
 这里可不要混淆了列表和链表（它们的中文发音类似，但是列表 list 底层其实还是线性结构，链表才是真的通过指针关联的链式结构）。
 看到指针你也不用怕，这里我们用的 python，你只需要一个简单赋值操作就能实现，不用担心 c 语言里复杂的指针。</p>
 <p>先来定义一个链接表的节点，刚才说到有一个指针保存下一个节点的位置，我们叫它 next， 当然还需要一个 value 属性保存值</p>
-<pre><code class="py">class Node(object):
+<pre><code class="language-py">class Node(object):
     def __init__(self, value, next=None):
         self.value = value
         self.next = next
 </code></pre>
-
 <p>然后就是我们的单链表 LinkedList ADT:</p>
-<pre><code class="py">class LinkedList(object):
+<pre><code class="language-py">class LinkedList(object):
     &quot;&quot;&quot; 链接表 ADT
     [root] -&gt; [node0] -&gt; [node1] -&gt; [node2]
     &quot;&quot;&quot;
 </code></pre>
-
 <p>实现我们会在视频中用画图来模拟并且手动代码实现，代码里我们会标识每个步骤的时间复杂度。这里请高度集中精力，
 虽然链表的思想很简单，但是想要正确写对链表的操作代码可不容易，稍不留神就可能丢失一些步骤。
 这里我们还是会用简单的单测来验证代码是否按照预期工作。</p>
@@ -292,15 +290,14 @@ <h1 id="_3">双链表</h1>
 并把它追加到访问表的最后一个位置，这个时候单链表就满足不了了，
 因为缓存在 dict 里查找的时间是 O(1)，你更新访问顺序就 O(n)了，缓存就没了优势。</p>
 <p>这里就要使用到双链表了，相比单链表来说，每个节点既保存了指向下一个节点的指针，同时还保存了上一个节点的指针。</p>
-<pre><code class="py">class Node(object):
+<pre><code class="language-py">class Node(object):
     # 如果节点很多，我们可以用 __slots__ 来节省内存，把属性保存在一个 tuple 而不是 dict 里
     # 感兴趣可以自行搜索  python  __slots__
     __slots__ = ('value', 'prev', 'next')
 
     def __init__(self, value=None, prev=None, next=None):
         self.value, self.prev, self.next = value, prev, next
 </code></pre>
-
 <p>对， 就多了 prev，有啥优势嘛？</p>
 <ul>
 <li>看似我们反过来遍历双链表了。反过来从哪里开始呢？我们只要让 root 的 prev 指向 tail 节点，不就串起来了吗？</li>

04_队列/queue/index.html

@@ -242,14 +242,16 @@ <h1 id="queue">队列 Queue</h1>
 <p>我们先来看看 list 可以不？对照这个三个需求，看看能否满足：</p>
 <ul>
 <li>1.我们选择了 list</li>
-<li>2.看起来队列需要从头删除，向尾部增加元素，也就是 list.insert(0, element) 和 list.append(element)</li>
-<li>3.嗯，貌似 list.insert(0, element) 会导致所有list元素后移，O(n)复杂度。append 平均倒是O(1)，但是如果内存不够还要重新分配内存。</li>
+<li>2.看起来队列需要从头删除，向尾部增加元素，也就是 list.pop(0) 和 list.append(element)</li>
+<li>3.嗯，貌似 list.pop(0) 会导致所有其后所有元素向前移动一个位置，O(n)复杂度。append 平均倒是O(1)，但是如果内存不够还要重新分配内存。</li>
+</ul>
+<p>你看，使用了 list 的话频繁 pop(0) 是非常低效的。(当然list 实现还有另一种方式就是插入用 list.insert(0, item)，删除用list.pop())</p>
+<p>脑子再转转， 我们第二章实现了 链表 LinkedList，看看能否满足要求：</p>
+<ul>
+<li>1.这里选择 LinkedList</li>
+<li>2.删除头元素 LinkedList.popleft()，追加 append(element)。都可以满足</li>
+<li>3.哇欧，这两个操作都是 O(1) 的，完美。</li>
 </ul>
-<p>你看，使用了 list 的话频繁 insert(0, element) 和 append 都是非常低效的。</p>
-<p>脑子再转转， 我们第二章实现了 链表 LinkedList，看看能否满足要求：
-- 1.这里选择 LinkedList
-- 2.删除头元素 LinkedList.popleft()，追加 append(element)。都可以满足
-- 3.哇欧，这两个操作都是 O(1) 的，完美。</p>
 <p>好， 就用 LinkedList 了，我们开始实现，具体看视频。这次实现我们还将演示自定义异常和测试异常。</p>
 <h1 id="_2">用数组实现队列</h1>
 <p>难道用数组就不能实现队列了吗？其实还是可以的。只不过数组是预先分配固定内存的，所以如果你知道了队列的最大长度，也是
@@ -261,11 +263,10 @@ <h1 id="_2">用数组实现队列</h1>
 <p>head = 0,1,2,3,4 ... 0,1,2,3,4 ...</p>
 <p>重头再来，循环往复，仿佛一个轮回。。。。
 怎么重头来呢？看上边数组的规律你如果还想不起来用取模，估计小学数学是体育老师教的。</p>
-<pre><code class="py">maxsize = 5
+<pre><code class="language-py">maxsize = 5
 for i in range(100):
     print(i % maxsize)
 </code></pre>
-
 <p><img alt="" src="../array_queue.png" /></p>
 <p>我们来实现一个空间有限的循环队列。ArrayQueue，它的实现很简单，但是缺点是需要预先知道队列的长度来分配内存。</p>
 <h1 id="double-ended-queue">双端队列 Double ended Queue</h1>

05_栈/stack/index.html

@@ -249,11 +249,10 @@ <h1 id="adt">栈 ADT</h1>
 <h1 id="stack-over-flow">Stack over flow 什么鬼？</h1>
 <p>嗯，stackoverflow 不是一个程序员问答网站吗？没错。
 函数的临时变量是存储在栈区的，如果你不幸写了一个没有出口的递归函数，就会这个错。不信你试试：</p>
-<pre><code class="py">def infinite_fib(n):
+<pre><code class="language-py">def infinite_fib(n):
     return infinite_fib(n-1) + infinite_fib(n-2)
 infinite_fib(10)
 </code></pre>
-
 <p>一大段输出之后就会出现异常： RecursionError: maximum recursion depth exceeded。
 后边会讲到递归，递归是初学者比较难理解的概念，在树的遍历等地方还会看到它。</p>
 <h1 id="_2">数据结构头脑风暴法</h1>

06_算法分析/big_o/index.html

@@ -251,7 +251,7 @@ <h1 id="o">大 O 表示法</h1>
 </script>
 </p>
 <p>这里列举两种方式:</p>
-<pre><code class="py"># version1
+<pre><code class="language-py"># version1
 total_sum = 0
 for i in range(n):
     row_sum[i] = 0
@@ -267,7 +267,6 @@ <h1 id="o">大 O 表示法</h1>
         row_sum[i] = row_sum[i] + matrix[i, j]
     total_sum = total_sum + row_sum[i]    # 注意这里和上边的不同
 </code></pre>
-
 <p>v1 版本的关键操作在 j 循环里，两步加法操作，由于嵌套在第一个循环里，操作步骤是 <script type="math/tex">  (2n) * n = 2n^2  </script>。</p>
 <p>v2 版本的 total_sum 只有 n 次操作，它的操作次数是 <script type="math/tex"> n + n*n = n^2 + n </script>。</p>
 <p>这里你可能还感觉不到它们有多大差别，因为计算机执行的太快了，但是当 n 增长特别快的时候，总的操作次数差距就很明显了：</p>

07_哈希表/hashtable/index.html

@@ -249,7 +249,6 @@ <h1 id="_2">哈希表的工作过程</h1>
 <p>我们还是以书中的例子说明，假如我们有一个数组 T，包含 M=13 个元素，我们可以定义一个简单的哈希函数 h</p>
 <pre><code>h(key) = key % M
 </code></pre>
-
 <p>这里取模运算使得 h(key) 的结果不会超过数组的长度下标。我们来分别插入以下元素：</p>
 <p>765, 431, 96, 142, 579, 226, 903, 388</p>
 <p>先来计算下它们应用哈希函数后的结果:</p>
@@ -263,7 +262,6 @@ <h1 id="_2">哈希表的工作过程</h1>
 h(903) = 903 % M = 6
 h(388) = 388 % M = 11
 </code></pre>
-
 <p>下边我画个图演示整个插入过程(纯手工绘制，原谅我字写得不太优雅):</p>
 <p><img alt="" src="../insert_hash.png" /></p>
 <h1 id="collision">哈希冲突 (collision)</h1>
@@ -284,7 +282,7 @@ <h1 id="collision">哈希冲突 (collision)</h1>
 </ul>
 <p>我们选一个简单的二次探查函数 <script type="math/tex"> h(k, i) = (home + i^2) \% m </script>，它的意思是如果
 遇到了冲突，我们就在原始计算的位置不断加上 i 的平方。我写了段代码来模拟整个计算下标的过程：</p>
-<pre><code class="py">inserted_index_set = set()
+<pre><code class="language-py">inserted_index_set = set()
 M = 13
 
 def h(key, M=13):
@@ -303,7 +301,6 @@ <h1 id="collision">哈希冲突 (collision)</h1>
         print('h({number}) = {number} % M = {index}'.format(number=number, index=index))
         inserted_index_set.add(index)
 </code></pre>
-
 <p>这段代码输出的结果如下：</p>
 <pre><code>h(765) = 765 % M = 11
 h(431) = 431 % M = 2
@@ -321,7 +318,6 @@ <h1 id="collision">哈希冲突 (collision)</h1>
     h(388) = 388 % M = 7 collision
 h(388) = 388 % M = 1
 </code></pre>
-
 <p>遇到冲突之后会重新计算，每个待插入元素最终的下标就是：</p>
 <p><img alt="" src="../quadratic_hash.png" /></p>
 <p><img alt="" src="../quadratic_result.png" /></p>
@@ -344,7 +340,6 @@ <h1 id="cpython">Cpython 如何解决哈希冲突</h1>
 
     0 -&gt; 1 -&gt; 6 -&gt; 7 -&gt; 4 -&gt; 5 -&gt; 2 -&gt; 3 -&gt; 0 [and here it's repeating]
 </code></pre>
-
 <h1 id="_3">哈希函数</h1>
 <p>到这里你应该明白哈希表插入的工作原理了，不过有个重要的问题之前没提到，就是 hash 函数怎么选？
 当然是散列得到的冲突越来越小就好啦，也就是说每个 key 都能尽量被等可能地散列到 m 个槽中的任何一个，并且与其他 key 被散列到哪个槽位无关。
@@ -366,7 +361,7 @@ <h1 id="hashtable-adt">HashTable ADT</h1>
 <li>get(key, default)</li>
 <li>remove(key)</li>
 </ul>
-<pre><code class="py">class Slot(object):
+<pre><code class="language-py">class Slot(object):
     &quot;&quot;&quot;定义一个 hash 表 数组的槽
     注意，一个槽有三种状态，看你能否想明白
     1.从未使用 HashMap.UNUSED。此槽没有被使用和冲突过，查找时只要找到 UNUSED 就不用再继续探查了
@@ -379,7 +374,6 @@ <h1 id="hashtable-adt">HashTable ADT</h1>
 class HashTable(object):
     pass
 </code></pre>
-
 <p>具体的实现和代码编写在视频里讲解。这个代码可不太好实现，稍不留神就会有错，我们还是通过编写单元测试验证代码的正确性。</p>
 <h1 id="_4">思考题</h1>
 <ul>

08_字典/dict/index.html

@@ -237,26 +237,23 @@ <h1 id="dict-adt">实现 dict ADT</h1>
 <p>其实上边 HashTable 实现的三个基本方法就是我们使用字典最常用的三个基本方法， 这里我们继承一下这个类，
 然后实现更多 dict 支持的方法，items(), keys(), values()。不过需要注意的是，在 python2 和 python3 里这些方法
 的返回是不同的，python3 里一大改进就是不再返回浪费内存的 列表，而是返回迭代器，你要获得列表必须用 list() 转换成列表。 这里我们实现 python3 的方式返回迭代器。</p>
-<pre><code class="py">class DictADT(HashTable):
+<pre><code class="language-py">class DictADT(HashTable):
     pass
 </code></pre>
-
 <p>视频里我们将演示如何实现这些方法，并且写单测验证正确性。</p>
 <h1 id="hashable">Hashable</h1>
 <p>作为 dict 的 key 必须是可哈希的，也就是说不能是 list 等可变对象。不信你在 ipython 里运行如下代码：</p>
-<pre><code class="py">d = dict()
+<pre><code class="language-py">d = dict()
 d[[1]] = 1
 # TypeError: unhashable type: 'list'
 </code></pre>
-
 <p>我引用 python 文档里的说法，大家可以自己理解下：</p>
 <pre><code>An object is hashable if it has a hash value which never changes during its lifetime (it needs a __hash__() method), and can be compared to other objects (it needs an __eq__() or __cmp__() method). Hashable objects which compare equal must have the same hash value.
 
 Hashability makes an object usable as a dictionary key and a set member, because these data structures use the hash value internally.
 
 All of Python’s immutable built-in objects are hashable, while no mutable containers (such as lists or dictionaries) are. Objects which are instances of user-defined classes are hashable by default; they all compare unequal (except with themselves), and their hash value is derived from their id().
 </code></pre>
-
 <h1 id="_1">思考题：</h1>
 <ul>
 <li>你能在哈希表的基础上实现 dict 的其他操作吗？</li>

09_集合/set/index.html

@@ -247,13 +247,12 @@ <h1 id="python-frozenset">python frozenset</h1>
 它的常见就是用一个可迭代对象初始化它，然后只用来判重等操作。</p>
 <h1 id="set-adt">实现一个 set ADT</h1>
 <p>如何实现一个集合的 ADT 呢，其实还是个哈希表，哈希表不是有 key 和 value 嘛，咱把 value 置为 1 不就行了。</p>
-<pre><code class="py">class SetADT(HashTable):
+<pre><code class="language-py">class SetADT(HashTable):
 
     def add(self, key):
         # 集合其实就是一个 dict，只不过我们把它的 value 设置成 1
         return super(SetADT, self).add(key, True)
 </code></pre>
-
 <p>当然其它数学上的操作就麻烦点了，不过也很容易实现。</p>
 <h1 id="_2">思考题</h1>
 <ul>

10_递归/recursion/index.html

@@ -246,13 +246,12 @@ <h1 id="_2">什么是递归？</h1>
 这里举一个和其他很多老套的教科书一样喜欢举的例子，阶乘函数，我觉得用来它演示再直观不过。它的定义是这样的：</p>
 <p><img alt="" src="../fact.png" /></p>
 <p>我们很容易根据它的定义写出这样一个递归函数，因为它本身就是递归定义的。</p>
-<pre><code class="py">def fact(n):
+<pre><code class="language-py">def fact(n):
     if n == 0:
         return 1
     else:
         return n * fact(n-1)
 </code></pre>
-
 <p>看吧，几乎完全是按照定义来写的。我们来看下递归函数的几个特点:</p>
 <ul>
 <li>递归必须包含一个基本的出口(base case)，否则就会无限递归，最终导致栈溢出。比如这里就是 n == 0 返回 1</li>
@@ -262,29 +261,26 @@ <h1 id="_2">什么是递归？</h1>
 <h1 id="_3">调用栈</h1>
 <p>看了上一个例子你可能觉得递归好简单，先别着急，我们再举个简单的例子，上边我们并没有讲递归如何工作的。
 假如让你输出从 1 到 10 这十个数字，如果你是个正常人的话，我想你的第一反应都是这么写：</p>
-<pre><code class="py">def print_num(n):
+<pre><code class="language-py">def print_num(n):
     for i in range(1, n + 1):    # 注意很多编程语言使用的都是 从 0 开始的左闭右开区间, python 也不例外
         print(i)
 
 
 if __name__ == '__main__':
     print_num(10)
 </code></pre>
-
 <p>我们尝试写一个递归版本，不就是自己调用自己嘛：</p>
-<pre><code class="py">def print_num_recursive(n):
+<pre><code class="language-py">def print_num_recursive(n):
     if n &gt; 0:
         print_num_recursive(n-1)
         print(n)
 </code></pre>
-
 <p>你猜下它的输出？然后我们调换下 print 顺序，你再猜下它的输出</p>
-<pre><code class="py">def print_num_recursive_revserve(n):
+<pre><code class="language-py">def print_num_recursive_revserve(n):
     if n &gt; 0:
         print(n)
         print_num_recursive_revserve(n-1)
 </code></pre>
-
 <p>你能明白是为什么吗？我建议你运行下这几个小例子，它们很简单但是却能说明问题。
 计算机内部使用调用栈来实现递归，这里的栈一方面指的是内存中的栈区，一方面栈又是之前讲到的后进先出这种数据结构。
 每当进入递归函数的时候，系统都会为当前函数开辟内存保存当前变量值等信息，每个调用栈之间的数据互不影响，新调用的函数
@@ -295,7 +291,7 @@ <h1 id="_3">调用栈</h1>
 <h1 id="_4">用栈模拟递归</h1>
 <p>刚才说到了调用栈，我们就用栈来模拟一把。之前栈这一章我们讲了如何自己实现栈，不过这里为了不拷贝太多代码，我们直接用 collections.deque 就可以
 快速实现一个简单的栈。</p>
-<pre><code class="py">from collections import deque
+<pre><code class="language-py">from collections import deque
 
 
 class Stack(object):
@@ -321,11 +317,10 @@ <h1 id="_4">用栈模拟递归</h1>
     while not s.is_empty():    # 参数弹出
         print(s.pop())
 </code></pre>
-
 <p>这里结果也是输出 1 到 10，只不过我们是手动模拟了入栈和出栈的过程，帮助你理解计算机是如何实现递归的，是不是挺简单！现在你能明白为什么上边 print_num_recursive print_num_recursive_revserve 两个函数输出的区别了吗？</p>
 <h1 id="_5">尾递归</h1>
 <p>上边的代码示例(麻雀虽小五脏俱全)中实际上包含了两种形式的递归，一种是普通的递归，还有一种叫做尾递归：</p>
-<pre><code class="py">def print_num_recursive(n):
+<pre><code class="language-py">def print_num_recursive(n):
     if n &gt; 0:
         print_num_recursive(n-1)
         print(n)
@@ -336,7 +331,6 @@ <h1 id="_5">尾递归</h1>
         print(n)
         print_num_recursive_revserve(n-1)    # 尾递归
 </code></pre>
-
 <p>概念上它很简单，就是递归调用放在了函数的最后。有什么用呢？
 普通的递归, 每一级递归都产生了新的局部变量, 必须创建新的调用栈, 随着递归深度的增加, 创建的栈越来越多, 造成爆栈。虽然尾递归调用也会创建新的栈,
 但是我们可以优化使得尾递归的每一级调用共用一个栈!, 如此便可解决爆栈和递归深度限制的问题!
@@ -366,7 +360,7 @@ <h1 id="_6">汉诺塔问题</h1>
 <li>把 n-1 个盘子从 I 移动到 D，借助 S</li>
 </ul>
 <p>我们把它转换成代码：</p>
-<pre><code class="py">def hanoi_move(n, source, dest, intermediate):
+<pre><code class="language-py">def hanoi_move(n, source, dest, intermediate):
     if n &gt;= 1:  # 递归出口，只剩一个盘子
         hanoi_move(n-1, source, intermediate, dest)
         print(&quot;Move %s -&gt; %s&quot; % (source, dest))
@@ -384,7 +378,6 @@ <h1 id="_6">汉诺塔问题</h1>
 Move A -&gt; C
 &quot;&quot;&quot;
 </code></pre>
-
 <p><center>
 <img alt="三个盘子的汉诺塔解法" src="../hanoi.gif" />
 </center></p>