题目描述：

运用你所掌握的数据结构，设计和实现一个  LRU (最近最少使用) 缓存机制

实现 LRUCache 类：

• LRUCache(int capacity) 以正整数作为容量 capacity 初始化 LRU 缓存

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

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

要求：O(1) 时间复杂度内完成这两种操作

思路分析：

缓存用HashMap，访问顺序用LinkedList

第一次尝试

public class LRUCacheFail {

    Map<Integer, Integer> cache = new HashMap<>();
    int capacity;
    LinkedList<Integer> queue = new LinkedList();

    public LRUCacheFail(int capacity) {
        this.capacity = capacity;
    }

    public int get(int key) {
        if (cache.containsKey(key)) {
            remove(key);//移除队列中的当前节点，但是这里做不到O(1)，所以不能这么干了
            addToHead(key);//把当前节点移动到头部
            return cache.get(key);
        } else {
            return -1;
        }
    }

    public void put(int key, int value) {
        if (cache.containsKey(key)) {
            remove(key);//移除队列中的当前节点，但是这里做不到O(1)，所以不能这么干了
            cache.put(key, value);
        } else {
            cache.put(key, value);
            if (capacity < cache.size()) {
                removeTail();
            }
        }
        addToHead(key);
    }

    private void removeTail() {

    }

    private void addToHead(int key) {
    }

    private void remove(Integer key) {
        //这里做不到O(1)，所以不能这么干了
    }
}

这里由于remove方法没办法O（1），所以需要对队列的结构进行修改

第二次尝试

public class LRUCache {
    int capacity;
    Map<Integer,Node<Integer,Integer>> cache = new HashMap<>();
    Node<Integer,Integer> head,tail;//辅助指针 实际头为head.next 尾为tail.prev

    public LRUCache(int capacity) {
        head = new Node<Integer, Integer>();
        tail = new Node<Integer, Integer>();
        this.capacity = capacity;
        head.next = tail;
        tail.prev = head;
    }

    public int get(int key) {
        if (cache.containsKey(key)) {
            remove(key);
            addToHead(key);
            return cache.get(key).value;
        }else {
            return -1;
        }
    }

    public void put(int key, int value) {
        if (cache.containsKey(key)) {
            remove(key);
            cache.put(key,new Node(key,value));
        }else {
            cache.put(key,new Node(key,value));
            if (capacity < cache.size()){
                removeTail();
            }
        }
        addToHead(key);
    }

    /**
     * 删掉某个节点
     * @param key
     */
    private void remove(Integer key) {
        Node<Integer, Integer> node = cache.get(key);
        node.prev.next = node.next;
        node.next.prev = node.prev;
    }

    //去除尾节点
    private void removeTail() {
        tail.prev.prev.next = tail;
        Integer key = tail.prev.key;
        cache.remove(key);
    }

    //把某个节点加到头节点
    private void addToHead(int key) {
        Node<Integer, Integer> node = cache.get(key);
        Node<Integer, Integer> next = head.next;
        node.prev = head;
        node.next = next;
        head.next = node;
        next.prev = node;
    }

    private class Node<K, V> {
        K key;
        V value;
        Node<K,V> prev;
        Node<K,V> next;

        public Node(K key, V value) {
            this.key = key;
            this.value = value;
        }

        public Node() {
        }
    }
}

本文正在参与「掘金 2021 春招闯关活动」, 点击查看 活动详情