Merge branch 'master' of github.com:PegasusWang/python_data_structures_and_algorithms

Author: wangningning

README.md

@@ -8,7 +8,9 @@
 ## 链接
 
 [网上阅读《Python 算法与数据结构教程 》](http://ningning.today/python_data_structures_and_algorithms/)
+
 [github 链接](https://github.com/PegasusWang/python_data_structures_and_algorithms)
+
 [readthedoc 电子书下载](http://python-data-structures-and-algorithms.readthedocs.io/zh/latest/)
 
 ## 痛点
@@ -124,7 +126,7 @@ Python 抽象程度比较高， 我们能用更少的代码来实现功能，同
 ## 资料
 
 - 视频。包含所有讲解视频
-- 代码示例。所有代码我会放到 github 上
+- 代码示例。所有代码我会放到 github 上。注意每一章目录里都有 py 文件，在电子书里看不到。clone 下代码找到对应目录里的 python 文件即是每章涉及到的代码。
 - markdown 讲义，包含视频内容的提要等内容
 - 延伸阅读。我会附上一些阅读资料方便想深入学习的同学
 
@@ -171,9 +173,12 @@ Python 抽象程度比较高， 我们能用更少的代码来实现功能，同
 
 安装依赖：
 ```sh
-pip install mkdocs    # 制作电子书
+pip install mkdocs    # 制作电子书, http://markdown-docs-zh.readthedocs.io/zh_CN/latest/
 # https://stackoverflow.com/questions/27882261/mkdocs-and-mathjax/31874157
 pip install https://github.com/mitya57/python-markdown-math/archive/master.zip
+
+# 或者直接
+pip install -r requirements.txt
 ```
 
 编写并查看：

docs/12_基本排序算法/basic_sort.md

@@ -0,0 +1,145 @@
+# 基本排序算法
+从本章开始讲常见的基于比较的排序算法，先讲三个简单的但是时间复杂度却不太理想的排序算法，包括冒泡排序、选择排序和插入排序。
+
+
+# 冒泡排序
+bubble sort 可以说是最简单的一种排序算法了，它的思想如下。对一个数组进行 n 轮迭代，每次比较相邻两个元素，
+如果相邻的元素前者大于后者，就交换它们。因为直接在元素上操作而不是返回新的数组，所以是一个 inplace 的操作。
+这里冒泡的意思其实就是每一轮冒泡一个最大的元素就会通过不断比较和交换相邻元素使它转移到最右边。
+
+你可以想象假如有 10 个小盆友从左到右站成一排，个头不等。老师想让他们按照个头从低到高站好，于是他开始喊口号。
+每喊一次，从第一个小盆友开始，相邻的小朋友如果身高不是正序就会两两调换，就这样第一轮个头最高的排到了最右边。(冒泡到最右边)
+第二轮依次这么来，从第一个小朋友开始两两交换，这样次高的小盆友又排到了倒数第二个位置。依次类推。
+
+
+我们在视频里手动模拟下它的过程。
+
+
+```py
+import random
+
+
+def bubble_sort(seq):  # O(n^2), n(n-1)/2 = 1/2(n^2 + n)
+    n = len(seq)
+    for i in range(n-1):
+        print(seq)    # 我打印出来让你看清楚每一轮最高、次高、次次高...的小朋友会冒泡到右边
+        for j in range(n-1-i):  # 这里之所以 n-1 还需要 减去 i 是因为每一轮冒泡最大的元素都会冒泡到最后，无需再比较
+            if seq[j] > seq[j+1]:
+                seq[j], seq[j+1] = seq[j+1], seq[j]
+	print(seq)
+
+
+def test_bubble_sort():
+    seq = list(range(10))  # 注意 python3 返回迭代器，所以我都用 list 强转了，python2 range 返回的就是 list
+    random.shuffle(seq)   # shuffle inplace 操作，打乱数组
+    bubble_sort(seq)
+    assert seq == sorted(seq)  # 注意呦，内置的 sorted 就不是 inplace 的，它返回一个新的数组，不影响传入的参数
+
+""" 我打印出来让你看到每次从最高到次高的小盆友就这么排好序了，因为是随机数，你第一个没有排序的数组应该和我的不一样
+[3, 4, 5, 0, 9, 1, 7, 8, 6, 2]
+[3, 4, 0, 5, 1, 7, 8, 6, 2, 9]
+[3, 0, 4, 1, 5, 7, 6, 2, 8, 9]
+[0, 3, 1, 4, 5, 6, 2, 7, 8, 9]
+[0, 1, 3, 4, 5, 2, 6, 7, 8, 9]
+[0, 1, 3, 4, 2, 5, 6, 7, 8, 9]
+[0, 1, 3, 2, 4, 5, 6, 7, 8, 9]
+[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+"""
+```
+
+
+
+# 选择排序
+刚才看到冒泡是每轮迭代中，如果相邻的两个元素前者大于后者了就交换两个相邻元素(假设正序排序)。其实还有一种思路就是，
+每次我们找到最小的元素插入迭代的起始位置，这样每个位置从它自己的位置开始它就是最小的了，一圈下来数组就有序了。
+选择可以理解为 一个 0 到 n-1 的迭代，每次向后查找选择一个最小的元素。
+
+同样小盆友又来啦，这次我们从第一个开始，从头到尾找一个个头最小的小盆友，然后把它和第一个小盆友交换。
+然后从第二个小盆友开始采取同样的策略，这样一圈下来小盆友就有序了。
+
+```py
+def select_sort(seq):
+    n = len(seq)
+    for i in range(n-1):
+        min_idx = i    # 我们假设当前下标的元素是最小的
+        for j in range(i+1, n):    # 从 i 的后边开始找到最小的元素，得到它的下标
+            if seq[j] < seq[min_idx]:
+                min_idx = j    # 一个 j 循环下来之后就找到了最小的元素它的下标
+        if min_idx != i:    # swap
+            seq[i], seq[min_idx] = seq[min_idx], seq[i]
+
+
+def test_select_sort():
+    seq = list(range(10))
+    random.shuffle(seq)
+    select_sort(seq)
+    assert seq == sorted(seq)
+
+"""
+[4, 7, 5, 3, 6, 0, 2, 9, 8, 1]
+[0, 7, 5, 3, 6, 4, 2, 9, 8, 1]
+[0, 1, 5, 3, 6, 4, 2, 9, 8, 7]
+[0, 1, 2, 3, 6, 4, 5, 9, 8, 7]
+[0, 1, 2, 3, 6, 4, 5, 9, 8, 7]
+[0, 1, 2, 3, 4, 6, 5, 9, 8, 7]
+[0, 1, 2, 3, 4, 5, 6, 9, 8, 7]
+[0, 1, 2, 3, 4, 5, 6, 9, 8, 7]
+[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+
+"""
+```
+
+
+# 插入排序
+插入排序很多教科书都是用扑克牌的例子讲的，想象你手里有一些扑克牌，它们顺序是散乱的，现在需要你把它们整理成有序的，你会怎么做呢？
+首先拿最顶上的一张，然后拿第二张，第二张点数大，你就把第二张放在第一张的下边，否则放在第一张上边。
+当你拿第三张的时候，你同样会找到适合它大小的位置插入进去。
+
+换成小朋友一样，第一个小盆友只有一个人我们假设是有序的，然后第二个小盆友会跟第一个比，如果第一个高就交换位置。
+接下来第三个小盆友从第二个位置开始比较，如果没第二个高就交换位置，然后没第一个高也交换位置，保持前边三个小盆友身高有序就好。
+依次类推，等到最后一个小盆友也转移到合适的位置，整个队列就是有序的了。
+
+插入排序就是这个道理, 每次挑选下一个元素插入已经排序的数组中,初始时已排序数组只有一个元素。我们就直接上代码吧。
+
+
+```py
+def insertion_sort(seq):
+    """ 每次挑选下一个元素插入已经排序的数组中,初始时已排序数组只有一个元素"""
+    n = len(seq)
+    print(seq)
+    for i in range(1, n):
+        value = seq[i]    # 保存当前位置的值，因为转移的过程中它的位置可能被覆盖
+        # 找到这个值的合适位置，使得前边的数组有序 [0,i] 有序
+        pos = i
+        while pos > 0 and value < seq[pos-1]:
+            seq[pos] = seq[pos-1]  # 如果前边的元素比它大，就让它一直前移
+            pos -= 1
+        seq[pos] = value    # 找到了合适的位置赋值就好
+        print(seq)
+
+
+""" 不断把新元素放到已经有序的数组中
+[1, 7, 3, 0, 9, 4, 8, 2, 6, 5]
+[1, 7, 3, 0, 9, 4, 8, 2, 6, 5]
+[1, 3, 7, 0, 9, 4, 8, 2, 6, 5]
+[0, 1, 3, 7, 9, 4, 8, 2, 6, 5]
+[0, 1, 3, 7, 9, 4, 8, 2, 6, 5]
+[0, 1, 3, 4, 7, 9, 8, 2, 6, 5]
+[0, 1, 3, 4, 7, 8, 9, 2, 6, 5]
+[0, 1, 2, 3, 4, 7, 8, 9, 6, 5]
+[0, 1, 2, 3, 4, 6, 7, 8, 9, 5]
+[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+"""
+```
+
+
+# 思考题
+- 本章介绍的几个排序算法平均时间复杂度是多少？
+- 请你补充插入排序的单元测试代码
+
+
+# 延伸阅读
+- 《Data Structures and Algorithms in Python》第5章

docs/12_基本排序算法/basic_sort.py

@@ -0,0 +1,54 @@
+# -*- coding: utf-8 -*-
+
+
+import random
+
+
+def bubble_sort(seq):  # O(n^2), n(n-1)/2 = 1/2(n^2 + n)
+    n = len(seq)
+    for i in range(n-1):
+        print(seq)    # 我打印出来让你看清楚每一轮最高、次高、次次高...的小朋友会冒泡到右边
+        for j in range(n-1-i):  # 这里之所以 n-1 还需要 减去 i 是因为每一轮冒泡最大的元素都会冒泡到最后，无需再比较
+            if seq[j] > seq[j+1]:
+                seq[j], seq[j+1] = seq[j+1], seq[j]
+        print(seq)
+
+
+def test_bubble_sort():
+    seq = list(range(10))  # 注意 python3 返回迭代器，所以我都用 list 强转了，python2 range 返回的就是 list
+    random.shuffle(seq)   # shuffle inplace 操作，打乱数组
+    bubble_sort(seq)
+    assert seq == sorted(seq)  # 注意呦，内置的 sorted 就不是 inplace 的，它返回一个新的数组，不影响传入的参数
+
+
+def select_sort(seq):
+    n = len(seq)
+    for i in range(n-1):
+        min_idx = i    # 我们假设当前下标的元素是最小的
+        for j in range(i+1, n):    # 从 i 的后边开始找到最小的元素，得到它的下标
+            if seq[j] < seq[min_idx]:
+                min_idx = j    # 一个 j 循环下来之后就找到了最小的元素它的下标
+        if min_idx != i:    # swap
+            seq[i], seq[min_idx] = seq[min_idx], seq[i]
+
+
+def test_select_sort():
+    seq = list(range(10))
+    random.shuffle(seq)
+    select_sort(seq)
+    assert seq == sorted(seq)
+
+
+def insertion_sort(seq):
+    """ 每次挑选下一个元素插入已经排序的数组中,初始时已排序数组只有一个元素"""
+    n = len(seq)
+    print(seq)
+    for i in range(1, n):
+        value = seq[i]    # 保存当前位置的值，因为转移的过程中它的位置可能被覆盖
+        # 找到这个值的合适位置，使得前边的数组有序 [0,i] 有序
+        pos = i
+        while pos > 0 and value < seq[pos-1]:
+            seq[pos] = seq[pos-1]  # 如果前边的元素比它大，就让它一直前移
+            pos -= 1
+        seq[pos] = value    # 找到了合适的位置赋值就好
+        print(seq)

docs/13_高级排序算法/advanced_sorting.md

@@ -0,0 +1,7 @@
+# 高级排序算法
+
+本章开始讲几个高级一些的排序算法，因为涉及到分治、递归和一些高级数据结构等，所以比前一章节的基本排序要稍微难理解一些。包括：
+
+- [分治法与归并排序](./merge_sort.md)
+- [快速排序](./quick_sort.md)
+- [堆和堆排序](./heap_sort.md)

docs/13_高级排序算法/heap_sort.md

@@ -0,0 +1,103 @@
+# 分治法 (Divide and Conquer)
+
+很多有用的算法结构上是递归的，为了解决一个特定问题，算法一次或者多次递归调用其自身以解决若干子问题。
+这些算法典型地遵循分治法的思想：将原问题分解为几个规模较小但是类似于原问题的子问题，递归求解这些子问题，
+然后再合并这些问题的解来建立原问题的解。
+
+分治法在每层递归时有三个步骤：
+
+- **分解**原问题为若干子问题，这些子问题是原问题的规模最小的实例
+- **解决**这些子问题，递归地求解这些子问题。当子问题的规模足够小，就可以直接求解
+- **合并**这些子问题的解成原问题的解
+
+
+# 归并排序
+现在我们就来看下归并排序是是如何利用分治法解决问题的。
+
+- **分解**：将待排序的 n 个元素分成各包含 n/2 个元素的子序列
+- **解决**：使用归并排序递归排序两个子序列
+- **合并**：合并两个已经排序的子序列以产生已排序的答案
+
+考虑我们排序这个数组：[10,23,51,18,4,31,13,5] ，我们递归地将数组进行分解
+
+![](./merge_sort_split.png)
+
+当数组被完全分隔成只有单个元素的数组时，我们需要把它们合并回去，每次两两合并成一个有序的序列。
+
+![](./merge_sort_merge.png)
+
+用递归代码来描述这个问题：
+
+```py
+def merge_sort(seq):
+    if len(seq) <= 1:   # 只有一个元素是递归出口
+        return seq
+    else:
+        mid = int(len(seq)/2)
+        left_half = merge_sort(seq[:mid])
+        right_half = merge_sort(seq[mid:])
+
+        # 合并两个有序的数组
+        new_seq = merge_sorted_list(left_half, right_half)
+        return new_seq
+```
+
+注意我们这里有一个函数没实现，就是如何合并两个有序数组 merge_sorted_list。其实你在纸上画一画，
+合并两个有序数组并不难实现。
+
+![](./merge_sorted_array.png)
+
+
+```py
+def merge_sorted_list(sorted_a, sorted_b):
+    """ 合并两个有序序列，返回一个新的有序序列
+
+    :param sorted_a:
+    :param sorted_b:
+    """
+    length_a, length_b = len(sorted_a), len(sorted_b)
+    a = b = 0
+    new_sorted_seq = list()
+
+    while a < length_a and b < length_b:
+        if sorted_a[a] < sorted_b[b]:
+            new_sorted_seq.append(sorted_a[a])
+            a += 1
+        else:
+            new_sorted_seq.append(sorted_b[b])
+            b += 1
+
+    # 最后别忘记把多余的都放到有序数组里
+    while a < length_a:
+        new_sorted_seq.append(sorted_a[a])
+        a += 1
+
+    while b < length_b:
+        new_sorted_seq.append(sorted_b[b])
+        b += 1
+
+    return new_sorted_seq
+```
+
+这样就实现了归并排序，并且你会发现它返回一个新的数组而不是修改原有数组。
+
+
+# 时间复杂度
+我们来简单看下它归并排序的时间复杂度，假设排序 n 个数字时间复杂度是 T(n)，这里为了方便假设 n 是 2 的幂
+
+\begin{align}
+T(n)= \begin{cases} c, & \text {if $n$ = 1} \\ 2T(n/2)+cn, & \text{if $n$ > 1} \end{cases}
+\end{align}
+
+![](./merge_sort_recursion_tree.png)
+
+总的代价是 $cnlg(n)+cn$ ，忽略常数项可以认为是  O(nlg(n))
+
+# 思考题
+- 请你完成归并排序的单元测试
+- 这里实现的归并排序是 inplace 的吗？
+- 归并排序是稳定的吗？稳定指的是排序前后相同大小的数字依然保持相对顺序。
+
+# 延伸阅读
+- 《算法导论》第 2 章和第 4 章，你需要了解下『主定理』，以及如何求解形如 $T(n)=aT(n/b) + f(n)$ 的递归式复杂度
+-  了解算法导论上递归式的三种求解方法：代入法，递归树法，主方法

docs/13_高级排序算法/merge_sort.md

@@ -0,0 +1,51 @@
+# -*- coding: utf-8 -*-
+
+
+def merge_sort(seq):
+    if len(seq) <= 1:   # 只有一个元素是递归出口
+        return seq
+    else:
+        mid = int(len(seq)/2)
+        left_half = merge_sort(seq[:mid])
+        right_half = merge_sort(seq[mid:])
+
+        # 合并两个有序的数组
+        new_seq = merge_sorted_list(left_half, right_half)
+        return new_seq
+
+
+def merge_sorted_list(sorted_a, sorted_b):
+    """ 合并两个有序序列，返回一个新的有序序列
+
+    :param sorted_a:
+    :param sorted_b:
+    """
+    length_a, length_b = len(sorted_a), len(sorted_b)
+    a = b = 0
+    new_sorted_seq = list()
+
+    while a < length_a and b < length_b:
+        if sorted_a[a] < sorted_b[b]:
+            new_sorted_seq.append(sorted_a[a])
+            a += 1
+        else:
+            new_sorted_seq.append(sorted_b[b])
+            b += 1
+
+    while a < length_a:
+        new_sorted_seq.append(sorted_a[a])
+        a += 1
+
+    while b < length_b:
+        new_sorted_seq.append(sorted_b[b])
+        b += 1
+
+    return new_sorted_seq
+
+
+def test_merge_sort():
+    import random
+    seq = list(range(10))
+    random.shuffle(seq)
+    assert merge_sort(seq) == sorted(seq)
+