完成 队列和栈章节

Author: PegasusWang

4_队列/circular_queue.py renamed to 4_队列/array_queue.py

@@ -26,6 +26,10 @@ def __iter__(self):
             yield item
 
 
+class FullError(Exception):
+    pass
+
+
 class ArrayQueue(object):
     def __init__(self, maxsize):
         self.maxsize = maxsize
@@ -34,23 +38,40 @@ def __init__(self, maxsize):
         self.tail = 0
 
     def push(self, value):
-        self.array[self.head % self.maxsize] = value
+        if len(self) >= self.maxsize:
+            raise FullError('queue full')
+        self.array[self.head] = value
         self.head += 1
 
     def pop(self):
         value = self.array[self.tail % self.maxsize]
         self.tail += 1
         return value
 
+    def __len__(self):
+        return self.head-self.tail
+
 
 def test_queue():
+    import pytest    # pip install pytest
     size = 5
     q = ArrayQueue(size)
     for i in range(size):
         q.push(i)
 
+    with pytest.raises(FullError) as excinfo:   # 我们来测试是否真的抛出了异常
+        q.push(size)
+    assert 'full' in str(excinfo.value)
+
+    assert len(q) == 5
+
     assert q.pop() == 0
     assert q.pop() == 1
+
+    assert len(q) == 3
+
     assert q.pop() == 2
     assert q.pop() == 3
     assert q.pop() == 4
+
+    assert len(q) == 0

4_队列/deque.py

@@ -1 +1 @@
-# 留给读者练习
+# 留给读者练习，如果实在想不出，在第 5 章栈里 stack.py 会有实现

4_队列/queue_and_stack.md renamed to 4_队列/queue.md

@@ -7,7 +7,6 @@
 生活中的数据结构：
 
 - 队列。没错就是咱平常排队，第一个来的第一个走
-- 栈。好比在桶里头放盘子，先放的盘子放在了底下，后来的盘子放在上边。你要拿的时候，也是先拿最上边的。
 
 本章我们详细讲讲常用的队列
 
@@ -43,7 +42,21 @@
 
 想象一下，队列就俩操作，进进出出，一进一出，pop 和 push 操作。
 似乎只要两个下标 head, tail 就可以了。 当我们 push 的时候赋值并且前移 head，pop 的时候前移 tail 就可以了。你可以在纸上
-模拟下试试。
+模拟下试试。列队的长度就是 head-pop，这个长度必须不能大于初始化的最大程度。
+
+如果 head 先到了数组末尾咋办？重头来呗，只要我们保证 tail 不会超过 head 就行。
+
+head = 0,1,2,3,4 ... 0,1,2,3,4 ...
+
+重头再来，循环往复，仿佛一个轮回。。。。
+怎么重头来呢？看上边数组的规律你如果还想不起来用取模，估计小学数学是体育老师教的。
+
+```py
+maxsize = 5
+for i in range(100):
+    print(i % maxsize)
+```
+
 
 我们来实现一个空间有限的循环队列。ArrayQueue，它的实现很简单，但是缺点是需要预先知道队列的长度来分配内存。
 
@@ -68,9 +81,6 @@
 交给你一个艰巨的任务，实现双端队列 Deque（） ADT。你可以参考前几章的任何代码，挑战一下这个任务，别忘记写单元测试呦
 
 
-
 # 思考题
-
-
-
-
+- 你能用 python 的 deque 来实现 queue ADT 吗？
+- 哪些经典算法里用到了队列呢？

4_队列/queue.py

@@ -150,4 +150,4 @@ def test_queue():
     import pytest    # pip install pytest
     with pytest.raises(EmptyError) as excinfo:   # 我们来测试是否真的抛出了异常
         q.pop()   # 继续调用会抛出异常
-        assert 'empty queue' == excinfo.value
+    assert 'empty queue' == str(excinfo.value)

5_栈/stack.md

@@ -0,0 +1,50 @@
+# 栈
+
+栈这个词实际上在计算机科学里使用很多，除了数据结构外，还有内存里的栈区 （和堆对应），熟悉 C 系语言的话应该不会陌生。
+上一章我们讲到了先进先出 queue，其实用 python 的内置类型 collections.deque 或者我们自己实现的 LinkedList 来实现它都很简单。
+本章我们讲讲 后进先出的栈。
+
+生活中的数据结构：
+- 栈。好比在桶里头放盘子，先放的盘子放在了底下，后来的盘子放在上边。你要拿的时候，也是先拿最上边的。
+
+栈其实也很简单，因为基础操作就俩，一个 push 和一个 pop，咦，咋和队列一样的？
+确实方法名字一样，但是得到的结果可是不同的。
+
+
+# 栈 ADT
+
+上一章我介绍了我们怎样选取恰到的数据结构来实现新的 ADT？你能想到这里我们应该使用之前提到的哪个数据结构来实现吗？
+你的大脑可能开始高(gui)速(su)旋转了，上几章学过的 array, list, deque, LinkedList, CircularDoubleLinkedList, queue
+等在大脑里呼啸而过，这个时候可能已经一脸愁容了，到底该选啥？
+
+还用问嘛，当然是时间复杂度最小的啦，大部分情况下空间都是够用的。
+其实你会发现栈比队列还简单，因为它只在顶上操作（想象装着盘子的桶），如果有一种数据结构能方便在尾部增减元素不就满足需求了吗。
+这个时候如果你忘记了，可以翻翻前几章，看看哪个数据结构符合要求。
+
+想一下，似乎 CircularDoubleLinkedList 循环双端队列是满足的，因为增删最后一个元素都是 O(1)。
+不过看了下示例代码，似乎没有 pop() 方法，对，因为我已经把实现 deque 作为思考题了。😂
+如果之前你没写出来也没关系，这里我们会再实现它。
+
+
+视频里我们将借助 CircularDoubleLinkedList 实现 双端队列 Deque ，并且用 Deque 实现 Stack。
+
+
+# Stack over flow 什么鬼？
+嗯，stackoverflow 不是一个程序员问答网站吗？没错。
+函数的临时变量是存储在栈区的，如果你不幸写了一个没有出口的递归函数，就会这个错。不信你试试：
+
+
+```py
+def infinite_fib(n):
+    return infinite_fib(n-1) + infinite_fib(n-2)
+infinite_fib(10)
+```
+
+一大段输出之后就会出现异常： RecursionError: maximum recursion depth exceeded。
+后边会讲到递归，递归是初学者比较难理解的概念，在树的遍历等地方还会看到它。
+
+
+# 思考题
+- 上一章我们用数组实现了队列，其实也能用数组来实现 栈，你能自己用数组来实现一个栈的 ADT 吗？
+- 这里我们自己实现了 Deque，你能用 python 内置的 collections.deque 实现栈吗？有轮子能直接用的话看起来就简单多了
+- 哪些经典算法里使用到了栈呢？

5_栈/stack.py

@@ -0,0 +1,171 @@
+# -*- coding: utf-8 -*-
+
+# NOTE: 这里拷贝的 double_link_list.py 里的代码
+
+
+class Node(object):
+
+    def __init__(self, value=None, prev=None, next=None):
+        self.value, self.prev, self.next = value, prev, next
+
+
+class CircularDoubleLinkedList(object):
+    """循环双端链表 ADT
+    多了个循环其实就是把 root 的 prev 指向 tail 节点，串起来
+    """
+
+    def __init__(self, maxsize=None):
+        self.maxsize = maxsize
+        node = Node()
+        node.next, node.prev = node, node
+        self.root = node
+        self.length = 0
+
+    def __len__(self):
+        return self.length
+
+    def headnode(self):
+        return self.root.next
+
+    def tailnode(self):
+        return self.root.prev
+
+    def append(self, value):    # O(1), 你发现一般不用 for 循环的就是 O(1)，有限个步骤
+        if self.maxsize is not None and len(self) > self.maxsize:
+            raise Exception('LinkedList is Full')
+        node = Node(value=value)
+        tailnode = self.tailnode() or self.root
+
+        tailnode.next = node
+        node.prev = tailnode
+        node.next = self.root
+        self.root.prev = node
+        self.length += 1
+
+    def appendleft(self, value):
+        if self.maxsize is not None and len(self) > self.maxsize:
+            raise Exception('LinkedList is Full')
+        node = Node(value=value)
+        if self.root.next is self.root:   # empty
+            node.next = self.root
+            node.prev = self.root
+            self.root.next = node
+            self.root.prev = node
+        else:
+            node.prev = self.root
+            headnode = self.root.next
+            node.next = headnode
+            headnode.prev = node
+            self.root.next = node
+        self.length += 1
+
+    def remove(self, node):      # O(1)，传入node 而不是 value 我们就能实现 O(1) 删除
+        """remove
+        :param node  # 在 lru_cache 里实际上根据key 保存了整个node:
+        """
+        if node is self.root:
+            return
+        else:    #
+            node.prev.next = node.next
+            node.next.prev = node.prev
+        self.length -= 1
+        return node
+
+    def iter_node(self):
+        if self.root.next is self.root:
+            return
+        curnode = self.root.next
+        while curnode.next is not self.root:
+            yield curnode
+            curnode = curnode.next
+        yield curnode
+
+    def __iter__(self):
+        for node in self.iter_node():
+            yield node.value
+
+    def iter_node_reverse(self):
+        """相比单链表独有的反序遍历"""
+        if self.root.prev is self.root:
+            return
+        curnode = self.root.prev
+        while curnode.prev is not self.root:
+            yield curnode
+            curnode = curnode.prev
+        yield curnode
+
+
+############################################################
+# 分割线，下边是本章 内容实现
+############################################################
+
+
+class Deque(CircularDoubleLinkedList):   # 注意这里我们用到了继承，嗯，貌似我说过不会用啥 OOP 特性的，抱歉
+
+    def pop(self):
+        """删除尾节点"""
+        if len(self) == 0:
+            raise Exception('empty')
+        tailnode = self.tailnode()
+        value = tailnode.value
+        self.remove(tailnode)
+        return value
+
+    def popleft(self):
+        if len(self) == 0:
+            raise Exception('empty')
+        headnode = self.headnode()
+        value = headnode.value
+        self.remove(headnode)
+        return value
+
+
+def test_deque():
+    dq = Deque()
+    dq.append(1)
+
+    dq.append(2)
+    assert list(dq) == [1, 2]
+
+    dq.appendleft(0)
+    assert list(dq) == [0, 1, 2]
+
+    dq.pop()
+    assert list(dq) == [0, 1]
+
+    dq.popleft()
+    assert list(dq) == [1]
+
+    dq.pop()
+    assert len(dq) == 0
+
+
+class Stack(object):
+    def __init__(self):
+        self.deque = Deque()
+
+    def push(self, value):
+        self.deque.append(value)
+
+    def pop(self):
+        return self.deque.pop()
+
+
+def test_stack():
+    s = Stack()
+    s.push(0)
+    s.push(1)
+    s.push(2)
+
+    assert s.pop() == 2
+    assert s.pop() == 1
+    assert s.pop() == 0
+
+    import pytest    # pip install pytest
+    with pytest.raises(Exception) as excinfo:   # 我们来测试是否真的抛出了异常
+        s.pop()
+    assert 'empty' in str(excinfo.value)
+
+
+if __name__ == '__main__':
+    test_stack()

README.md

@@ -5,6 +5,11 @@
 笔者尝试录制视频教程帮助 Python 初学者掌握常用算法和数据结构，提升开发技能。
 本教程是付费教程，因为笔者录制的过程中除了购买软件、手写板等硬件之外，业余需要花费很多时间和精力来录制视频、查资料、编写课件和代码，希望大家体谅。
 
+## 痛点
+- 讲 Python 数据结构和算法的资料很少
+- 很多自学 Python 的工程师对基础不够重视，面试也发现很多数据结构和算法不过关
+- 缺少工程应用场景下的讲解，很多讲算法的资料太『教科书化』
+
 ## 作者简介
 目前就职于[知乎](https://www.zhihu.com/people/pegasus-wang/activities)，从实习期间接触 Python 起一直从事 Python 网站后端开发，有一定 Python 的使用和实践经验。
 
@@ -31,9 +36,9 @@
 - 课程简介之笨方法学算法
 - 抽象数据类型 ADT，面向对象编程
 - 数组和列表
-- 链表
-- 高级链表。双链表，循环双端链表
-- 队列和栈，双端队列
+- 链表，高级链表。双链表，循环双端链表
+- 队列，双端队列，循环双端队列
+- 栈
 - 算法分析，时间复杂度 大O 表示法
 - 哈希表，散列冲突
 - 字典和集合
@@ -88,8 +93,16 @@ Python 抽象程度比较高， 我们能用更少的代码来实现功能，同
 
 [抱歉，我是开发，你居然让我写单测[视频]](https://zhuanlan.zhihu.com/p/35352024)
 
-- 视频演示更加直观
-- 演示代码实现思路
+
+## 课程特点
+
+- 讲义循序渐进，结合自己的学习和使用经验讲解。github 上实时更新
+- 视频演示更加直观易懂
+- 演示代码实现思路，现场编写
+- 偏向工程应用和代码实现。代码直接可以用。
+- 良好的工程实践：[编码之前碎碎念(工程实践)](http://python-web-guide.readthedocs.io/zh/latest/codingstyle/codingstyle.html)。这是很多看了几本书没有太多实践经验就敢讲课的培训班老师教不了的。
+- 每个实现都会有单测来验证，培养良好的工程习惯
+- 结合 cpython 底层实现讲解（比如list 内存分配策略等）
 
 ## 资料
 
@@ -109,6 +122,7 @@ Python 抽象程度比较高， 我们能用更少的代码来实现功能，同
     - 使用场景，什么时候用
 - 自己尝试实现，如果抛开视频自己写起来有困难可以多看几次视频，一定要自己手动实现。很多面试可能会让手写
 - 每章讲义后边都会有我设计的几个小问题，最好能够回答上来
+- 最好按照顺序循序渐进，每章都会有铺垫和联系
 
 ## 课程目标
 掌握基本的算法和数据结构原理，能独立使用 Python 语言实现，能在日常开发中灵活选用数据结构。
@@ -122,3 +136,7 @@ Python 抽象程度比较高， 我们能用更少的代码来实现功能，同
 - Vscode
 - Vim
 
+
+## 勘误
+
+如果你觉得哪里讲错了，可以在github 上提 issue 讨论，我会修改内容并重新录制视频。