最近最少使用算法(LRU)-算法设计

YiWait

于 2023-02-09 11:03:21 发布

阅读量222

点赞数

分类专栏：算法设计文章标签： java 开发语言 Powered by 金山文档

本文链接：https://blog.csdn.net/YiWait/article/details/128949333

版权

算法设计专栏收录该内容

3 篇文章 0 订阅

订阅专栏

文章展示了如何用Java实现LRU(LeastRecentlyUsed)缓存策略。通过创建一个双向链表和哈希映射，当缓存满时，最近最少使用的项将被移除。示例代码包括put、get和moveToTail等关键函数，解释了缓存的工作原理。

摘要由CSDN通过智能技术生成

/**
 * 最近最少使用算法（LRU）
 * 示例：
 * 输入
 * ["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]
 * <p>
 * 解释
 * 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
 */

实现方法

public class LRUCache {
    private class CacheNode {
        private CacheNode prev;
        private CacheNode next;
        private int key;
        private int value;

        public CacheNode(int key, int value) {
            this.key = key;
            this.value = value;
            this.prev = null;
            this.next = null;
        }
    }

    private int capacity;
    private HashMap<Integer, CacheNode> valNodeMap = new HashMap<>();
    private CacheNode head = new CacheNode(-1, -1);
    private CacheNode tail = new CacheNode(-1, -1);


    public LRUCache(int capacity) {
        this.capacity = capacity;
        head.next = tail;
        tail.prev = head;
    }

    public int get(int key) {
        if (!valNodeMap.containsKey(key)) {
            return -1;
        }
        CacheNode current = valNodeMap.get(key);
        current.prev.next = current.next;
        current.next.prev = current.prev;
        moveToTail(current);
        return valNodeMap.get(key).value;
    }

    public void put(int key, int value) {
        if (get(key) != -1) {
            valNodeMap.get(key).value = value;
            return;
        }
        if (valNodeMap.size() == capacity) {
            valNodeMap.remove(head.next.key);
            head.next = head.next.next;
            head.next.prev = head;
        }
        CacheNode node = new CacheNode(key, value);
        valNodeMap.put(key, node);
        moveToTail(node);
    }

    private void moveToTail(CacheNode node) {
        node.prev = tail.prev;
        tail.prev = node;
        node.next = tail;
        node.prev.next = node;
    }

    public static void main(String[] args) {
        LRUCache lruCache = new LRUCache(2);
        lruCache.put(1, 1);
        lruCache.put(2, 2);
        int value = lruCache.get(1);
        System.out.println(String.format("value is:%d", value));
        System.out.println();
    }
}

输出：