力扣链表 哈希表 之 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


Java 原生linkedHashMap
class LRUCache { int cap; LinkedHashMap<Integer, Integer> cache = new LinkedHashMap<>(); public LRUCache(int capacity) { this.cap = capacity; } public int get(int key) { if (!cache.containsKey(key)) { return -1; } // 将 key 变为最近使用 makeRecently(key); return cache.get(key); } public void put(int key, int val) { if (cache.containsKey(key)) { // 修改 key 的值 cache.put(key, val); // 将 key 变为最近使用 makeRecently(key); return; } if (cache.size() >= this.cap) { // 链表头部就是最久未使用的 key int oldestKey = cache.keySet().iterator().next(); cache.remove(oldestKey); } // 将新的 key 添加链表尾部 cache.put(key, val); } private void makeRecently(int key) { int val = cache.get(key); // 删除 key，重新插入到队尾 cache.remove(key); cache.put(key, val); } } 作者：labuladong 链接：https://leetcode.cn/problems/lru-cache/solutions/12711/lru-ce-lue-xiang-jie-he-shi-xian-by-labuladong/ 来源：力扣（LeetCode） 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

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;

    }

}

Java 原生linkedHashMap

class LRUCache { int cap; LinkedHashMap<Integer, Integer> cache = new LinkedHashMap<>(); public LRUCache(int capacity) { this.cap = capacity; } public int get(int key) { if (!cache.containsKey(key)) { return -1; } // 将 key 变为最近使用 makeRecently(key); return cache.get(key); } public void put(int key, int val) { if (cache.containsKey(key)) { // 修改 key 的值 cache.put(key, val); // 将 key 变为最近使用 makeRecently(key); return; } if (cache.size() >= this.cap) { // 链表头部就是最久未使用的 key int oldestKey = cache.keySet().iterator().next(); cache.remove(oldestKey); } // 将新的 key 添加链表尾部 cache.put(key, val); } private void makeRecently(int key) { int val = cache.get(key); // 删除 key，重新插入到队尾 cache.remove(key); cache.put(key, val); } } 作者：labuladong 链接：https://leetcode.cn/problems/lru-cache/solutions/12711/lru-ce-lue-xiang-jie-he-shi-xian-by-labuladong/ 来源：力扣（LeetCode） 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

class LRUCache {

    int cap;

    LinkedHashMap<Integer, Integer> cache = new LinkedHashMap<>();

    public LRUCache(int capacity) {

        this.cap = capacity;

    }

    public int get(int key) {

        if (!cache.containsKey(key)) {

            return -1;

        }

        // 将 key 变为最近使用

        makeRecently(key);

        return cache.get(key);

    }

    public void put(int key, int val) {

        if (cache.containsKey(key)) {

            // 修改 key 的值

            cache.put(key, val);

            // 将 key 变为最近使用

            makeRecently(key);

            return;

        }

        if (cache.size() >= this.cap) {

            // 链表头部就是最久未使用的 key

            int oldestKey = cache.keySet().iterator().next();

            cache.remove(oldestKey);

        }

        // 将新的 key 添加链表尾部

        cache.put(key, val);

    }

    private void makeRecently(int key) {

        int val = cache.get(key);

        // 删除 key，重新插入到队尾

        cache.remove(key);

        cache.put(key, val);

    }

}

 

hashmap + linkedlist;

哈希表+linkedlist 双向链表，半手动半自动

import java.util.HashMap;

import java.util.LinkedList;

class LRUCache {

    private HashMap<Integer, Integer> map;

    private LinkedList<Integer> list;

    private int cap;

    public LRUCache(int capacity) {

        this.cap = capacity;

        map = new HashMap<>();

        list = new LinkedList<>();

    }

    public int get(int key) {

        if (!map.containsKey(key)) {

            return -1;

        }

        int val = map.get(key);

        list.remove((Integer) key);

        list.addFirst(key);

        return val;

    }

    public void put(int key, int val) {

        if (map.containsKey(key)) {

            list.remove((Integer) key);

        } else if (list.size() >= cap) {

            int leastRecentlyUsed = list.removeLast();

            map.remove(leastRecentlyUsed);

        }

        map.put(key, val);

        list.addFirst(key);

    }

}

手动实现

class LRUCache {

    // key -> Node(key, val)

    private HashMap<Integer, Node> map;

    // Node(k1, v1) <-> Node(k2, v2)...

    private DoubleList cache;

    // 最大容量

    private int cap;

    public LRUCache(int capacity) {

        this.cap = capacity;

        map = new HashMap<>();

        cache = new DoubleList();

    }

    public int get(int key) {

        if (!map.containsKey(key)) {

            return -1;

        }

        // 将该数据提升为最近使用的

        makeRecently(key);

        return map.get(key).val;

    }

    public void put(int key, int val) {

        if (map.containsKey(key)) {

            // 删除旧的数据

            deleteKey(key);

            // 新插入的数据为最近使用的数据

            addRecently(key, val);

            return;

        }

        if (cap == cache.size()) {

            // 删除最久未使用的元素

            removeLeastRecently();

        }

        // 添加为最近使用的元素

        addRecently(key, val);

    }

    /* 将某个 key 提升为最近使用的 */

    private void makeRecently(int key) {

        Node x = map.get(key);

        // 先从链表中删除这个节点

        cache.remove(x);

        // 重新插到队尾

        cache.addLast(x);

    }

    /* 添加最近使用的元素 */

    private void addRecently(int key, int val) {

        Node x = new Node(key, val);

        // 链表尾部就是最近使用的元素

        cache.addLast(x);

        // 别忘了在 map 中添加 key 的映射

        map.put(key, x);

    }

    /* 删除某一个 key */

    private void deleteKey(int key) {

        Node x = map.get(key);

        // 从链表中删除

        cache.remove(x);

        // 从 map 中删除

        map.remove(key);

    }

    /* 删除最久未使用的元素 */

    private void removeLeastRecently() {

        // 链表头部的第一个元素就是最久未使用的

        Node deletedNode = cache.removeFirst();

        // 同时别忘了从 map 中删除它的 key

        int deletedKey = deletedNode.key;

        map.remove(deletedKey);

    }

    class Node {

        public int key, val;

        public Node next, prev;

        public Node(int k, int v) {

            this.key = k;

            this.val = v;

        }

    }

    class DoubleList {

        // 头尾虚节点

        private Node head, tail;

        // 链表元素数

        private int size;

        public DoubleList() {

            // 初始化双向链表的数据

            head = new Node(0, 0);

            tail = new Node(0, 0);

            head.next = tail;

            tail.prev = head;

            size = 0;

        }

        // 在链表尾部添加节点 x，时间 O(1)

        public void addLast(Node x) {

            x.prev = tail.prev;

            x.next = tail;

            tail.prev.next = x;

            tail.prev = x;

            size++;

        }

        // 删除链表中的 x 节点（x 一定存在）

        // 由于是双链表且给的是目标 Node 节点，时间 O(1)

        public void remove(Node x) {

            x.prev.next = x.next;

            x.next.prev = x.prev;

            size--;

        }

        // 删除链表中第一个节点，并返回该节点，时间 O(1)

        public Node removeFirst() {

            if (head.next == tail)

                return null;

            Node first = head.next;

            remove(first);

            return first;

        }

        // 返回链表长度，时间 O(1)

        public int size() {

            return size;

        }

    }

}