刷题LeetCode：146.LRU缓存机制

目录

题目描述

题目分析

扩展，Java中的 LinkedHashMap 实现

---

题目链接： 力扣

题目描述

设计和实现一个 LRU (最近最少使用) 缓存机制 。

实现 LRUCache 类：

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

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

（3）void put(int key, int value) 如果关键字已经存在，则变更其数据值；如果关键字不存在，则插入该组「关键字-值」。当缓存容量达到上限时，它应该在写入新数据之前删除最久未使用的数据值，从而为新的数据值留出空间。

题目分析

根据题目描述，已经有了比较清晰的思路，为了执行 put(int key, int value)、get(int key) 方法，需要哈希表与链表配合：

• 双向链表：按照被使用的顺序存储了这些键值对，靠近头部的键值对是最近使用的，而靠近尾部的键值对是最久未使用的；
• 哈希映射（HashMap）：通过缓存数据的键映射到其在双向链表中的位置。

代码实现如下：

public class LRUCache {

    // 双向链表按照被使用的顺序存储了这些键值对，靠近头部的键值对是最近使用的，而靠近尾部的键值对是最久未使用的
    public class DLinkedNode {
        int key;
        int value;
        DLinkedNode prev;
        DLinkedNode next;

        public DLinkedNode() {
        }

        public DLinkedNode(int _key, int _value) {
            key = _key;
            value = _value;
        }
    }

    // 靠近头部的键值对是最近使用的，而靠近尾部的键值对是最久未使用的
    private DLinkedNode head, tail;

    // 容量
    private int capacity;
    // 当前链表长度
    private int size;

    // 缓存数据的键映射到其在双向链表中的位置
    private Map<Integer, DLinkedNode> cache = new HashMap<Integer, DLinkedNode>();


    public LRUCache(int capacity) {
        this.size = 0;
        this.capacity = capacity;
        // 使用伪头部和伪尾部节点
        head = new DLinkedNode();
        tail = new DLinkedNode();
        head.next = tail;
        tail.prev = head;
    }

    public int get(int key) {
        DLinkedNode node = cache.get(key);
        if (node == null) {
            return -1;
        }

        // key 存在，移动到链表头部
        moveToHead(node);
        return node.value;
    }


    /**
     * 如果关键字已经存在，则变更其数据值；
     * 如果关键字不存在，则插入该组「关键字-值」。
     * 当缓存容量达到上限时，它应该在写入新数据之前删除最久未使用的数据值，从而为新的数据值留出空间。
     *
     * @param key
     * @param value
     */
    public void put(int key, int value) {

        DLinkedNode node = cache.get(key);
        if (node != null) {
            // 关键字已经存在，则变更其数据值；
            node.value = value;
            moveToHead(node);
        } else {
            // 关键字不存在，则插入该组「关键字-值」。
            DLinkedNode newNode = new DLinkedNode(key, value);
            cache.put(key, newNode);
            addToHead(newNode);
            size++;
            // 当缓存容量达到上限时，它应该在写入新数据之前删除最久未使用的数据值
            if (size > capacity) {
                DLinkedNode tail = removeTail();
                cache.remove(tail.key);
                size--;
            }
        }

    }


    private void moveToHead(DLinkedNode node) {
        removeNode(node);
        addToHead(node);
    }


    /**
     * 最近使用的节点 添加 到链表头部
     *
     * @param node
     */
    private void addToHead(DLinkedNode node) {
        node.prev = head;
        node.next = head.next;
        head.next.prev = node;
        head.next = node;
    }


    /**
     * 删除最末节点
     *
     * @return
     */
    private DLinkedNode removeTail() {
        DLinkedNode res = tail.prev;
        removeNode(res);
        return res;
    }

    private void removeNode(DLinkedNode node){
        node.prev.next = node.next;
        node.next.prev = node.prev;
    }

}

扩展，Java中的 LinkedHashMap 实现

public class LRUCache extends LinkedHashMap<Integer, Integer> {

    // 容量
    private int capacity;

    public LRUCache(int capacity) {
        super(capacity, 0.75F, true);
        this.capacity = capacity;
    }

    public int get(int key) {
        return super.getOrDefault(key, -1);
    }

    public void put(int key, int value) {
        super.put(key, value);
    }

    @Override
    protected boolean removeEldestEntry(Map.Entry<Integer, Integer> eldest) {
        return size() > capacity;
    }
}

多谢各位看官，不如来个三连吖~~