LRU缓存机制实现-优快云博客

运用你所掌握的数据结构，设计和实现一个 LRU (最近最少使用) 缓存机制。它应该支持以下操作：获取数据 get 和写入数据 put 。

获取数据 get(key) - 如果密钥 (key) 存在于缓存中，则获取密钥的值（总是正数），否则返回 -1。
写入数据 put(key, value) - 如果密钥不存在，则写入其数据值。当缓存容量达到上限时，它应该在写入新数据之前删除最近最少使用的数据值，从而为新的数据值留出空间。

进阶:

你是否可以在 O(1) 时间复杂度内完成这两种操作？

示例:

LRUCache cache = new LRUCache( 2 /* 缓存容量 */ );

cache.put(1, 1);
cache.put(2, 2);
cache.get(1);       // 返回  1
cache.put(3, 3);    // 该操作会使得密钥 2 作废
cache.get(2);       // 返回 -1 (未找到)
cache.put(4, 4);    // 该操作会使得密钥 1 作废
cache.get(1);       // 返回 -1 (未找到)
cache.get(3);       // 返回  3
cache.get(4);       // 返回  4

====================================================

解题思路: 时间复杂度为O(1)的话,可以使用hashMap key为key, value为双向链表节点, 每次put和get都会将对应对应节点放置到链表头,每次删除节点都删除链表尾节点

class LRUCache {
    private Node first = null;
    private Node last = null;
    private int capacity = 0;
    private final HashMap<Integer, Node> cache;


    public LRUCache(int capacity) {
        this.capacity = capacity;
        cache = new HashMap<>();
    }

    public int get(int key) {
        Node getNode = cache.get(key);
        if (getNode == null) {
            return -1;
        }
        getNode.flush();
        return getNode.val;
    }

    public void put(int key, int value) {
        Node getNode = cache.get(key);
        if (getNode != null) {
            getNode.val = value;
            getNode.flush();
            return;
        }
        if (capacity == 0) {
            last.del();
        }
        Node newNode = new Node(key,value);
        cache.put(key,newNode);
        if (first == null) {
            first = newNode;
            last = newNode;
            capacity--;
            return;
        }
        first.pre = newNode;
        newNode.next = first;
        first = newNode;
        capacity--;
    }

    class Node {
        private Node pre;
        private int key;
        private int val;
        private Node next;

        private void del() {
            last = pre;
            if(pre!=null){
                pre.next = null;
            }
            pre = null;
            next = null;
            cache.remove(key);
            capacity++;
        }

        private void flush() {
            if (this==first){
                return;
            }
            pre.next = next;
            if(next==null){
                last = pre;
            }else {
                next.pre=pre;
            }
            pre = null;
            next = first;
            first.pre = this;
            first = this;
        }

        Node(int key, int val) {
            this.key = key;
            this.val = val;
        }
    }
}