阿里面试题：LRU 缓存机制（手写双链表，详细注释）

• • 题目描述
  • 示例
  • LRU性质分析
  • Java解法（详细注释）
  • leetcode 地址

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

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

输入
["LRUCache", "put", "put", "get", "put", "get", "put", "get", "get", "get"]
[[2], [1, 1], [2, 2], [1], [3, 3], [2], [4, 4], [1], [3], [4]]
输出
[null, null, null, 1, null, -1, null, -1, 3, 4]

解释
LRUCache lRUCache = new LRUCache(2);
lRUCache.put(1, 1); // 缓存是 {1=1}
lRUCache.put(2, 2); // 缓存是 {1=1, 2=2}
lRUCache.get(1);    // 返回 1
lRUCache.put(3, 3); // 该操作会使得关键字 2 作废，缓存是 {1=1, 3=3}
lRUCache.get(2);    // 返回 -1 (未找到)
lRUCache.put(4, 4); // 该操作会使得关键字 1 作废，缓存是 {4=4, 3=3}
lRUCache.get(1);    // 返回 -1 (未找到)
lRUCache.get(3);    // 返回 3
lRUCache.get(4);    // 返回 4

不多bb，一句话，最近用过的放在前边，放不下了删后边。（get put操作都算用过）

// 解法二： 需要自己实现双向链表
class LRUCache {
    // 定义双向链表节点
    class DlinkedNode {
        int key;
        int value;
        DlinkedNode pre;
        DlinkedNode next;
        public DlinkedNode() {}
        public DlinkedNode(int _key,int _val) {
            key = _key;
            value = _val;
        }
    }
    // 定义hashMap
    Map cache = new HashMap();
    // 定义双向链表头结点 尾结点
    DlinkedNode head,tail;
    // 定义缓冲区容量
    int capacity;
    // 定义当前缓冲区大小
    int size;

    public LRUCache(int capacity){
    	// 记录当前大小
        this.size = 0;
        // 记录总的容量
        this.capacity = capacity;
        // 定义伪头部和尾部
        tail = new DlinkedNode();
        head = new DlinkedNode();
        // 连接成双链表的形式
        tail.pre = head;
        head.next = tail;
    }

    public int get(int key){
        DlinkedNode node = cache.get(key);
        // 没有就返回-1
        if (node == null) return -1;
        // 使用了就移到最前边
        moveToHead(node);
        // 返回get到的值
        return node.value;
    }

    public void put(int key, int value) {
    	// 先看原来有没有
        DlinkedNode node = cache.get(key);
        // 当前插入节点不存在
        if (node == null) {
            // 新建节点
            node = new DlinkedNode(key,value);
            // 加入缓冲区
            cache.put(key,node);
            size++;
            // 添加到双链表的头部
            addToHead(node);
            // 超出容量删除尾结点(两处 一处双向链表的一处hasmap)
            if (size > capacity) {
            	// 删hashmap
                cache.remove(tail.pre.key);
                // 删双链表的
                removeNode(tail.pre);
                // 删完改变size
                size--;//很容易忘！！
            }
        // 当前节点存在
        } else {
            // 更改节点的值
            node.value = value;
            // 将节点移动到双链表头部
            moveToHead(node);
        }
    }
    
    public void addToHead(DlinkedNode node) {
        // 先连后，再连前
        head.next.pre = node;
        node.next = head.next; 
        head.next = node;
        node.pre = head;
    }
    public void removeNode(DlinkedNode node) {
        node.next.pre = node.pre;
        node.pre.next = node.next;
    }
    public void moveToHead(DlinkedNode node) {
        // 先remove掉原来的，再加新的
        removeNode(node);
        addToHead(node);
    }
}

LRU 缓存机制