chore: $460 增加新书预告

Author: lucifer

problems/460.lfu-cache.md

@@ -29,97 +29,99 @@ cache.get(4);       // returns 4
 ```
 
 ## 思路
+
+`本题已被收录到我的新书中，敬请期待～`
+
 [LFU（Least frequently used)](https://www.wikiwand.com/en/Least_frequently_used) 但内存容量满的情况下，有新的数据进来，需要更多空间的时候，就需要删除被访问频率最少的元素。
 
-举个例子，比如说cache容量是 3，按顺序依次放入 `1，2，1，2，1，3`， cache已存满 3 个元素 (1，2，3)， 这时如果想放入一个新的元素 4 的时候，就需要腾出一个元素空间。 
+举个例子，比如说 cache 容量是 3，按顺序依次放入 `1，2，1，2，1，3`， cache 已存满 3 个元素 (1，2，3)， 这时如果想放入一个新的元素 4 的时候，就需要腾出一个元素空间。 
 用 LFU，这里就淘汰 3， 因为 3 的次数只出现依次， 1 和 2 出现的次数都比 3 多。
 
-
 题中 `get` 和 `put` 都是 `O(1)`的时间复杂度，那么删除和增加都是`O(1)`，可以想到用双链表，和`HashMap`，用一个`HashMap, nodeMap,` 保存当前`key`，和 `node{key, value, frequent} `的映射。
 这样`get(key)`的操作就是`O(1)`. 如果要删除一个元素，那么就需要另一个`HashMap，freqMap，`保存元素出现次数`（frequent）`和双链表`（DoublyLinkedlist）` 映射，
-这里双链表存的是frequent相同的元素。每次`get`或`put`的时候，`frequent+1`，然后把`node`插入到双链表的`head node, head.next=node`
+这里双链表存的是 frequent 相同的元素。每次`get`或`put`的时候，`frequent+1`，然后把`node`插入到双链表的`head node, head.next=node`
 每次删除`freqent`最小的双链表的`tail node, tail.prev`。
 
 用给的例子举例说明：
  ```
  1. put(1, 1), 
-    - 首先查找nodeMap中有没有key=1对应的value，
-        没有就新建node(key, value, freq) -> node1(1, 1, 1), 插入 nodeMap，{[1, node1]}
-    - 查找freqMap中有没有freq=1 对应的value，
-        没有就新建doublylinkedlist(head, tail), 把node1 插入doublylinkedlist head->next = node1.
+    - 首先查找 nodeMap 中有没有 key=1 对应的 value，
+        没有就新建 node(key, value, freq) -> node1(1, 1, 1), 插入 nodeMap，{[1, node1]}
+    - 查找 freqMap 中有没有 freq=1 对应的 value，
+        没有就新建 doublylinkedlist(head, tail), 把 node1 插入 doublylinkedlist head->next = node1.
     如下图，
  ```
 ![460.lfu-cache-1](../assets/problems/460.lfu-cache-1.jpg)
  ```
  2. put(2, 2), 
-    - 首先查找nodeMap中有没有key=2对应的value，
-        没有就新建node(key, value, freq) -> node2(2, 2, 1), 插入 nodeMap，{[1, node1], [2, node2]}
-    - 查找freqMap中有没有freq=1 对应的value，
-        没有就新建doublylinkedlist(head, tail), 把node2 插入doublylinkedlist head->next = node2.
+    - 首先查找 nodeMap 中有没有 key=2 对应的 value，
+        没有就新建 node(key, value, freq) -> node2(2, 2, 1), 插入 nodeMap，{[1, node1], [2, node2]}
+    - 查找 freqMap 中有没有 freq=1 对应的 value，
+        没有就新建 doublylinkedlist(head, tail), 把 node2 插入 doublylinkedlist head->next = node2.
     如下图，
  ```
 ![460.lfu-cache-2](../assets/problems/460.lfu-cache-2.jpg)
  ```
  3. get(1), 
-    - 首先查找nodeMap中有没有key=1对应的value，nodeMap:{[1, node1], [2, node2]},
-        找到node1，把node1 freq+1 -> node1(1,1,2)
-    - 更新freqMap，删除freq=1，node1
-    - 更新freqMap，插入freq=2，node1
+    - 首先查找 nodeMap 中有没有 key=1 对应的 value，nodeMap:{[1, node1], [2, node2]},
+        找到 node1，把 node1 freq+1 -> node1(1,1,2)
+    - 更新 freqMap，删除 freq=1，node1
+    - 更新 freqMap，插入 freq=2，node1
     如下图，
  ```
 ![460.lfu-cache-3](../assets/problems/460.lfu-cache-3.jpg)
  ```
  4. put(3, 3), 
-    - 判断cache的capacity，已满，需要淘汰使用次数最少的元素，找到最小的freq=1，删除双链表tail node.prev 
-        如果tailnode.prev != null, 删除。然后从nodeMap中删除对应的key。
-    - 首先查找nodeMap中有没有key=3对应的value，
-        没有就新建node(key, value, freq) -> node3(3, 3, 1), 插入 nodeMap，{[1, node1], [3, node3]}
-    - 查找freqMap中有没有freq=1 对应的value，
-        没有就新建doublylinkedlist(head, tail), 把node3 插入doublylinkedlist head->next = node3.
+    - 判断 cache 的 capacity，已满，需要淘汰使用次数最少的元素，找到最小的 freq=1，删除双链表 tail node.prev 
+        如果 tailnode.prev != null, 删除。然后从 nodeMap 中删除对应的 key。
+    - 首先查找 nodeMap 中有没有 key=3 对应的 value，
+        没有就新建 node(key, value, freq) -> node3(3, 3, 1), 插入 nodeMap，{[1, node1], [3, node3]}
+    - 查找 freqMap 中有没有 freq=1 对应的 value，
+        没有就新建 doublylinkedlist(head, tail), 把 node3 插入 doublylinkedlist head->next = node3.
     如下图，
  ```
 ![460.lfu-cache-4](../assets/problems/460.lfu-cache-4.jpg)
  ```
  5. get(2) 
-    - 查找nodeMap，如果没有对应的key的value，返回 -1。
+    - 查找 nodeMap，如果没有对应的 key 的 value，返回 -1。
   
  6. get(3)
-    - 首先查找nodeMap中有没有key=3对应的value，nodeMap:{[1, node1], [3, node3]},
-        找到node3，把node3 freq+1 -> node3(3,3,2)
-    - 更新freqMap，删除freq=1，node3
-    - 更新freqMap，插入freq=2，node3
+    - 首先查找 nodeMap 中有没有 key=3 对应的 value，nodeMap:{[1, node1], [3, node3]},
+        找到 node3，把 node3 freq+1 -> node3(3,3,2)
+    - 更新 freqMap，删除 freq=1，node3
+    - 更新 freqMap，插入 freq=2，node3
     如下图，
  ```
 ![460.lfu-cache-5](../assets/problems/460.lfu-cache-5.jpg)
  ```
  7. put(4, 4), 
-    - 判断cache的capacity，已满，需要淘汰使用次数最少的元素，找到最小的freq=1，删除双链表tail node.prev 
-        如果tailnode.prev != null, 删除。然后从nodeMap中删除对应的key。
-    - 首先查找nodeMap中有没有key=4对应的value，
-        没有就新建node(key, value, freq) -> node4(4, 4, 1), 插入 nodeMap，{[4, node4], [3, node3]}
-    - 查找freqMap中有没有freq=1 对应的value，
-        没有就新建doublylinkedlist(head, tail), 把 node4 插入doublylinkedlist head->next = node4.
+    - 判断 cache 的 capacity，已满，需要淘汰使用次数最少的元素，找到最小的 freq=1，删除双链表 tail node.prev 
+        如果 tailnode.prev != null, 删除。然后从 nodeMap 中删除对应的 key。
+    - 首先查找 nodeMap 中有没有 key=4 对应的 value，
+        没有就新建 node(key, value, freq) -> node4(4, 4, 1), 插入 nodeMap，{[4, node4], [3, node3]}
+    - 查找 freqMap 中有没有 freq=1 对应的 value，
+        没有就新建 doublylinkedlist(head, tail), 把 node4 插入 doublylinkedlist head->next = node4.
     如下图，
  ```
 ![460.lfu-cache-6](../assets/problems/460.lfu-cache-6.jpg)
  ```
  8. get(1) 
-    - 查找nodeMap，如果没有对应的key的value，返回 -1。
+    - 查找 nodeMap，如果没有对应的 key 的 value，返回 -1。
   
  9. get(3)
-    - 首先查找nodeMap中有没有key=3对应的value，nodeMap:{[4, node4], [3, node3]},
-        找到node3，把node3 freq+1 -> node3(3,3,3)
-    - 更新freqMap，删除freq=2，node3
-    - 更新freqMap，插入freq=3，node3
+    - 首先查找 nodeMap 中有没有 key=3 对应的 value，nodeMap:{[4, node4], [3, node3]},
+        找到 node3，把 node3 freq+1 -> node3(3,3,3)
+    - 更新 freqMap，删除 freq=2，node3
+    - 更新 freqMap，插入 freq=3，node3
     如下图，
  ```
 ![460.lfu-cache-7](../assets/problems/460.lfu-cache-7.jpg)
  ```
  10. get(4)
-    - 首先查找nodeMap中有没有key=4对应的value，nodeMap:{[4, node4], [3, node3]},
-        找到node4，把node4 freq+1 -> node4(4,4,2)
-    - 更新freqMap，删除freq=1，node4
-    - 更新freqMap，插入freq=2，node4
+    - 首先查找 nodeMap 中有没有 key=4 对应的 value，nodeMap:{[4, node4], [3, node3]},
+        找到 node4，把 node4 freq+1 -> node4(4,4,2)
+    - 更新 freqMap，删除 freq=1，node4
+    - 更新 freqMap，插入 freq=2，node4
     如下图，
  ```
 ![460.lfu-cache-8](../assets/problems/460.lfu-cache-8.jpg)
@@ -128,7 +130,7 @@ cache.get(4);       // returns 4
 用两个`Map`分别保存 `nodeMap {key, node}` 和 `freqMap{frequent, DoublyLinkedList}`。
 实现`get` 和 `put`操作都是`O(1)`的时间复杂度。
 
-可以用Java自带的一些数据结构，比如HashLinkedHashSet，这样就不需要自己自建Node，DoublelyLinkedList。
+可以用 Java 自带的一些数据结构，比如 HashLinkedHashSet，这样就不需要自己自建 Node，DoublelyLinkedList。
 可以很大程度的缩减代码量。
 
 ## 代码（Java code）