力扣解题-146. LRU 缓存

力扣解题-146. LRU 缓存

请你设计并实现一个满足 LRU (最近最少使用) 缓存 约束的数据结构。

实现 LRUCache 类：

LRUCache(int capacity) 以 正整数 作为容量 capacity 初始化 LRU 缓存

int get(int key) 如果关键字 key 存在于缓存中，则返回关键字的值，否则返回 -1 。

void put(int key, int value) 如果关键字 key 已经存在，则变更其数据值 value ；如果不存在，则向缓存中插入该组 key-value 。如果插入操作导致关键字数量超过 capacity ，则应该 逐出 最久未使用的关键字。

函数 get 和 put 必须以 O(1) 的平均时间复杂度运行。

示例：

输入

["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]

解释

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

提示：

1 <= capacity <= 3000

0 <= key <= 10000

0 <= value <= 105

最多调用 2 * 105 次 get 和 put

Related Topics

设计、哈希表、链表、双向链表

---

第一次解答

解题思路

核心方法：双向链表 + 哈希表 组合实现，利用双向链表维护缓存的使用顺序（最近使用的节点在链表尾部，最久未使用的在链表头部），哈希表存储key到节点的映射，保证get/put操作的O(1)时间复杂度，是LRU缓存的经典最优实现。

核心逻辑拆解

LRU缓存的核心需求是“快速访问”和“快速淘汰最久未使用数据”，因此需要两种数据结构配合：

1. 双向链表：
   • 作用：维护缓存节点的使用顺序，支持O(1)时间的节点插入、删除、移动操作；
   • 规则：
     • 新插入/访问的节点移到链表尾部（表示最近使用）；
     • 链表头部节点是最久未使用的，容量满时淘汰头部节点；
     • 用哑节点（head/tail）简化链表头尾的边界操作，避免空指针；
2. 哈希表（HashMap）：
   • 作用：存储key到节点的映射，支持O(1)时间查找key对应的节点；
   • 规则：插入节点时同步存入哈希表，删除节点时同步移除哈希表中的映射。

具体执行逻辑

1. 数据结构定义

• Node类：双向链表节点，包含key、value、pre（前驱节点）、next（后继节点）；
• 成员变量：
  • cache：HashMap<Integer, Node>，key到节点的映射；
  • head/tail：哑节点，作为链表头尾，简化边界操作；
  • capacity：缓存容量。

2. 初始化（LRUCache构造方法）

• 初始化容量、哈希表；
• 创建head和tail哑节点，将head.next指向tail，tail.pre指向head，形成空的双向链表。

3. 核心辅助方法

• addToTail(Node node)：将节点添加到链表尾部（最近使用区域）：
  1. 节点的前驱指向tail的前驱（原尾部节点）；
  2. 节点的后继指向tail；
  3. 原尾部节点的后继指向该节点；
  4. tail的前驱更新为该节点；
• removeNode(Node node)：从链表中移除指定节点：
  1. 节点前驱的后继指向节点的后继；
  2. 节点后继的前驱指向节点的前驱；
• moveToTail(Node node)：将节点移动到链表尾部（表示最近使用）：
  1. 先调用removeNode移除节点；
  2. 再调用addToTail将节点添加到尾部。

4. get操作逻辑

• 若key不在哈希表中，返回-1；
• 若存在：
  1. 从哈希表中获取对应的节点；
  2. 调用moveToTail将节点移到链表尾部（更新使用顺序）；
  3. 返回节点的value。

5. put操作逻辑

• key已存在：
  1. 从哈希表中获取节点；
  2. 更新节点的value；
  3. 调用moveToTail将节点移到尾部；
• key不存在：
  1. 检查缓存容量：若哈希表大小≥capacity，淘汰最久未使用节点：
     • 移除head.next（最久未使用节点）；
     • 从哈希表中删除该节点的key；
  2. 创建新节点，存入哈希表；
  3. 调用addToTail将新节点添加到链表尾部。

执行流程可视化（以示例中put(3,3)为例）

操作步骤	哈希表状态	双向链表状态	说明
初始	{1:节点1, 2:节点2}	head→节点1→节点2→tail	缓存容量2，已存2个节点
淘汰节点	-	head→节点2→tail	移除head.next（节点1？不，示例中淘汰的是节点2）
修正	{1:节点1, 2:节点2}	head→节点1→节点2→tail	容量满（2），先移除节点2
移除后	{1:节点1}	head→节点1→tail	哈希表删除key=2
插入新节点	{1:节点1,3:节点3}	head→节点1→节点3→tail	节点3添加到尾部

关键细节说明

• 哑节点的作用：head/tail不存储实际数据，避免处理“链表为空”“节点是头/尾”的边界情况，简化代码；
• 节点存储key的必要性：淘汰节点时，需要通过节点的key删除哈希表中的映射，因此节点必须存储key；
• 操作原子性：链表操作和哈希表操作必须同步，避免数据不一致（如删除节点时既要移除链表节点，也要删除哈希表映射）；
• 时间复杂度保证：
  • get：哈希表查找O(1) + 链表移动O(1) → 总O(1)；
  • put：哈希表查找/插入/删除O(1) + 链表操作O(1) → 总O(1)。

性能说明

• 时间复杂度：get/put操作均为O(1)（满足题目要求）；
• 空间复杂度：O(capacity)（最多存储capacity个节点）；
• 优势：
  1. 完全满足题目O(1)时间复杂度要求，是LRU缓存的工业级实现方案；
  2. 代码逻辑清晰，辅助方法拆分合理，易维护；
  3. 哑节点设计避免了大量边界判断，降低出错概率。

class Node{
    int key;
    int value;
    Node pre;
    Node next;
    Node(int key,int value){
        this.key=key;
        this.value=value;
    }
}

private Map<Integer,Node> cache;
private Node head;
private Node tail;
private int capacity;

public LRUCache(int capacity) {
    this.capacity=capacity;
    cache=new HashMap<>();
    head=new Node(0,0);
    tail=new Node(0,0);
    head.next=tail;
    tail.pre=head;
}

private void addToTail(Node node){
    node.pre=tail.pre;
    node.next=tail;
    tail.pre.next=node;
    tail.pre=node;
}

private void removeNode(Node node){
    node.pre.next=node.next;
    node.next.pre=node.pre;
}

private void moveToTail(Node node){
    removeNode(node);
    addToTail(node);
}

public int get(int key) {
    if(!cache.containsKey(key)){
        return -1;
    }
    Node node=cache.get(key);
    moveToTail(node);
    return node.value;
}

public void put(int key, int value) {
    if(cache.containsKey(key)){
        Node node=cache.get(key);
        node.value=value;
        moveToTail(node);
    }else {
        if(cache.size()>=capacity){
            Node old=head.next;
            removeNode(old);
            cache.remove(old.key);
        }
        Node newNode=new Node(key,value);
        cache.put(key,newNode);
        addToTail(newNode);
    }
}

---

示例解答

解题思路

解法1：利用Java内置LinkedHashMap实现（简化版）

核心方法：Java的LinkedHashMap天然支持按访问顺序维护元素，通过重写removeEldestEntry方法实现容量限制，代码极简，适合快速实现LRU缓存（本质仍是双向链表+哈希表，底层逻辑与手动实现一致）。

代码实现

class LRUCache extends LinkedHashMap<Integer, Integer> {
    private int capacity;

    public LRUCache(int capacity) {
        // 初始化参数：initialCapacity, loadFactor, accessOrder(true表示按访问顺序)
        super(capacity, 0.75f, true);
        this.capacity = capacity;
    }

    public int get(int key) {
        // 调用LinkedHashMap的get方法，会自动将访问的元素移到尾部
        return super.getOrDefault(key, -1);
    }

    public void put(int key, int value) {
        // 调用LinkedHashMap的put方法，会自动处理重复key和访问顺序
        super.put(key, value);
    }

    @Override
    protected boolean removeEldestEntry(Map.Entry<Integer, Integer> eldest) {
        // 当size超过capacity时，移除最久未使用的元素（链表头部）
        return size() > capacity;
    }
}

核心逻辑说明

1. LinkedHashMap特性：
   • 构造方法第三个参数accessOrder=true：开启按访问顺序排序（默认按插入顺序），访问/插入元素时会将元素移到链表尾部；
   • 重写removeEldestEntry：当map大小超过容量时，自动移除最久未使用的元素（链表头部）；
2. 方法复用：
   • get：调用super.getOrDefault，找不到返回-1，找到则自动更新访问顺序；
   • put：调用super.put，自动处理key重复（更新value+移到尾部）和新增key（插入尾部）。

性能说明

• 时间复杂度：get/put均为O(1)（底层是双向链表+哈希表，与手动实现一致）；
• 空间复杂度：O(capacity)；
• 优势：
  1. 代码极简，无需手动实现双向链表，减少出错概率；
  2. 利用JDK内置实现，稳定性高；
• 劣势：
  1. 属于“黑盒使用”，无法体现LRU的底层实现逻辑，面试中通常要求手动实现；
  2. 灵活性较低，无法自定义链表操作细节。

解法2：优化版手动实现（增加空指针校验+代码健壮性）

核心方法：在原手动实现的基础上，增加空指针校验、节点回收等细节，提升代码健壮性，适合工业级应用。

代码实现

class Node {
    int key;
    int value;
    Node pre;
    Node next;

    Node(int key, int value) {
        this.key = key;
        this.value = value;
    }
}

public class LRUCache {
    private final Map<Integer, Node> cache;
    private final Node head;
    private final Node tail;
    private final int capacity;

    public LRUCache(int capacity) {
        if (capacity <= 0) {
            throw new IllegalArgumentException("Capacity must be positive");
        }
        this.capacity = capacity;
        this.cache = new HashMap<>(capacity);
        this.head = new Node(-1, -1);
        this.tail = new Node(-1, -1);
        head.next = tail;
        tail.pre = head;
    }

    public int get(int key) {
        Node node = cache.get(key);
        if (node == null) {
            return -1;
        }
        // 移动到尾部，标记为最近使用
        moveToTail(node);
        return node.value;
    }

    public void put(int key, int value) {
        Node node = cache.get(key);
        if (node != null) {
            // 更新value并移动到尾部
            node.value = value;
            moveToTail(node);
            return;
        }
        // 容量满，移除最久未使用节点
        if (cache.size() >= capacity) {
            Node eldest = head.next;
            removeNode(eldest);
            cache.remove(eldest.key);
            // 帮助GC回收
            eldest.pre = null;
            eldest.next = null;
        }
        // 插入新节点
        Node newNode = new Node(key, value);
        cache.put(key, newNode);
        addToTail(newNode);
    }

    private void addToTail(Node node) {
        if (node == null || tail == null) {
            return;
        }
        Node last = tail.pre;
        last.next = node;
        node.pre = last;
        node.next = tail;
        tail.pre = node;
    }

    private void removeNode(Node node) {
        if (node == null || head == null || tail == null) {
            return;
        }
        Node pre = node.pre;
        Node next = node.next;
        pre.next = next;
        next.pre = pre;
    }

    private void moveToTail(Node node) {
        if (node == null || node.next == tail) {
            return; // 已经在尾部，无需移动
        }
        removeNode(node);
        addToTail(node);
    }
}

核心优化点

1. 参数校验：构造方法中校验capacity>0，避免非法初始化；
2. 空指针防护：所有辅助方法增加null校验，避免NPE；
3. 提前返回：put中key存在时直接return，减少嵌套；
4. GC优化：移除节点时清空pre/next引用，帮助垃圾回收；
5. 冗余判断：moveToTail中判断节点是否已在尾部，避免无效操作。

---

总结

1. 手动实现（第一次解答）：O(1)时间+O(capacity)空间，经典实现，体现LRU核心逻辑，面试/底层开发首选；
2. LinkedHashMap实现：O(1)时间+O(capacity)空间，代码极简，适合快速开发，无需关注底层细节；
3. 优化版手动实现：O(1)时间+O(capacity)空间，增加健壮性，适合工业级应用；
4. 关键技巧：
   • 核心思想：LRU的本质是“双向链表维护使用顺序 + 哈希表保证快速访问”，两者缺一不可；
   • 设计要点：哑节点简化边界操作、节点存储key用于哈希表删除、链表尾部存储最近使用节点；
   • 性能保证：所有链表操作（插入/删除/移动）都是O(1)，哈希表操作也是O(1)，满足题目要求。