LeetCode HOT 100 —— 146.LRU缓存

news2024/11/18 12:22:13

题目

请你设计并实现一个满足 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) 的平均时间复杂度运行。

在这里插入图片描述

思路

下面给出使用封装好的数据结构实现的代码，但是面试官一般不会看重，比如面试官希望你可以自己实现一个简单的双向链表，而不是使用语言自带的、封装好的数据结构，但是能写出下面的代码，至少说明还是对JDK源码有点了解的。

class LRUCache extends LinkedHashMap<Integer, Integer>{
    private int capacity;
    
    public LRUCache(int capacity) {
        super(capacity, 0.75F, true);//这里的参数都是源码里的，建议去读一读源码，比如capacity代表map的容量，loadFactor = 0.75F 代表加载因子 (默认即可)，accessorder = fasle表示按照读取顺序排序，true表示按照插入顺序排序，
        this.capacity = capacity;
    }

    public int get(int key) {
        return super.getOrDefault(key, -1);//LinkedHashMap 中的 getOrDefault()，即当key不存在时会返回默认值 -1
    }

    public void put(int key, int value) {
        super.put(key, value);
    }

    @Override
    protected boolean removeEldestEntry(Map.Entry<Integer, Integer> eldest) {
        return size() > capacity; 
    }
}

哈希表 + 双向链表：

LRU缓存机制可以通过哈希表 + 双向链表实现，用一个哈希表和一个双向链表维护所有在缓存中的键值对

双向链表按照被使用的顺序存储这些键值对，靠近头部的键值对是最近使用的，而靠近尾部的键值对是最久未使用的
哈希表就是普通的哈希映射（HashMap），通过缓存数据的键映射到其在双向链表的位置

然后，首先用哈希表进行定位，找出缓存项在双向链表中的位置，然后将这个缓存项移动到双向链表的头部，即可在O（1）时间内完成get和put操作，具体方法如下：

对于get操作，首先判断key是否存在：
（1）如果key不存在，返回-1
（2）如果key存在，则key对应的节点是最近被使用的节点。通过哈希表定位到该节点在双向链表中的位置，并将其移动到双向链表的头部，从而返回该节点的值
对于put操作，首先判断key是否存在
（1）如果key不存在，使用key和value创建一个新的节点，在双向链表的头部添加这个节点，并将key和该节点添加进哈希表，然后判断双向链表的节点数是否超出容量，如果超出容量，则删除双向链表的尾部节点，并删除哈希表中对应的项
（2）如果key存在，则与get操作类似，先通过哈希表定位，再将对应的节点的值更新为value，并将该节点移到双向链表的头部

上面的操作中，访问哈希表时间复杂度为O（1），在双向链表的头部添加节点、尾部删除节点的时间复杂度也是O（1），而将节点移到双向链表的头部，可以分成「删除该节点」和「在双向链表的头部添加节点」这两步，都是O（1）的时间复杂度

注意点：在双向链表的实现中，使用一个虚拟头结点(dummy head)和虚拟尾结点(dummy tail)标记界限，这样在添加节点和删除节点的时候就不需要检查相邻的节点是否存在

java代码如下：

public class LRUCache {
	class DLinkedNode {
		int key;
		int value;
		DLinkedNode prev;
		DLinkedNode next;
		public DLinkedNode (){}
		public DLinkedNode (int _key, int _value){
			key = _key;
			value = _value;
		}
	}
		
	private Map<Integer,DLinkedNode> cache = new HashMap<>();
	private int size;
	private int capacity;
	private DLinkedNode head,tail;
	
	public LRUCache(int capacity){
		this.size = 0;
		this.capacity = capacity;
		//使用虚拟头结点和虚拟尾结点
        head = new DLinkedNode();
        tail = new DLinkedNode();
        head.next = tail;
        tail.prev = head;
	}
		
	public int get(int key){
		DLinkedNode node = cache.get(key);
		if(node == null){
			return -1;
		}
		//如果key存在，先通过哈希表定位，再移到头部
		moveToHead(node);
		return node.value;
	}
	
	public void put(int key, int value){
		DLinkedNode node = cache.get(key);
		if(node == null){
			//如果 key 不存在，创建一个新的节点
			DLinkedNode newNode = new DLinkedNode(key, value);
			// 添加进哈希表
			cache.put(key, newNode);
			// 添加至双向链表的头部
			addToHead(newNode);
			size++;
            if (size > capacity) {
                // 如果超出容量，删除双向链表的尾部节点
                DLinkedNode tail = removeTail();
                // 删除哈希表中对应的项
                cache.remove(tail.key);
                size--;
            }
		} else {
			// 如果 key 存在，先通过哈希表定位，再修改 value，并移到头部
			node.value = value;
			moveToHead(node);
		}
	}

    private void addToHead(DLinkedNode node) {//在双向链表头结点位置插入操作
        node.prev = head;
        node.next = head.next;
        head.next.prev = node;
        head.next = node;
    }

    private void removeNode(DLinkedNode node) {
        node.prev.next = node.next;
        node.next.prev = node.prev;
    }

    private void moveToHead(DLinkedNode node) {//移动到头结点处，分成两步，先删除节点，然后再头结点处添加节点
        removeNode(node);
        addToHead(node);
    }

    private DLinkedNode removeTail() {//删除末尾节点
        DLinkedNode res = tail.prev;//因为有虚拟尾结点，所以是删除虚拟尾结点的前一个节点
        removeNode(res);
        return res;
    }
    
}