二刷146

Author: diguage

docs/0146-lru-cache.adoc

@@ -1,50 +1,74 @@
 [#0146-lru-cache]
-= 146. LRU Cache
+= 146. LRU 缓存
 
-{leetcode}/problems/lru-cache/[LeetCode - LRU Cache^]
+https://leetcode.cn/problems/lru-cache/[LeetCode - 146. LRU 缓存 ^]
 
-使用双向链表实现时，使用两个"空节点" `head` 和 `tail`，可以有效减少空值判断，真是精巧。想起来上大学时，老师讲课提到这么一句。没想到竟然是如此实现。
+请你设计并实现一个满足 https://baike.baidu.com/item/LRU[LRU (最近最少使用) 缓存] 约束的数据结构。
 
-`LinkedHashMap` 的实现也有不少的秘密可以探索。
+实现 `LRUCache` 类：
 
-Design and implement a data structure for https://en.wikipedia.org/wiki/Cache_replacement_policies#LRU[Least Recently Used (LRU) cache^]. It should support the following operations: `get` and `put`.
+* `LRUCache(int capacity)` 以 *正整数* 作为容量 `capacity` 初始化 LRU 缓存
+* `int get(int key)` 如果关键字 `key` 存在于缓存中，则返回关键字的值，否则返回 `-1` 。
+* `void put(int key, int value)` 如果关键字 `key` 已经存在，则变更其数据值 `value`；如果不存在，则向缓存中插入该组 `key-value`。如果插入操作导致关键字数量超过 `capacity` ，则应该 *逐出* 最久未使用的关键字。
 
-`get(key)` - Get the value (will always be positive) of the key if the key exists in the cache, otherwise return -1.
+函数 `get` 和 `put` 必须以 `O(1)` 的平均时间复杂度运行。
 
+*示例：*
 
-`put(key, value)` - Set or insert the value if the key is not already present. When the cache reached its capacity, it should invalidate the least recently used item before inserting a new item.
+....
+输入
+["LRUCache", "put", "put", "get", "put", "get", "put", "get", "get", "get"]
+[[2], [1, 1], [2, 2], [1], [3, 3], [2], [4, 4], [1], [3], [4]]
+输出
+[null, null, null, 1, null, -1, null, -1, 3, 4]
 
-The cache is initialized with a *positive* capacity.
+解释
+LRUCache lRUCache = new LRUCache(2);
+lRUCache.put(1, 1); // 缓存是 {1=1}
+lRUCache.put(2, 2); // 缓存是 {1=1, 2=2}
+lRUCache.get(1);    // 返回 1
+lRUCache.put(3, 3); // 该操作会使得关键字 2 作废，缓存是 {1=1, 3=3}
+lRUCache.get(2);    // 返回 -1 (未找到)
+lRUCache.put(4, 4); // 该操作会使得关键字 1 作废，缓存是 {4=4, 3=3}
+lRUCache.get(1);    // 返回 -1 (未找到)
+lRUCache.get(3);    // 返回 3
+lRUCache.get(4);    // 返回 4
+....
 
-*Follow up:*
+*提示：*
 
+* `+1 <= capacity <= 3000+`
+* `+0 <= key <= 10000+`
+* `0 \<= value \<= 10^5^`
+* 最多调用 `2 * 10^5^` 次 `get` 和 `put`
 
-Could you do both operations in *O(1)* time complexity?
 
-*Example:*
+== 思路分析
 
-[subs="verbatim,quotes,macros"]
-----
-LRUCache cache = new LRUCache( 2 /* capacity */ );
-
-cache.put(1, 1);
-cache.put(2, 2);
-cache.get(1);       // returns 1
-cache.put(3, 3);    // evicts key 2
-cache.get(2);       // returns -1 (not found)
-cache.put(4, 4);    // evicts key 1
-cache.get(1);       // returns -1 (not found)
-cache.get(3);       // returns 3
-cache.get(4);       // returns 4
-----
+使用双向链表实现时，使用两个"空节点" `head` 和 `tail`，可以有效减少空值判断，真是精巧。想起来上大学时，老师讲课提到这么一句。没想到竟然是如此实现。
 
+`LinkedHashMap` 的实现也有不少的秘密可以探索。
 
 
-
-
 [[src-0146]]
+[tabs]
+====
+一刷::
++
+--
 [{java_src_attr}]
 ----
 include::{sourcedir}/_0146_LRUCache.java[tag=answer]
 ----
+--
+
+二刷::
++
+--
+[{java_src_attr}]
+----
+include::{sourcedir}/_0146_LRUCache_2.java[tag=answer]
+----
+--
+====
 

logbook/202503.adoc

@@ -105,6 +105,11 @@ endif::[]
 |{doc_base_url}/0003-longest-substring-without-repeating-characters.adoc[题解]
 |✅ 滑动窗口
 
+|{counter:codes2503}
+|{leetcode_base_url}/lru-cache/[146. LRU 缓存^]
+|{doc_base_url}/0146-lru-cache.adoc[题解]
+|✅ 链表前后指针操作
+
 |===
 
 截止目前，本轮练习一共完成 {codes2503} 道题。

src/main/java/com/diguage/algo/leetcode/_0146_LRUCache.java

@@ -47,6 +47,9 @@ public class _0146_LRUCache {
      * Memory Usage: 50.8 MB, less than 96.93% of Java online submissions for LRU Cache.
      *
      * Copy from: https://leetcode-cn.com/problems/lru-cache/solution/lru-huan-cun-ji-zhi-by-leetcode/[LRU 缓存机制 - LRU缓存机制 - 力扣（LeetCode）]
+     *
+     * @author D瓜哥 · https://www.diguage.com
+     * @since 2020-01-26 10:49
      */
     class LRUCache {
         private Map<Integer, DLinkedNode> data;
@@ -155,6 +158,8 @@ public void put(int key, int value) {
         }
     }
 
+  // end::answer[]
+
     private void test() {
         LRUCache solution = new LRUCache(2);
         solution.put(1, 1);
@@ -173,9 +178,6 @@ private void test() {
         System.out.println((r5 == 4) + " : " + r5);
     }
 
-  // end::answer[]
-
-
     public static void main(String[] args) {
         _0146_LRUCache solution = new _0146_LRUCache();
         solution.test();

src/main/java/com/diguage/algo/leetcode/_0146_LRUCache_2.java

@@ -0,0 +1,95 @@
+package com.diguage.algo.leetcode;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class _0146_LRUCache_2 {
+  // tag::answer[]
+
+  /**
+   * 最近最少使用缓存
+   *
+   * @author D瓜哥 · https://www.diguage.com
+   * @since 2025-04-01 23:28:56
+   */
+  class LRUCache {
+
+    private Map<Integer, Node<Integer>> data;
+    private Node<Integer> head;
+    private Node<Integer> tail;
+    private int capacity;
+
+    public LRUCache(int capacity) {
+      head = new Node<>();
+      tail = new Node<>();
+      head.next = tail;
+      tail.prev = head;
+      data = new HashMap<>(capacity);
+      this.capacity = capacity;
+    }
+
+    public int get(int key) {
+      Node<Integer> node = data.getOrDefault(key, null);
+      if (node == null) {
+        return -1;
+      }
+      siftUp(node);
+      return node.item;
+    }
+
+    private void siftUp(Node<Integer> node) {
+      // 将当前访问节点放在链表最前面
+      node.prev.next = node.next;
+      node.next.prev = node.prev;
+
+      node.next = head.next;
+      node.prev = head;
+
+      head.next.prev = node;
+      head.next = node;
+
+    }
+
+    public void put(int key, int value) {
+      Node<Integer> node;
+      if (data.containsKey(key)) {
+        node = data.get(key);
+        node.item = value;
+        siftUp(node);
+      } else {
+        node = new Node<>(head, key, value, head.next);
+        data.put(key, node);
+        head.next.prev = node;
+        head.next = node;
+      }
+      if (data.size() > capacity) {
+        Node<Integer> removing = tail.prev;
+        removing.prev.next = tail;
+        tail.prev = removing.prev;
+
+        removing.prev = null;
+        removing.next = null;
+
+        data.remove(removing.key);
+      }
+    }
+
+    static class Node<E> {
+      E key;
+      E item;
+      Node<E> next;
+      Node<E> prev;
+
+      Node() {
+      }
+
+      Node(Node<E> prev, E key, E element, Node<E> next) {
+        this.key = key;
+        this.item = element;
+        this.next = next;
+        this.prev = prev;
+      }
+    }
+  }
+  // end::answer[]
+}