LeetCode之LRU缓存机制

LeetCode之LRU缓存机制

• 题目来源于Leetcode146.LRU 缓存机制。
• 运用你所掌握的数据结构，设计和实现一个 LRU (最近最少使用) 缓存机制 。
• 实现 LRUCache 类：

class LRUCache {
	//LRUCache(int capacity) 以正整数作为容量 capacity 初始化 LRU 缓存
	public LRUCache(int capacity) {
	
	}
	//int get(int key) 如果关键字 key 存在于缓存中，则返回关键字的值，否则返回 -1
	//时间复杂度O(1)
	public int get(int key) {
	
	}
	//void put(int key, int value) 如果关键字已经存在，则变更其数据值；
	//如果关键字不存在，则插入该组「关键字-值」。
	//当缓存容量达到上限时，它应该在写入新数据之前删除最久未使用的数据值，从而为新的数据值留出空间。
	//时间复杂度O(1)
	public void put(int key, int value) {
	
	}
}

• 分析：

1. 需要在时间复杂度O(1)内get，即需要可以在任意位置查找元素
2. 需要在时间复杂度O(1)内put，即需要可以在任意位置查找、删除、插入元素
3. 需要键值对按照 添加顺序、修改顺序排序，则需要有序

• 综上所述：

  1. 哈希表可以实现在快速查找元素，但是无序
  2. 链表可以实现在快速删除、插入元素，且有序，但是查找慢
  3. 所以我们可以使用哈希表和链表的结合体：LinkedHashMap
  4. 我们可以自己通过HashMap和一条双向链表实现LinkedHashMap
     

• 具体的操作：

  • 插入操作：新建一个node，保存着键值对。在HashMap新建一个键值对，键为key，值为node。将node插入到双向链表中：如果node节点的个数还没有达到上限，直接插入到链表的头；如果链表节点的个数达到上限，则除了插入node到链表头以外，还需要删除链表尾的节点node1，【同时删除对应节点node1的HashMap中的键值对】。
  • 查找操作：通过key，在HashMap中找到对应的node，从而得到对应的value。再node节点取出，查到双向链表的表头中，以满足 LRU (最近最少使用) 缓存机制 的特性。

• 代码实现

class LRUCache {
    //定义Node内部类
    class Node {
        public int key, value;
        public Node pre, next;

        public Node() {
        }

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

    private HashMap<Integer, Node> hashMap;
    private int capacity;
    private Node head;
    private Node tail;

    public LRUCache(int capacity) {
        this.hashMap = new HashMap<>();
        this.capacity = capacity;
        this.head = null;
        this.tail = null;
    }

    public int get(int key) {
        //查找节点
        Node node = hashMap.get(key);
        //该节点不存在
        if (node == null) {
            return -1;
        }
        //该节点存在
        else {
            int res = node.value;
            //将节点移到表头
            node.pre.next = node.next;
            node.next.pre = node.pre;
            addHead(node);
            return res;
        }
    }

    public void put(int key, int value) {
        //查找节点
        Node node = hashMap.get(key);
        //该节点不存在
        if (node == null) {
            node = new Node(key, value);
            //将该节点加入双向链表和hashMap
            //容量已经到达了上限，同时在链表和hashMap中删除最久未使用节点
            if (hashMap.size() == capacity) {
                Node last = tail.pre;
                Node beforeLast = tail.pre.pre;
                beforeLast.next = tail;
                tail.pre = beforeLast;
                int keyToDel = last.key;
                hashMap.remove(keyToDel);
            }
            addHead(node);
            hashMap.put(key, node);
        }
        //该节点存在
        else {
            //修改节点的值，将节点移到头
            node.value = value;
            node.pre.next = node.next;
            node.next.pre = node.pre;
            addHead(node);
        }
    }

    //将节点node添加到链表头head之后
    private void addHead(Node node) {
        //双向链表为空
        if (head == null) {
            head = new Node(0, 0);
            tail = new Node(0, 0);
            head.next = node;
            node.pre = head;
            node.next = tail;
            tail.pre = node;
        }
        //双向链表非空
        else {
            Node temp = head.next;
            head.next = node;
            node.pre = head;
            node.next = temp;
            temp.pre = node;
        }
    }
}