力扣 - 146. LRU缓存机制

目录

• 题目
• 思路
  • 代码
  • 复杂度分析

题目

146. LRU缓存机制

思路

• 利用双链表和HashMap来解题
• 看到链表题目，我们可以使用头尾结点可以更好进行链表操作和边界判断等
• 还需要使用size变量来存储双链表的当前长度
• 调用get，如果存在的话，我们可以调用将在双链表中的结点通过修改指针移动到第一个；如果调用put，我们先判断是否存在该结点，如果不存在，可直接将链接插入即可，同时size++，如果存在的话，先删除原来的结点，再将新结点push到头部即可

代码

class LRUCache {
    class Node {
        int key;
        int val;
        Node pre;
        Node next;

        public Node() {}

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

    // 哈希表中的node和双链表的node是同一个结点
    private HashMap<Integer, Node> cache;
    private Node dummyHead;
    private Node dummyTail;
    private int size;
    private int capacity;

    public LRUCache(int capacity) {
        cache = new HashMap<>();
        dummyHead = new Node();
        dummyTail = new Node();
        dummyHead.next = dummyTail;
        dummyTail.pre = dummyHead;
        this.capacity = capacity;
        this.size = 0;
    }
    
    public int get(int key) {
        // 先获取看看结点存不存在
        Node node = cache.get(key);
        // 如果存在的话，将当前访问的结点移动到链表头，并且返回值
        if (node != null) {
            moveToHead(node);
            return node.val;
        }
        // 不存在的话就返回-1
        return -1;
    }
    
    public void put(int key, int value) {
        // 也是先看看结点是否存在
        Node node = cache.get(key);
        // 如果存在，那么要做的操作就是将结点移动到链表头，然后更新结点值即可
        if (node != null) {
            node.val = value;
            moveToHead(node);
        } else {
            // 如果不存在的话我们就要创建新结点插入
            Node newNode = new Node(key, value);
            // 先添加到哈希表中
            cache.put(key, newNode);
            // 再添加到链表中
            addToHead(newNode);
            // 并且长度+1
            size++;
            // 因为我们设定最大容量，我们还要判断新put的结点后，容量是否超过了capacity，超过了话，删除最后一个结点，并且长度-1
            if (size > capacity) {
                Node tail = removeTail();
                cache.remove(tail.key);
                size--;
            }
        }
    }

    /**
    * 将node移动到最前面
    */
    private void moveToHead(Node node) {
        if (size > 0 && size <= capacity) {
            remove(node);
            addToHead(node);
        }
    }

    /**
    * 删除node结点
    */
    private void remove(Node node) {
        if (size > 0) {
            node.pre.next = node.next;
            node.next.pre = node.pre;
        }
    }

    /**
    * 删除最后一个结点
    */
    private Node removeTail() {
        if (size > 0) {
            Node node = dummyTail.pre;
            remove(node);
            return node;
        }
        return null;
    }

    /**
    * 添加新结点到第一位去
    */
    private void addToHead(Node node) {
        node.next = dummyHead.next;
        dummyHead.next = node;
        node.next.pre = node;
        node.pre = dummyHead;
    }
}

复杂度分析

• 时间复杂度：\(O(1)\)
• 空间复杂度：\(O(N)\)，其中 N 为初始化的 capacity 容量