【算法训练】LeetCode#146 LRU 缓存

一、描述

146. LRU 缓存

请你设计并实现一个满足 LRU (最近最少使用) 缓存 约束的数据结构。

实现 LRUCache 类：

• LRUCache(int capacity) 以 正整数 作为容量 capacity 初始化 LRU 缓存
• int get(int key) 如果关键字 key 存在于缓存中，则返回关键字的值，否则返回 -1 。
• void put(int key, int value) 如果关键字 key 已经存在，则变更其数据值 value ；如果不存在，则向缓存中插入该组 key-value 。如果插入操作导致关键字数量超过 capacity ，则应该 逐出 最久未使用的关键字。

函数 get 和 put 必须以 O(1) 的平均时间复杂度运行。

示例：

输入
["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

二、思路

实现功能很容易，但是有时空复杂度的要求，所以打算双向链表+数组，get用数组，put改链表节点位置。

（真不容易啊，还真过了）

三、解题

public static class LRUCache {

    public static class Node{
        int key;
        int value;
        Node last;
        Node next;
        public Node(int k,int v){
            key = k;
            value = v;
            last = null;
            next = null;
        }
        public Node(int k,int v,Node l,Node n){
            key = k;
            value = v;
            last = l;
            next = n;
        }
    }

    List<Node> arr = new ArrayList<>();
    Node head = null;
    Node tail = null;
    int maxSize;
    int curSize = 0;

    public LRUCache(int capacity) {
        maxSize = capacity;
        for (int i = 0 ; i < 10001 ; i++){
            arr.add(null); // 初始化
        }
    }

    // 需要做两个操作，一个是拿到key对应的值，一个是将其放入tail
    public int get(int key) {
        Node node = arr.get(key);
        if (node == null){
            return -1;
        }
        if (curSize == 1){
            return node.value;
        }
        if (node == head){
            // 如果该节点是头节点，且有后续节点
            head = node.next;
            head.last = null;
        } else if(node == tail){
            return node.value;
        } else {
            // 不是头节点
            node.last.next = node.next;
            node.next.last = node.last;
        }

        // 作为新节点放在最后
        node.last = tail;
        node.next = null;
        tail.next = node;
        tail = tail.next;
        arr.set(key,node);
        return node.value;
    }

    public void put(int key, int value) {
        Node node = null;
        if (arr.get(key) != null){
            // 对应的key有值，更新并移动节点到尾部
            node = arr.get(key);
            node.value = value; // 直接改
            if (curSize == 1){
                // 如果当前节点是唯一节点
                return;
            } else if (node == head){
                // 如果该节点是头节点,且有后续节点
                head = node.next;
                head.last = null;
                curSize--;
            } else if(node == tail){
                // 如果是尾节点
                return;
            } else {
                // 不是头节点
                node.last.next = node.next;
                node.next.last = node.last;
                node.last = null;
                node.next = null;
                curSize--;
            }
        } else {
            node = new Node(key,value);
        }
        // 无论是否存在，此时node即为最新节点

        if (curSize == 0){
            // 如果是第一次调用
            head = node;
            tail = node;
        } else {
            node.last = tail;
            tail.next = node;
            tail = tail.next;
            // 新插入节点永远在最后
        }
        arr.set(key,node);
        curSize++;

        if (curSize == maxSize+1){
            // 溢出处理
            arr.set(head.key,null); // 清空数组头节点
            head = head.next; // 因为头节点一直存储最老的节点，所以直接右移
            head.last = null;
            curSize--;
        }
    }
}