算法记录

LeetCode 题目：

  设计和构建一个“最近最少使用”缓存，该缓存会删除最近最少使用的项目。缓存应该从键映射到值(允许你插入和检索特定键对应的值)，并在初始化时指定最大容量。当缓存被填满时，它应该删除最近最少使用的项目

---

思路

• 算法记录
• 说明
• • 一、题目
  • 二、分析
• 总结

---

说明

一、题目

  设计和构建一个“最近最少使用”缓存，该缓存会删除最近最少使用的项目。缓存应该从键映射到值(允许你插入和检索特定键对应的值)，并在初始化时指定最大容量。当缓存被填满时，它应该删除最近最少使用的项目

二、分析

• 题目涉及一个 hash 的设计, 其余的步骤全靠编码能力.
• 这里使用 hash 存储链表的节点形式来加快对链表元素的遍历.

class Node {
    int key;
    int value;
    Node pre;
    Node next;
    public Node(int key, int value) {
        this.next = null;
        this.pre = null;
        this.key = key;
        this.value = value;
    }
}

class LRUCache {
    Node head;
    Node tail;
    Integer size;
    Map<Integer,Node> map;

    public LRUCache(int capacity) {
        this.size = capacity;
        this.head = new Node(-1, -1);
        this.tail = new Node(-1, -1);
        head.next = tail;
        tail.pre = head;
        map = new HashMap();
    }
    
    public int get(int key) {
        if(!map.containsKey(key))
            return -1;
        put(key, map.get(key).value);
        return map.get(key).value;
    }
    
    public void put(int key, int value) {
        Node node = null;
        if(!map.containsKey(key)) {
            node = new Node(key, value);
            map.put(key, node);
            if(map.size() > size) {
                Node temp = head.next;
                temp.next.pre = temp.pre;
                temp.pre.next = temp.next;
                map.remove(temp.key);
            }
        } else {
            node = map.get(key);
            node.pre.next = node.next;
            node.next.pre = node.pre;
            map.get(key).value = value;
        }
        offer(node);
    }

    private void offer(Node node) {
        node.pre = tail.pre;
        node.next = tail;
        tail.pre.next = node;
        tail.pre = node;
    }
}

/**
 * Your LRUCache object will be instantiated and called as such:
 * LRUCache obj = new LRUCache(capacity);
 * int param_1 = obj.get(key);
 * obj.put(key,value);
 */

---

总结

熟悉 hash 表的使用。