emoji testing

Author: Ric-Chang

docs/00_课程简介之笨方法学算法/why_and_how_to_learn.md

@@ -1,30 +1,30 @@
-# 什么是算法和數據結構？
+# 什麼是算法和數據結構？
 
 你可能會在一些教材上看到這句话：
 
 程序 = 算法 + 數據結構
 
-算法（Algorithm）：是指解题方案的准确而完整的描述，是一系列解决問題的清晰指令，算法代表着用系统的方法描述解决問題的策略机制。也就是說，能够對一定规范的输入，在有限時間内获得所要求的输出。
+算法（Algorithm）：是指解题方案的准确而完整的描述，是一系列解决問題的清晰指令，算法代表着用系统的方法描述解决問題的策略機制。也就是說，能够對一定規範的输入，在有限時間内获得所要求的输出。
 
-數據結構（Data Structures）：是计算机存储和组织數據的一種方式，可以用來高效地处理數據。
+數據結構（Data Structures）：是计算機存儲和組織數據的一種方式，可以用來高效地處理數據。
 
-举個例子：二分查找就是一個非常經典的算法，而二分查找經常需要作用在一個有序数组上。這裡二分就是一種折半的算法思想，
-而数组是我們最常用的一種數據結構，支持根據下标快速訪問。很多算法需要特定的數據結構來實現，所以經常把它们放到一块講。
+舉個例子：二分查找就是一個非常經典的算法，而二分查找經常需要作用在一個有序数組上。這裡二分就是一種折半的算法思想，
+而数組是我們最常用的一種數據結構，支持根據下標快速訪問。很多算法需要特定的數據結構來實現，所以經常把它們放到一塊講。
 
-實际上，在真正的项目開發中，大部分時間都是 从數據库取數據 -> 數據操作和結構化 -> 返回给前端，在數據操作過程中需要合理地抽象，
-组织、处理數據，如果选用了错誤的數據結構，就會造成代碼运行低效。這也是我們需要学习算法和數據結構的原因。
+實際上，在真正的項目開發中，大部分時間都是 從資料庫取數據 -> 數據操作和結構化 -> 返回给前端，在數據操作過程中需要合理地抽象，
+組織、處理數據，如果選用了错誤的數據結構，就會造成代碼運行低效。這也是我們需要學習算法和數據結構的原因。
 
-# 笨方法学算法
-這裡我們用一種很原始的『笨』方法來学习算法：纸笔模擬。
+# 笨方法學算法
+這裡我們用一種很原始的『笨』方法來學習算法：紙筆模擬。
 
-- 閱讀资料了解算法思想
-- 纸笔模擬嘗試理解
+- 閱讀資料了解算法思想
+- 紙筆模擬嘗試理解
 - 用自己熟悉的编程语言來實現
 - 單測
 
-# 小問題
+# 小問題 :smile:
 
 - 你還知道哪些經典的算法和數據結構？
-- 学习算法你覺得需要哪些预备知识？
+- 學習算法你覺得需要哪些预备知识？
 - 我們的業務代碼開發中會涉及到算法嗎？
 - 你了解 redis 嗎，你知道它有哪几個常用的數據結構嗎？你知道它的底层實現方式嗎？

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

@@ -1,6 +1,6 @@
 # Python 一切皆對象
 
-举個例子，在 python 中我們經常使用的 list
+舉個例子，在 python 中我們經常使用的 list
 
 ```py
 l = list()    # 實例化一個 list 對象 l
@@ -12,14 +12,14 @@ print(len(l))    # 调用對象的 `__len__` 方法
 
 在後面實現新的數據类型时，我們将使用 python 的 class 實現，它包含属性和方法。
 属性一般是使用某種特定的數據类型，而方法一般是對属性的操作。
-這裡你只需了解這么多就行了， 我們不會使用继承等特性。
+這裡你只需了解這麼多就行了， 我們不會使用继承等特性。
 
 
-# 什么是抽象數據类型 ADT
+# 什麼是抽象數據类型 ADT
 
-實际上 python 内置的 list 就可以看成一種抽象數據类型。
+實際上 python 内置的 list 就可以看成一種抽象數據类型。
 
-ADT: Abstract Data Type，抽象數據类型，我們在组合已有的數據結構來實現一種新的數據类型， ADT 定義了类型的數據和操作。
+ADT: Abstract Data Type，抽象數據类型，我們在組合已有的數據結構來實現一種新的數據类型， ADT 定義了类型的數據和操作。
 
 我們以抽象一個背包(Bag) 數據类型來說明，背包是一種容器类型，我們可以给它添加東西，也可以移除東西，并且我們想知道背包里
 有多少東西。于是我們可以定義一個新的數據类型叫做 Bag.
@@ -35,15 +35,15 @@ class Bag:
 影片中我們将使用 python 的 class 來實現一個新的容器类型叫做 Bag。
 
 
-# 實現 ADT 我們应该注意什么？
-- 如何选用恰當的數據結構作為存储？
-- 选取的數據結構能否满足 ADT 的功能需求
+# 實現 ADT 我們应该注意什麼？
+- 如何選用恰當的數據結構作為存儲？
+- 選取的數據結構能否满足 ADT 的功能需求
 - 實現效率如何？
 
 
 # 小問題：
-- 你了解 python 的魔術方法嗎？ 比如 `__len__` ，调用 len(l) 的时候發生了什么？
-- 你了解單測嗎？我們以後将使用 pytest 运行單元測试，保证我們實現的數據結構和算法是正确的。你可以网上搜索下它的簡單用法
+- 你了解 python 的魔術方法嗎？ 比如 `__len__` ，调用 len(l) 的时候發生了什麼？
+- 你了解單測嗎？我們以後将使用 pytest 運行單元測试，保证我們實現的數據結構和算法是正确的。你可以网上搜索下它的簡單用法
 
 # 延伸閱讀：
 

docs/02_数组和列表/array_and_list.md

@@ -1,23 +1,23 @@
 # 線性結構
-本節我們从最簡單和常用的線性結構開始，并結合 Python 语言本身内置的數據結構和其底层實現方式來講解。
+本節我們從最簡單和常用的線性結構開始，并結合 Python 语言本身内置的數據結構和其底层實現方式來講解。
 雖然本质上數據結構的思想是语言无關的，但是了解 Python 的實現方式有助于你避免一些坑。
 
 我們會在代碼中注释出操作的時間複雜度。
 
 
-# 数组 array
+# 数組 array
 
-数组是最常用到的一種線性結構，其實 python 内置了一個 array 模块，但是大部人甚至从來没用過它。
-Python 的 array 是内存连续、存储的都是同一數據类型的結構，而且只能存数值和字符。
+数組是最常用到的一種線性結構，其實 python 内置了一個 array 模塊，但是大部人甚至從來没用過它。
+Python 的 array 是内存连续、存儲的都是同一數據类型的結構，而且只能存数值和字符。
 
 我建議你课下看下 array 的文档：https://docs.python.org/2/library/array.html
 
 你可能很少會使用到它(我推荐你用 numpy.array)，我将在影片里簡單介绍下它的使用和工作方式，最常用的還是接下來要說的 list，
-本章最後我們會用 list 來實現一個固定长度、并且支持所有 Python 數據类型的数组 Array.
+本章最後我們會用 list 來實現一個固定长度、并且支持所有 Python 數據类型的数組 Array.
 
 
 # 列表 list
-如果你学過 C++，list 其實和 C++ STL（标准模板库）中的 vector 很类似，它可能是你的 Python 学习中使用最频繁的數據結構之一。
+如果你學過 C++，list 其實和 C++ STL（標准模板库）中的 vector 很类似，它可能是你的 Python 學習中使用最频繁的數據結構之一。
 這裡我們不再去自己實現 list，因為這是個 Python 提供的非常基础的數據类型，我會在影片中講解它的工作方式和内存分配策略，
 避免使用過程中碰到一些坑。當然如果你有毅力或者興趣的了解底层是如何實現的，可以看看 cpython 解释器的具體實現。
 
@@ -33,14 +33,14 @@ list.remove                           | O(n)           |
 ![](./list.png)
 
 # 用 list 實現 Array ADT
-講完了 list 让我們來實現一個定长的数组 Array ADT，在其他一些语言中，内置的数组結構就是定长的。
+講完了 list 让我們來實現一個定长的数組 Array ADT，在其他一些语言中，内置的数組結構就是定长的。
 這裡我們會使用 list 作為 Array 的一個成员（代理）。具體請参考影片講解和代碼示例，後面我們會使用到這個 Array 类。
 
 
 # 小問題
 - 你知道線性結構的查找，删除，訪問一個元素的平均時間複雜度嗎？(後面我們會介绍這個概念，现在你可以簡單地理解為一個操作需要的平均步骤)
-- list 内存重新分配的时候為什么要有冗余？不會浪费空間嗎？
-- 當你频繁的pop list 的第一個元素的时候，會發生什么？如果需要频繁在兩头增添元素，你知道更高效的數據結構嗎？後面我們會講到
+- list 内存重新分配的时候為什麼要有冗余？不會浪费空間嗎？
+- 當你频繁的pop list 的第一個元素的时候，會發生什麼？如果需要频繁在兩头增添元素，你知道更高效的數據結構嗎？後面我們會講到
 
 
 # 延伸閱讀

docs/03_链表/double_link_list.py

@@ -60,7 +60,7 @@ def appendleft(self, value):
 
     def remove(self, node):      # O(1)，傳入node 而不是 value 我們就能實現 O(1) 删除
         """remove
-        :param node  # 在 lru_cache 里實际上根據key 保存了整個node:
+        :param node  # 在 lru_cache 里實際上根據key 保存了整個node:
         """
         if node is self.root:
             return

docs/03_链表/linked_list.md

@@ -1,19 +1,19 @@
 # 鏈式結構
 
-上一節講到了支持随机訪問的線性結構，這次我們開始講鏈式結構, 影片里我會說下這兩種結構的區别，然後講解最常見的單鏈表和双鏈表。
+上一節講到了支持随機訪問的線性結構，這次我們開始講鏈式結構, 影片里我會說下這兩種結構的區别，然後講解最常見的單鏈表和双鏈表。
 之前在专栏文章[那些年，我們一起跪過的算法题[影片]](https://zhuanlan.zhihu.com/p/35175401)里實現過一個 lru_cache，
 使用到的就是循環双端鏈表，如果感覺這篇文章有點难理解，我們這裡将會循序渐进地來實現。
 後面講到哈希表的冲突解决方式的时候，我們會再次提到鏈表。
 
 上一節我們分析了 list 的各種操作是如何實現的，如果你還有印象的话，list
-在头部进行插入是個相當耗时的操作（需要把後面的元素一個一個挪個位置）。假如你需要频繁在数组兩头增删，list 就不太合适。
-今天我們介绍的鏈式結構将摆脱這個缺陷，當然了鏈式結構本身也有缺陷，比如你不能像数组一样随机根據下标訪問，你想查找一個元素只能老老實實从头遍历。
-所以嘛，学习和了解數據結構的原理和實現你才能准确地选择到底什么时候该用什么數據結構，而不是瞎选导致代碼性能很差。
+在头部进行插入是個相當耗时的操作（需要把後面的元素一個一個挪個位置）。假如你需要频繁在数組兩头增删，list 就不太合适。
+今天我們介绍的鏈式結構将摆脱這個缺陷，當然了鏈式結構本身也有缺陷，比如你不能像数組一样随機根據下標訪問，你想查找一個元素只能老老實實從头遍历。
+所以嘛，學習和了解數據結構的原理和實現你才能准确地選择到底什麼时候该用什麼數據結構，而不是瞎選导致代碼性能很差。
 
 
 # 單鏈表
 和線性結構不同，鏈式結構内存不连续的，而是一個個串起來的，這個时候就需要每個鏈接表的節點保存一個指向下一個節點的指針。
-這裡可不要混淆了列表和鏈表（它们的中文發音类似，但是列表 list 底层其實還是線性結構，鏈表才是真的通過指針關联的鏈式結構）。
+這裡可不要混淆了列表和鏈表（它們的中文發音类似，但是列表 list 底层其實還是線性結構，鏈表才是真的通過指針關联的鏈式結構）。
 看到指針你也不用怕，這裡我們用的 python，你只需要一個簡單赋值操作就能實現，不用担心 c 语言里复杂的指針。
 
 先來定義一個鏈接表的節點，刚才說到有一個指針保存下一個節點的位置，我們叫它 next， 當然還需要一個 value 属性保存值
@@ -32,7 +32,7 @@ class LinkedList(object):
     [root] -> [node0] -> [node1] -> [node2]
     """
 ```
-實現我們會在影片中用画图來模擬并且手動代碼實現，代碼里我們會标识每個步骤的時間複雜度。這裡請高度集中精力，
+實現我們會在影片中用画图來模擬并且手動代碼實現，代碼里我們會標识每個步骤的時間複雜度。這裡請高度集中精力，
 雖然鏈表的思想很簡單，但是想要正确写對鏈表的操作代碼可不容易，稍不留神就可能丢失一些步骤。
 這裡我們還是會用簡單的單測來验证代碼是否按照预期工作。
 
@@ -48,7 +48,7 @@ linked_list.remove(value)     | O(n)           |
 
 # 双鏈表
 上邊我們亲自實現了一個單鏈表，但是能看到很明显的問題，單鏈表雖然 append 是 O(1)，但是它的 find 和 remove 都是 O(n)的，
-因為删除你也需要先查找，而單鏈表查找只有一個方式就是从头找到尾，中間找到才退出。
+因為删除你也需要先查找，而單鏈表查找只有一個方式就是從头找到尾，中間找到才退出。
 這裡我之前提到過如果要實現一個 lru 缓存（訪問時間最久的踢出），我們需要在一個鏈表里能高效的删除元素，
 并把它追加到訪問表的最後一個位置，這個时候單鏈表就满足不了了，
 因為缓存在 dict 里查找的時間是 O(1)，你更新訪問顺序就 O(n)了，缓存就没了優势。
@@ -67,10 +67,10 @@ class Node(object):
 
 對， 就多了 prev，有啥優势嘛？
 
-- 看似我們反過來遍历双鏈表了。反過來从哪里開始呢？我們只要让 root 的 prev 指向 tail 節點，不就串起來了嗎？
+- 看似我們反過來遍历双鏈表了。反過來從哪里開始呢？我們只要让 root 的 prev 指向 tail 節點，不就串起來了嗎？
 - 直接删除節點，當然如果给的是一個值，我們還是需要查找這個值在哪個節點？ - 但是如果给了一個節點，我們把它拿掉，直接让它的前後節點互相指過去不就行了？哇欧，删除就是 O(1) 了，兩步操作就行啦
 
-好，废话不多說，我們在影片里介绍怎么實現一個双鏈表 ADT。你可以直接在本项目的 `docs/03_鏈表/double_link_list.py` 找到代碼。
+好，废话不多說，我們在影片里介绍怎麼實現一個双鏈表 ADT。你可以直接在本項目的 `docs/03_鏈表/double_link_list.py` 找到代碼。
 最後让我們看下它的時間複雜度:(這裡 CircularDoubleLinkedList 取大写字母缩写為 cdll)
 
 循環双端鏈表操作                       | 平均時間複雜度 |

docs/03_链表/linked_list.py

@@ -59,9 +59,9 @@ def __iter__(self):
             yield node.value
 
     def iter_node(self):
-        """遍历 从 head 節點到 tail 節點"""
+        """遍历 從 head 節點到 tail 節點"""
         curnode = self.root.next
-        while curnode is not self.tailnode:    # 从第一個節點開始遍历
+        while curnode is not self.tailnode:    # 從第一個節點開始遍历
             yield curnode
             curnode = curnode.next    # 移動到下一個節點
         if curnode is not None:
@@ -86,7 +86,7 @@ def remove(self, value):    # O(n)
         return -1  # 表明删除失败
 
     def find(self, value):    # O(n)
-        """ 查找一個節點，返回序号，从 0 開始
+        """ 查找一個節點，返回序号，從 0 開始
 
         :param value:
         """
@@ -107,7 +107,7 @@ def popleft(self):    # O(1)
         self.length -= 1
         value = headnode.value
 
-        if self.tailnode is headnode:   # 勘誤：增加單節點删除 tailnode 处理
+        if self.tailnode is headnode:   # 勘誤：增加單節點删除 tailnode 處理
             self.tailnode = None
         del headnode
         return value
@@ -122,7 +122,7 @@ def clear(self):
     def reverse(self):
         """反转鏈表"""
         curnode = self.root.next
-        self.tailnode = curnode  # 记得更新 tailnode，多了這個属性处理起來經常忘记
+        self.tailnode = curnode  # 记得更新 tailnode，多了這個属性處理起來經常忘记
         prevnode = None
 
         while curnode:

docs/03_链表/lru_cache.py

@@ -13,7 +13,7 @@ def fib(n):
 
 
 """
-下邊就來写一個缓存装饰器來優化它。傳统方法是用個数组记录之前计算過的值，但是這種方式不够 Pythonic
+下邊就來写一個缓存装饰器來優化它。傳统方法是用個数組记录之前计算過的值，但是這種方式不够 Pythonic
 """
 
 
@@ -40,13 +40,13 @@ def f(n):
 
 
 """
-問題來了，假如空間有限怎么办，我們不可能一直向缓存塞東西，當缓存达到一定個数之後，我們需要一種策略踢出一些元素，
+問題來了，假如空間有限怎麼办，我們不可能一直向缓存塞東西，當缓存达到一定個数之後，我們需要一種策略踢出一些元素，
 用來给新的元素腾出空間。
 一般缓存失效策略有
-- LRU(Least-Recently-Used): 替换掉最近請求最少的對象，實际中使用最广。cpu缓存淘汰和虚拟内存效果好，web应用欠佳
+- LRU(Least-Recently-Used): 替换掉最近請求最少的對象，實際中使用最广。cpu缓存淘汰和虚拟内存效果好，web应用欠佳
 - LFU(Least-Frequently-Used): 缓存污染問題(一個先前流行的缓存對象會在缓存中驻留很长時間)
 - First in First out(FIFO)
-- Random Cache: 随机选一個删除
+- Random Cache: 随機選一個删除
 
 LRU 是常用的一個，比如 redis 就實現了這個策略，這裡我們來模擬實現一個。
 要想實現一個 LRU，我們需要一種方式能够记录訪問的顺序，并且每次訪問之後我們要把最新使用到的元素放到最後（表示最新訪問）。
@@ -94,7 +94,7 @@ def __call__(self, func):
 
         - 這裡為了简化默认参数只有一個数字 n，假如可以傳入多個参数，如何确定缓存的key 呢？
         - 這裡實現没有考虑線程安全的問題，要如何才能實現線程安全的 LRU 呢？當然如果不是多線程环境下使用是不需要考虑的
-        - 假如這裡没有用内置的 dict，你能使用 redis 來實現這個 LRU 嗎，如果使用了 redis，我們可以存储更多數據到服务器。而使用字典實际上是缓存了Python进程里(localCache)。
+        - 假如這裡没有用内置的 dict，你能使用 redis 來實現這個 LRU 嗎，如果使用了 redis，我們可以存儲更多數據到服务器。而使用字典實際上是缓存了Python进程里(localCache)。
         - 這裡只是實現了 lru 策略，你能同时實現一個超时 timeout 参数嗎？比如像是memcache 實現的 lazy expiration 策略
         - LRU有個缺點就是，對于周期性的數據訪問會导致命中率迅速下降，有一種優化是 LRU-K，訪問了次数达到 k 次才會将數據放入缓存
         """
@@ -127,7 +127,7 @@ def test():
     print(time.time() - beg)
 
 
-# TODO 要怎么给 lru 写單測？
+# TODO 要怎麼给 lru 写單測？
 
 if __name__ == '__main__':
     test()

docs/04_队列/array_queue.py

@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 
 
-# NOTE: 从 array_and_list 第一章拷贝的代碼
+# NOTE: 從 array_and_list 第一章拷贝的代碼
 class Array(object):
 
     def __init__(self, size=32):