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>

13_高级排序算法/quick_sort/index.html

@@ -224,7 +224,7 @@ <h1 id="_1">注意事项</h1>
 <li>电子简历尽量用 pdf 格式，方便跨平台打开。doc 等格式在不同的电脑上打开会有排版问题，很多后端技术面试官可能使用的是 mac 或者 linux。</li>
 <li>提前复习回顾重点知识，防止卡在基础上。比如 mac 下著名的 brew 工具作者面试 google 就因为没写出来反转二叉树被拒，后来去了苹果😂.(这就只能看人品和运气和眼缘了，如果没见到二面面试官或者 hr，大概率是挂了)。（树、链表、哈希表、二分、快排、TCP/UDP、HTTP、数据库ACID、索引优化等常考点）。</li>
 <li>白板编程，练习在纸上手写代码。虽然很多求职者都很抵触手写代码，但是白板编程确实是一种比较好的区分方式。你的思考过程、编码习惯、编码规范等都能看出来。</li>
-<li>如果被问到工程里不会使用但是比较刁钻的算法题，建议你和面试官沟通的时候问问这个算法或者题目在开发中有哪些实际使用场景，看看对方怎么说😎。</li>
+<li>如果被问到工程里不会使用但是比较刁钻的算法题，建议你和面试官沟通的时候问问这个算法或者题目在开发中有哪些实际使用场景，看看对方怎么说😎。少数公司喜欢考一些算法竞赛题，这种对于没有ACM，信息学竞赛背景的开发者来说比较吃力。大部分业务开发岗位应该只会考察基础算法题</li>
 <li>面试的时候准备充分，简历要与招聘方需求对等，甚至可以针对不同公司准备不同的简历内容。笔者每次面试都会带上白纸、笔、简历、电脑等，即使面试没过，至少也让面试官感觉我是有诚意的，给对方留下好印象。</li>
 <li>加分项：github、个人技术博客、开源项目、技术论坛帐号等，让面试官有更多渠道了解你，有时候仅仅根据几十分钟的面试来评判面试者是有失偏颇的。（比如面试者临场发挥不好；面试官个人偏好；会的都不问，问的都不会等）</li>
 </ul>

13_高级排序算法/quicksort.py

@@ -395,7 +395,7 @@ <h2 id="_15">如何学习</h2>
 <li>使用场景，什么时候用</li>
 </ul>
 </li>
-<li>自己尝试实现，如果抛开视频自己写起来有困难可以反复多看几次视频，一定要自己手动实现。很多面试可能会让手写</li>
+<li>自己尝试实现，如果抛开视频自己写起来有困难可以反复多看几次视频，一定要自己手动实现。很多面试可能会让手写。一次不行就看完原理后多实践几次，直到能自己独立完成。</li>
 <li>每章讲义后边都会有我设计的几个小问题，最好能够回答上来。同时还有代码练习题，你可以挑战下自己的掌握程度。</li>
 <li>最好按照顺序循序渐进，每章都会有铺垫和联系，后边的章节可能会使用到前面提到的数据结构</li>
 <li>根据自己的基础结合我列举的教材和视频学习，第一次理解不了的可以反复多看几次，多编写代码练习到熟练为止</li>
@@ -528,5 +528,5 @@ <h2 id="_20">本电子书制作和写作方式</h2>
 
 <!--
 MkDocs version : 1.0.4
-Build Date UTC : 2018-12-09 04:31:07
+Build Date UTC : 2018-12-18 00:49:36
 -->