Deployed 662bdbc with MkDocs version: 1.0.4

Author: PegasusWang

03_链表/__pycache__/double_link_list.cpython-36-PYTEST.pyc

@@ -2,6 +2,8 @@
 
 # NOTE: 这里拷贝的 double_link_list.py 里的代码
 
+from collections import deque
+
 
 class Node(object):
 
@@ -151,6 +153,21 @@ def pop(self):
         return self.deque.pop()
 
 
+class Stack2(object):
+
+    def __init__(self):
+        self._deque = deque()
+
+    def push(self, value):
+        return self._deque.append(value)
+
+    def pop(self):
+        return self._deque.pop()
+
+    def empty(self):
+        return len(self._deque) == 0
+
+
 def test_stack():
     s = Stack()
     s.push(0)

03_链表/__pycache__/linked_list.cpython-27-PYTEST.pyc

@@ -98,6 +98,9 @@
     <li class="toctree-l2"><a href="#_3">思考题</a></li>
 
 
+    <li class="toctree-l2"><a href="#leetcode">Leetcode 练习</a></li>
+    
+
     </ul>
 	    </li>
 
@@ -264,6 +267,8 @@ <h1 id="_3">思考题</h1>
 <li>这里我们自己实现了 Deque，你能用 python 内置的 collections.deque 实现栈吗？有轮子能直接用的话看起来就简单多了，这里我们为了学习数据结构的实现就避免了直接使用内置结构</li>
 <li>哪些经典算法里使用到了栈呢？</li>
 </ul>
+<h1 id="leetcode">Leetcode 练习</h1>
+<p>https://leetcode.com/problems/implement-queue-using-stacks/</p>
 
             </div>
           </div>

05_栈/stack.py

@@ -245,15 +245,14 @@ <h1 id="_1">快速排序</h1>
 <p><img alt="" src="../quick_sort.png" /></p>
 <p>根据这个想法我们可以快速写出快排的代码，简直就是在翻译上边的描述：</p>
 <pre><code class="py">def quicksort(array):
-    if len(array) &lt; 2:   # 递归出口，空数组或者只有一个元素的数组都是有序的
+    size = len(array)
+    if not array or size &lt; 2:  # NOTE: 递归出口，空数组或者只有一个元素的数组都是有序的
         return array
-    else:
-        pivot_index = 0    # 选择第一个元素作为主元 pivot
-        pivot = array[pivot_index]
-        less_part = [i for i in array[pivot_index+1:] if i &lt;= pivot]
-        great_part = [i for i in array[pivot_index+1:] if i &gt; pivot]
-        return quicksort(less_part) + [pivot] + quicksort(great_part)
-
+    pivot_idx = 0
+    pivot = array[pivot_idx]
+    less_part = [array[i] for i in range(size) if array[i] &lt;= pivot and pivot_idx != i]
+    great_part = [array[i] for i in range(size) if array[i] &gt; pivot and pivot_idx != i]
+    return quicksort(less_part) + [pivot] + quicksort(great_part)
 
 def test_quicksort():
     import random

05_栈/stack/index.html

@@ -2,14 +2,14 @@
 
 
 def quicksort(array):
-    if len(array) < 2:   # 递归出口，空数组或者只有一个元素的数组都是有序的
+    size = len(array)
+    if not array or size < 2:  # NOTE: 递归出口，空数组或者只有一个元素的数组都是有序的
         return array
-    else:
-        pivot_index = 0    # 选择第一个元素作为主元 pivot
-        pivot = array[pivot_index]
-        less_part = [i for i in array[pivot_index+1:] if i <= pivot]
-        great_part = [i for i in array[pivot_index+1:] if i > pivot]
-        return quicksort(less_part) + [pivot] + quicksort(great_part)
+    pivot_idx = 0
+    pivot = array[pivot_idx]
+    less_part = [array[i] for i in range(size) if array[i] <= pivot and pivot_idx != i]
+    great_part = [array[i] for i in range(size) if array[i] > pivot and pivot_idx != i]
+    return quicksort(less_part) + [pivot] + quicksort(great_part)
 
 
 def test_quicksort():
@@ -23,7 +23,7 @@ def quicksort_inplace(array, beg, end):    # 注意这里我们都用左闭右
     if beg < end:    # beg == end 的时候递归出口
         pivot = partition(array, beg, end)
         quicksort_inplace(array, beg, pivot)
-        quicksort_inplace(array, pivot+1, end)
+        quicksort_inplace(array, pivot + 1, end)
 
 
 def partition(array, beg, end):

11_线性查找与二分查找/__pycache__/search.cpython-27-PYTEST.pyc

@@ -1,6 +1,7 @@
 # -*- coding: utf-8 -*-
 
 
+
 class BinTreeNode(object):
     def __init__(self, data, left=None, right=None):
         self.data, self.left, self.right = data, left, right
@@ -47,6 +48,30 @@ def reverse(self, subtree):
             self.reverse(subtree.left)
             self.reverse(subtree.right)
 
+    def layer_trav(self, subtree):
+        cur_nodes = [subtree]
+        next_nodes = []
+        while cur_nodes or next_nodes:
+            for node in cur_nodes:
+                print(node.data)
+                if node.left:
+                    next_nodes.append(node.left)
+                if node.right:
+                    next_nodes.append(node.right)
+            cur_nodes = next_nodes  # 继续遍历下一层
+            next_nodes = []
+
+    def layer_trav_use_queue(self, subtree):
+        q = Queue()
+        q.append(subtree)
+        while not q.empty():
+            cur_node = q.pop()
+            print(cur_node.data)
+            if cur_node.left:
+                q.append(cur_node.left)
+            if cur_node.right:
+                q.append(cur_node.right)
+
 
 node_list = [
     {'data': 'A', 'left': 'B', 'right': 'C', 'is_root': True},
@@ -63,7 +88,13 @@ def reverse(self, subtree):
 
 
 btree = BinTree.build_from(node_list)
+print('====先序遍历=====')
 btree.preorder_trav(btree.root)
+print('====层序遍历=====')
+btree.layer_trav(btree.root)
+print('====用队列层序遍历=====')
+btree.layer_trav_use_queue(btree.root)
+
 btree.reverse(btree.root)
-print('====我是华丽丽滴分割线=====')
+print('====反转之后的结果=====')
 btree.preorder_trav(btree.root)

13_高级排序算法/__pycache__/quicksort.cpython-27-PYTEST.pyc

@@ -170,13 +170,16 @@
     <li class="toctree-l2"><a href="#_6">二叉树的遍历</a></li>
 
 
-    <li class="toctree-l2"><a href="#_7">反转二叉树</a></li>
+    <li class="toctree-l2"><a href="#_7">二叉树层序遍历</a></li>
 
 
-    <li class="toctree-l2"><a href="#_8">练习题</a></li>
+    <li class="toctree-l2"><a href="#_8">反转二叉树</a></li>
 
 
-    <li class="toctree-l2"><a href="#_9">延伸阅读</a></li>
+    <li class="toctree-l2"><a href="#_9">练习题</a></li>
+    
+
+    <li class="toctree-l2"><a href="#_10">延伸阅读</a></li>
 
 
     </ul>
@@ -413,7 +416,53 @@ <h1 id="_6">二叉树的遍历</h1>
 </code></pre>
 
 <p>怎么样是不是挺简单的，比较直白的递归函数。如果你不明白，视频里我们会画个图来说明。</p>
-<h1 id="_7">反转二叉树</h1>
+<h1 id="_7">二叉树层序遍历</h1>
+<p>除了递归的方式遍历之外，我们还可以使用层序遍历的方式。层序遍历比较直白，就是从根节点开始按照一层一层的方式遍历节点。
+我们可以从根节点开始，之后把所有当前层的孩子都按照从左到右的顺序放到一个列表里，下一次遍历所有这些孩子就可以了。</p>
+<pre><code class="py">    def layer_trav(self, subtree):
+        cur_nodes = [subtree]
+        next_nodes = []
+        while cur_nodes or next_nodes:
+            for node in cur_nodes:
+                print(node.data)
+                if node.left:
+                    next_nodes.append(node.left)
+                if node.right:
+                    next_nodes.append(node.right)
+            cur_nodes = next_nodes  # 继续遍历下一层
+            next_nodes = []
+</code></pre>
+
+<p>还有一种方式就是使用一个队列，之前我们知道队列是一个先进先出结构，如果我们按照一层一层的顺序从左往右把节点放到一个队列里，
+也可以实现层序遍历：</p>
+<pre><code class="py">    def layer_trav_use_queue(self, subtree):
+        q = Queue()
+        q.append(subtree)
+        while not q.empty():
+            cur_node = q.pop()
+            print(cur_node.data)
+            if cur_node.left:
+                q.append(cur_node.left)
+            if cur_node.right:
+                q.append(cur_node.right)
+
+
+from collections import deque
+class Queue(object):  # 借助内置的 deque 我们可以迅速实现一个 Queue
+    def __init__(self):
+        self._items = deque()
+
+    def append(self, value):
+        return self._items.append(value)
+
+    def pop(self):
+        return self._items.popleft()
+
+    def empty(self):
+        return len(self._items) == 0
+</code></pre>
+
+<h1 id="_8">反转二叉树</h1>
 <p>之所以单拎出来说这个是因为 mac 下著名的 brew 工具作者据说是因为面试 google 白板编程没写出来反转二叉树跪了。然后人家就去了苹果 😂。其实吧和遍历操作相比也没啥太大区别，递归交换就是了：</p>
 <pre><code class="py">    def reverse(self, subtree):
         if subtree is not None:
@@ -422,14 +471,15 @@ <h1 id="_7">反转二叉树</h1>
             self.reverse(subtree.right)
 </code></pre>
 
-<h1 id="_8">练习题</h1>
+<h1 id="_9">练习题</h1>
 <ul>
 <li>请你完成二叉树的中序遍历和后序遍历以及单元测试</li>
 <li>树的遍历我们用了 print，请你尝试换成一个 callback，这样就能自定义处理树节点的方式了。</li>
 <li>请问树的遍历操作时间复杂度是多少？假设它的 size 是 n</li>
 <li>你能用非递归的方式来实现树的遍历吗？我们知道计算机内部使用了 stack，如果我们自己模拟如何实现？请你尝试完成</li>
+<li>使用树的层序遍历我们能实现一个树的左右视图，比如从一个二叉树的左边能看到哪些节点。请你尝试做这个练习题 https://leetcode.com/problems/binary-tree-right-side-view/description/</li>
 </ul>
-<h1 id="_9">延伸阅读</h1>
+<h1 id="_10">延伸阅读</h1>
 <ul>
 <li>《Data Structures and Algorithms in Python》 13 章 Binary Trees</li>
 <li><a href="https://www.geeksforgeeks.org/iterative-preorder-traversal/">https://www.geeksforgeeks.org/iterative-preorder-traversal/</a></li>