Merge branch 'PegasusWang:master' into master

Author: lawrenceywr

README.md

@@ -121,9 +121,12 @@ Python 抽象程度比较高， 我们能用更少的代码来实现功能，同
 ## 算法可视化
 
 学习算法的过程中有时候会比较抽象，这里给大家推荐一些可视化的网站，方便更直观地理解各种算法和数据结构的执行步骤：
+遇到一个算法或数据结构，你可以 google 搜索 "名称+ visualization" 找到一些可视化网站方便理解，比如学习跳跃表的时候笔者就
+可以通过 goole "skip list visualization" 搜到一些可视化网站帮助你理解它的工作原理。
 
 - https://github.com/algorithm-visualizer/algorithm-visualizer
 - https://www.cs.usfca.edu/~galles/visualization/Algorithms.html
+- https://cmps-people.ok.ubc.ca/ylucet/DS/Algorithms.html
 - https://runestone.academy/runestone/books/published/pythonds/index.html#
 
 ## 讲课形式

docs/03_链表/lru_cache.py

@@ -132,3 +132,83 @@ def test():
 
 if __name__ == '__main__':
     test()
+
+
+######################################### 使用双链表实现 LRUcache ####################################################
+"""
+一般面试中不会让我们直接用内置结构，所以这里提供一个自己实现的双链表+map lru 缓存。这也是力扣上的一道真题：
+[146] LRU 缓存 https://leetcode-cn.com/problems/lru-cache/description/
+"""
+
+class ListNode:
+    def __init__(self, key=None, value=None):
+        self.key = key
+        self.value = value
+        self.prev = self.next = None
+
+
+class List:
+    def __init__(self):
+        """循环双链表。注意增加了虚拟头尾结点 head,tail 方便处理"""
+        self.head = ListNode()
+        self.tail = ListNode()
+        self.head.prev = self.head.next = self.tail
+        self.tail.next = self.tail.prev = self.head
+
+    def delete_node(self, node):  # 删除指定节点
+        node.prev.next = node.next
+        node.next.prev = node.prev
+
+    def add_to_head(self, node):  # 指定节点添加到 self.head 后
+        nextnode = self.head.next
+        node.next = nextnode
+        node.prev = self.head
+        self.head.next = node
+        nextnode.prev = node
+
+
+class LRUCache(object):
+
+    def __init__(self, capacity):
+        """
+        思路：循环双链表 + 字典
+        :type capacity: int
+        """
+        self.map = dict()
+        self.ll = List()
+        self.capacity = capacity
+
+    def get(self, key):
+        """
+        :type key: int
+        :rtype: int
+        """
+        if key not in self.map:
+            return -1
+
+        node = self.map[key]
+        self.ll.delete_node(node)
+        self.ll.add_to_head(node)
+        return node.value
+
+    def put(self, key, value):
+        """
+        :type key: int
+        :type value: int
+        :rtype: None
+        """
+        if key in self.map: # 更新不会改变元素个数，这里不用判断是否需要剔除
+            node = self.map[key]
+            node.value = value  # 修改结构体会也会修改 map 对应 value 的引用
+            self.ll.delete_node(node)
+            self.ll.add_to_head(node)
+        else:
+            if len(self.map) >= self.capacity:  # 直接用 len(self.map) ，不需要self.size 字段了
+                tailnode = self.ll.tail.prev
+                self.ll.delete_node(tailnode)
+                del self.map[tailnode.key]
+
+            node = ListNode(key, value)
+            self.map[key] = node
+            self.ll.add_to_head(node)
+

docs/15_堆与堆排序/min_heap.py

@@ -0,0 +1,66 @@
+# python3
+class MinHeap:
+    def __init__(self):
+        """
+        这里提供一个最小堆实现。如果面试不让用内置的堆非让你自己实现的话，考虑用这个简版的最小堆实现。
+        一般只需要实现 heqppop,heappush 两个操作就可以应付面试题了
+        parent: (i-1)//2。注意这么写 int((n-1)/2)， python3 (n-1)//2当n=0结果是-1而不是0
+        left:  2*i+1
+        right: 2*i+2
+        参考：
+        https://favtutor.com/blogs/heap-in-python
+        https://runestone.academy/ns/books/published/pythonds/Trees/BinaryHeapImplementation.html
+        https://www.askpython.com/python/examples/min-heap
+        """
+        self.pq = []
+
+    def min_heapify(self, nums, k):
+        """递归调用，维持最小堆特性"""
+        l = 2*k+1  # 左节点位置
+        r = 2*k+2  # 右节点
+        if l < len(nums) and nums[l] < nums[k]:
+            smallest = l
+        else:
+            smallest = k
+        if r < len(nums) and nums[r] < nums[smallest]:
+            smallest = r
+        if smallest != k:
+            nums[k], nums[smallest] = nums[smallest], nums[k]
+            self.min_heapify(nums, smallest)
+
+    def heappush(self, num):
+        """列表最后就加入一个元素，之后不断循环调用维持堆特性"""
+        self.pq.append(num)
+        n = len(self.pq) - 1
+        # 注意必须加上n>0。因为 python3 (n-1)//2 当n==0 的时候结果是-1而不是0!
+        while n > 0 and self.pq[n] < self.pq[(n-1)//2]:  # parent 交换
+            self.pq[n], self.pq[(n-1)//2] = self.pq[(n-1)//2], self.pq[n]  # swap
+            n = (n-1)//2
+
+    def heqppop(self):  # 取 pq[0]，之后和pq最后一个元素pq[-1]交换之后调用 min_heapify(0)
+        minval = self.pq[0]
+        last = self.pq[-1]
+        self.pq[0] = last
+        self.min_heapify(self.pq, 0)
+        self.pq.pop()
+        return minval
+
+    def heapify(self, nums):
+        n = int((len(nums)//2)-1)
+        for k in range(n, -1, -1):
+            self.min_heapify(nums, k)
+
+
+def test_MinHeqp():
+    import random
+    l = list(range(1, 9))
+    random.shuffle(l)
+    pq = MinHeap()
+    for num in l:
+        pq.heappush(num)
+    res = []
+    for _ in range(len(l)):
+        res.append(pq.heqppop())  # 利用 heqppop,heqppush 实现堆排序
+
+    def issorted(l): return all(l[i] <= l[i+1] for i in range(len(l) - 1))
+    assert issorted(res)