力扣146. LRU 缓存

Problem: 146. LRU 缓存

文章目录

题目描述

思路

主要说明大致思路,具体实现看代码。

1.为了实现题目中的O(1)时间复杂度的get与put方法,我们利用哈希表和双链表 的结合,将key作为键,对应的链表的节点作为值(也就是在此处我们用一个节点类作为值);

2.定义双链表 的节点类,其中包含每次put的键与对应的值,还包括前驱、后驱指针;

3.编写双链表的实现类,并实现:

3.1.初始化一个双链表(创建虚拟头、尾节点;由于我们要实现将最就不使用的节点删除,我们在此使用尾插法 即每次链表尾部位最近使用的,表头为最久不适用的);

3.2.实现尾插一个节点;

3.3.实现删除一个给定的节点;

3.4.实现从表头删除一个节点(删除最久不使用的节点)

3.5.返回链表的长度
4.实现LRUCache类:
4.1. 创建哈希表map与双链表cache;

4.2. 为了不直接在get与put中对map与cache操作带来麻烦(主要操作是同步在mao中添加key同时在cache中增、删、改对应节点的值),我们封装实现一些API(具体操作实现看代码)

4.3. 实现get与put方法(直接看代码)

复杂度

时间复杂度:

O ( n ) O(n) O(n);其中 n n n为要操作的次数

空间复杂度:

O ( n ) O(n) O(n)

Code

java 复制代码
/**
 * Node class
 */
class Node {
    public int key;
    public int val;
    public Node next;
    public Node prev;

    public Node(int k, int v) {
        this.key = k;
        this.val = v;
    }
}

class DoubleList {
    //The dummy node of head and tail to a double linked list
    private Node head;
    private Node tail;
    //The size of a linked list
    private int size;

    public DoubleList() {
        //Initialize the element of double linked list
        head = new Node(0, 0);
        tail = new Node(0, 0);
        head.next = tail;
        tail.prev = head;
        size = 0;
    }

    // Add node x at the end of the list, time O(1)
    // Tail insertion method of bidirectional linked list
    // with virtual head and tail nodes
    public void addLast(Node x) {
        x.prev = tail.prev;
        x.next = tail;
        tail.prev.next = x;
        tail.prev = x;
        size++;
    }

    // Delete the x node in the linked list (x must exist)
    // Since it is a double-linked list and given to the target Node,
    // time O(1)
    public void remove(Node x) {
        x.prev.next = x.next;
        x.next.prev = x.prev;
        size--;
    }

    // Delete the first node in the linked list
    // and return the node, time O(1)
    public Node removeFirst() {
        if (head.next == null) {
            return null;
        }
        Node first = head.next;
        remove(first);
        return first;
    }

    // Return list length, time O(1)
    public int size() {
        return size;
    }
}

class LRUCache {
    private HashMap<Integer, Node> map;
    private DoubleList cache;
    //Max capacity
    private int cap;

    public LRUCache(int capacity) {
        this.cap = capacity;
        map = new HashMap<>();
        cache = new DoubleList();
    }

    // Upgrade a key to the most recently used
    private void makeRecently(int key) {
        Node x = map.get(key);
        // Delete this node from the linked list first
        cache.remove(x);
        // Move back to the end of the line
        cache.addLast(x);
    }

    // Add the most recently used element
    private void addRecently(int key, int val) {
        Node x = new Node(key, val);
        // The end of the list is the most recently used element
        cache.addLast(x);
        // Add the mapping of the key to the map
        map.put(key, x);
    }

    // Delete a key
    private void deleteKey(int key) {
        Node x = map.get(key);
        // Delete from the linked list
        cache.remove(x);
        // Delete from map
        map.remove(key);
    }

    // Delete the element that has been unused the longest
    private void removeLeastRecently() {
        // The first element at the head of the list is the one
        // that has been unused for the longest time
        Node deletedNode = cache.removeFirst();
        // Delete its key from the map
        int deleteKey = deletedNode.key;
        map.remove(deleteKey);
    }

    public int get(int key) {
        if (!map.containsKey(key)) {
            return -1;
        }
        // Upgrade the data to the most recently used
        makeRecently(key);
        return map.get(key).val;
    }

    public void put(int key, int value) {
        if (map.containsKey(key)) {
            // Delete old data
            deleteKey(key);
            // The newly inserted data is the latest data
            addRecently(key, value);
            return;
        }
        if (cap == cache.size()) {
            // Delete the element that has been unused the longest
            removeLeastRecently();
        }
        // Add as recently used element
        addRecently(key, value);
    }
}

/**
 * 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);
 */
相关推荐
夜晚中的人海11 分钟前
【C++】滑动窗口算法习题
开发语言·c++·算法
此心光明事上练33 分钟前
大厂级企业后端:配置变更与缓存失效的自动化处理方案
运维·缓存·自动化
violet-lz1 小时前
数据结构四大简单排序算法详解:直接插入排序、选择排序、基数排序和冒泡排序
数据结构·算法·排序算法
·白小白1 小时前
力扣(LeetCode) ——118.杨辉三角(C++)
c++·算法·leetcode
CoovallyAIHub1 小时前
超越“识别”:下一代机器视觉如何破解具身智能落地难题?
深度学习·算法·计算机视觉
仰泳的熊猫1 小时前
LeetCode:207. 课程表
数据结构·c++·算法·leetcode
liu****2 小时前
19.map和set的封装
开发语言·数据结构·c++·算法
水冗水孚2 小时前
双指针算法在实际开发中的具体应用之代码Review文章字符串的片段分割
算法·leetcode
DuHz2 小时前
用于汽车雷达应用的步进频率PMCW波形——论文阅读
论文阅读·算法·汽车·信息与通信·信号处理·毫米波雷达
张晓~183399481212 小时前
碰一碰发抖音源码技术搭建部署方案
线性代数·算法·microsoft·矩阵·html5