手撕LRU缓存结构--java代码实现

最新推荐文章于 2024-08-05 13:24:57 发布

原创最新推荐文章于 2024-08-05 13:24:57 发布 · 198 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java #缓存 #链表

算法专栏收录该内容

12 篇文章

订阅专栏

该博客介绍了如何使用双向链表和节点数据结构实现LRU（最近最少使用）缓存。LRUCache类包含了get和put方法，分别用于获取和插入元素，并根据缓存容量进行淘汰策略。同时，定义了Node类用于存储键值对，并通过DoubleList类实现了链表的插入和删除操作。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

定义节点和双向链表

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

class DoubleList{
   Node head,tail;
    public DoubleList(){
       head = new Node(0,0);
       tail = new Node(0,0);
       head.next=tail;
       tail.pre=head;
    }
    void addFirst(Node n){
       head.next.pre=n;
       n.next=head.next;
       head.next=n;
       n.pre=head;
    }
    void remove(Node n){
       n.next.pre=n.pre;
       n.pre.next=n.next;
    }
    Node removeLast(){
        Node res =tail.pre;
        remove(res);
        return res;
    }
}

LRU实现主类

class LRUCache {
   Map<Integer,Node> map;
   DoubleList cache;
   int capacity;
    public LRUCache(int capacity) {
        map=new HashMap<>();
        cache= new DoubleList();
        this.capacity=capacity;
    }
    
    public int get(int key) {
        if(!map.containsKey(key))
            return -1;
        Node n = map.get(key);
        cache.remove(n);
        cache.addFirst(n);
        return n.value;
    }
    
    public void put(int key, int value) {
       Node n = new Node(key,value);
       if(map.containsKey(key)){
           cache.remove(map.get(key));
       }else if(map.size()==capacity){
          Node last = cache.removeLast();
          map.remove(last.key);
       }
       cache.addFirst(n);
       map.put(key,n);
    }
}