模拟题 05 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
题目来源LeetCode

• 实现数据结构

  • 哈希 + 双向链表

• 代码

public class Node {
    int key;
    int val;
    Node pre, next;

    public Node(int key, int val) {
        this.key = key;
        this.val = val;
    }
}
public class Cache {
    private Node head;
    private Node tail;
    private int size;

    public void addFirst(Node node) {
        if(head == null) {
            head = tail =node;
        } else {
            Node n = head;
            head = node;
            node.next = n;
            n.pre = node;
        }
        size ++;
    }

    public void remove(Node node) {
        if(head == node && tail == node) {
            head = tail = null;
        } else if(head == node) {
            node.next.pre = null;
            head = head.next;
        } else if(tail == node) {
            tail = tail.pre;
            node.pre.next = null;
        } else {
            node.pre.next = node.next;
            node.next.pre = node.pre;

        }
        size -- ;
    }

    public Node removeLast() {
        Node node = tail;
        remove(tail);
        return node;
    }

    public int size() {
        return size;
    }
}

public class LRUCache {
    private  HashMap<Integer,Node> hashMap;
    private int capacity;
    private Cache cache;
    public LRUCache(int capacity) {
        hashMap = new HashMap<>();
        cache = new Cache();
        this.capacity = capacity;
    }

    public int get(int key) {
        if(!hashMap.containsKey(key)) {
            return -1;
        }
        int val ;
        put(key,val = hashMap.get(key).val );
        return val;
    }

    public void put(int key, int value) {
        Node x = new Node(key, value);
        if(hashMap.containsKey(key)) {
            cache.remove(hashMap.get(key));
        } else {
            if(cache.size() == capacity) {
                Node last = cache.removeLast();
                hashMap.remove(last.key);
            }
        }
        cache.addFirst(x);
        hashMap.put(key,x);
    }

    public static void main(String[] args) {
        LRUCache lruCache = new LRUCache(2);
        lruCache.put(1,1);
        lruCache.put(2,2);
        lruCache.get(1);
        lruCache.put(3,3);
        lruCache.get(2);
        lruCache.put(4,4);
        lruCache.get(1);
        lruCache.get(3);
        lruCache.get(4);
    }
}