feat: 春招冲冲冲

Author: lucifer

README.md

@@ -31,6 +31,14 @@
 
 > epub 还是有动图的
 
+## 春招冲冲冲
+
+春招已经开始了。你是不是已经开始准备了呢？为了帮助大家获得更好的 offer，lucifer 开辟了「春招冲冲冲」栏目。
+
+第一期我们的猎物是「虾皮」。来看看虾皮的算法题难度几何吧！
+
+- [春招冲冲冲](https://mp.weixin.qq.com/s?__biz=MzI4MzUxNjI3OA==&mid=2247487632&idx=1&sn=830fe267d835e5acbfc417787f85f1c1&chksm=eb88dc89dcff559f49913c0f2dec77b1d06c2ddbe2c6c299b32b3e49c2efaf8b11ac0aedce8f&token=1676518002&lang=zh_CN#rd)
+
 ## :information_desk_person:订阅公众号
 
 有些内容只在公众号发布，因此大家觉得内容不错的话，可以关注一下。如果再给 ➕ 个星标就更棒啦！
@@ -381,6 +389,7 @@ leetcode 题解，记录自己的 leetcode 解题之路。
 - [0128. 最长连续序列](./problems/128.longest-consecutive-sequence.md)
 - [0140. 单词拆分 II](problems/140.word-break-ii.md)
 - [0145. 二叉树的后序遍历](./problems/145.binary-tree-postorder-traversal.md)
+- [0146. LRU 缓存机制](./problems/146.lru-cache.md)
 - [0212. 单词搜索 II](./problems/212.word-search-ii.md)
 - [0239. 滑动窗口最大值](./problems/239.sliding-window-maximum.md)
 - [0295. 数据流的中位数](./problems/295.find-median-from-data-stream.md)

SUMMARY.md

@@ -254,6 +254,7 @@
   - [0128. 最长连续序列](./problems/128.longest-consecutive-sequence.md)
   - [0140. 单词拆分 II](problems/140.word-break-ii.md)
   - [0145. 二叉树的后序遍历](./problems/145.binary-tree-postorder-traversal.md)
+  - [0146. LRU 缓存机制](./problems/146.lru-cache.md)
   - [0212. 单词搜索 II](./problems/212.word-search-ii.md)
   - [0239. 滑动窗口最大值](./problems/239.sliding-window-maximum.md)
   - [0295. 数据流的中位数](./problems/295.find-median-from-data-stream.md)

problems/146.lru-cache.md

@@ -105,7 +105,7 @@ function put (key, value) {
 
 ## 代码
 
-语言支持: JS, Go, PHP, CPP
+语言支持: JS, Go, PHP, Python3
 
 JS Code:
 
@@ -377,36 +377,78 @@ class DoubleList
 }
 ```
 
-CPP Code:
-
-```cpp
-class LRUCache {
-private:
-  list<pair<int, int>> data;
-  unordered_map<int, list<pair<int, int>>::iterator> m;
-  int capacity;
-public:
-  LRUCache(int capacity) : capacity(capacity) {}
-
-  int get(int key) {
-    if (!m.count(key)) return -1;
-    data.splice(data.begin(), data, m[key]);
-    m[key] = data.begin();
-    return data.front().second;
-  }
+Python Code:
+
+> 来自 leetcode
+
+```py
+class DLinkedNode:
+    def __init__(self, key=0, value=0):
+        self.key = key
+        self.value = value
+        self.prev = None
+        self.next = None
+
+
+class LRUCache:
+    def __init__(self, capacity: int):
+        self.cache = dict()
+        # 使用伪头部和伪尾部节点
+        self.head = DLinkedNode()
+        self.tail = DLinkedNode()
+        self.head.next = self.tail
+        self.tail.prev = self.head
+        self.capacity = capacity
+        self.size = 0
+
+    def get(self, key: int) -> int:
+        if key not in self.cache:
+            return -1
+        # 如果 key 存在，先通过哈希表定位，再移到头部
+        node = self.cache[key]
+        self.moveToHead(node)
+        return node.value
+
+    def put(self, key: int, value: int) -> None:
+        if key not in self.cache:
+            # 如果 key 不存在，创建一个新的节点
+            node = DLinkedNode(key, value)
+            # 添加进哈希表
+            self.cache[key] = node
+            # 添加至双向链表的头部
+            self.addToHead(node)
+            self.size += 1
+            if self.size > self.capacity:
+                # 如果超出容量，删除双向链表的尾部节点
+                removed = self.removeTail()
+                # 删除哈希表中对应的项
+                self.cache.pop(removed.key)
+                self.size -= 1
+        else:
+            # 如果 key 存在，先通过哈希表定位，再修改 value，并移到头部
+            node = self.cache[key]
+            node.value = value
+            self.moveToHead(node)
+
+    def addToHead(self, node):
+        node.prev = self.head
+        node.next = self.head.next
+        self.head.next.prev = node
+        self.head.next = node
+
+    def removeNode(self, node):
+        node.prev.next = node.next
+        node.next.prev = node.prev
+
+    def moveToHead(self, node):
+        self.removeNode(node)
+        self.addToHead(node)
+
+    def removeTail(self):
+        node = self.tail.prev
+        self.removeNode(node)
+        return node
 
-  void put(int key, int value) {
-    if (get(key) == -1) {
-      if (data.size() == capacity) {
-        auto p = data.back();
-        m.erase(p.first);
-        data.pop_back();
-      }
-      data.emplace_front(key, value);
-      m[key] = data.begin();
-    } else data.front().second = value;
-  }
-};
 ```
 
 **复杂度分析**