缓存算法 LRU 与 LFU 详解及代码实现

一、LRU 缓存算法

1.哈希表 + 双向链表

1.题目链接：LRU 缓存
2.题目描述：

3.算法思路：

1.双向链表 + 哈希表 组合：
双向链表（带哑头 / 哑尾节点）：维护缓存节点的访问顺序，最近使用的节点放在链表头部，最少使用的节点放在链表尾部（淘汰时直接删尾部）；
哈希表（cache）：实现 key 到节点的 O(1) 快速查找，解决链表遍历查找慢的问题；
2.哑头 / 哑尾节点：简化链表边界处理（无需判断'节点是否为头 / 尾''链表是否为空'等特殊情况）；
3.核心规则：
访问 / 更新节点（get/ 更新式 put）：将节点移到链表头部（标记为'最近使用'）；
新增节点：添加到链表头部，若缓存容量超限，删除链表尾部节点（最少使用），并同步删除哈希表中的映射。

4.代码实现：

class LRUCache {
    // 1. 双向链表节点类：封装缓存的 key、value，以及前后指针
    class DLinkedNode {
        int key; // 缓存键（淘汰节点时需要通过 key 删除哈希表中的映射）
        int value; // 缓存值
        DLinkedNode prev; // 前驱节点（双向链表）
        DLinkedNode next; // 后继节点（双向链表）
        // 无参构造：用于创建哑头/哑尾节点（无实际 key/value）
        public DLinkedNode() {}
        // 有参构造：用于创建真实的缓存节点（初始化 key 和 value）
        public DLinkedNode(int _key, int _value) {
            this.key = _key;
            this.value = _value;
        }
    }

    // 2. LRUCache 核心成员变量
    private Map<Integer, DLinkedNode> cache = new HashMap<>(); 
      size; 
      capacity; 
     DLinkedNode head; 
     DLinkedNode tail; 

    
      {
        .size = ; 
        .capacity = capacity; 
        head =  (); 
        tail =  (); 
        head.next = tail; 
        tail.prev = head; 
    }

    
       {
        
           cache.get(key);
        
         (node == ) {
             -;
        }
        
        moveToHead(node);
        
         node.value;
    }

    
       {
        
           cache.get(key);
        
         (node == ) {
            
                (key, value);
            
            cache.put(key, newNode);
            
            addToHead(newNode);
            
            size++;
            
             (size > capacity) {
                
                   removeTail();
                
                cache.remove(tailNode.key);
                
                size--;
            }
        }
        
         {
            
            node.value = value;
            
            moveToHead(node);
        }
    }

    
       {
        node.prev.next = node.next; 
        node.next.prev = node.prev; 
    }

    
       {
        node.prev = head; 
        node.next = head.next; 
        head.next.prev = node; 
        head.next = node; 
    }

    
       {
        removeNode(node); 
        addToHead(node); 
    }

    
     DLinkedNode  {
           tail.prev; 
        removeNode(res); 
         res; 
    }
}