Leetcode 146.LRU缓存 记录反思

链接

很难,官方提供了两种做法,做完思路还是不明确,所以记录一下深入反思

1.LinkedHashMap

2.hashmap + 双端队列

这道题目的意思可能就是打算让我们封装一个双端队列出来
所以主要记录一下第二种实现方法

从题目要求可以看到 get 和 put 都需要 时间复杂度为 O(1) ,所以可以很简单的想到需要使用 map来实现,然后题干中还有一个要求, 如果插入操作导致关键字数量超过 capacity ，则应该 逐出 最久未使用的关键字。 逐出最长不使用的元素,先想着用队列,但是一般的队列还不行,我们需要在元素被使用后将他放置到头部,这其中包含着删除插入操作,Deque只有删除添加首尾节点的作用,所以需要自己封装一个简单的双端队列

双端队列需要的功能

1. 删除选中的某个节点 (某个元素被使用的时候找到这个元素在队列中的位置) --removeNode()
2. 添加节点到头部 (添加新元素) --addNode()
3. 删除最后一个节点 (超过容量了,所以删除节点) --moveHead()
4. 将节点移动到头部 (说明这个元素刚刚被使用过) --removetail()

对于LRUcache本身 ,我们需要引入一些变量

    private Deque head = new Deque();  //双端队列的头
    private Deque tail = new Deque(); //双端队列的尾
    private Map<Integer,Deque> map = new HashMap<Integer,Deque>(); //cache,注意这里的value值是我们自己构造的双端队列 ,通过双断队列取得元素

    private int size;  //当前已经存入的元素
    private int capacity; //初始化大小

get函数逻辑

    public int get(int key) {
        Deque node = map.get(key);
        if (node == null) {
            return -1;
        }
        moveHead(node);
        return node.value;
    }

根据key值取得双端队列节点,如果节点为空,就返回-1,不为空就将当前节点移动到双端队列最前面,然后值

put函数逻辑

public void put(int key, int value) {
        Deque node = map.get(key);
        if(node == null){
            Deque newnode = new Deque(key,value);
            map.put(key,newnode);
            size++;
            addNode(newnode);
            if (size > capacity) {
                Deque tail = removetail();
                map.remove(tail.key);
                --size;
            }
        }else{
            node.value = value;
            moveHead(node);
        }
    }

根据key值取得节点,如果节点为空就说明不在map中,就新创建一个节点,对节点赋值存入到map中,如果存在就将节点值更新,并且移动节点到头部

代码

class LRUCache {
    class Deque {//双端队列
        int key;
        int value;
        Deque prev;
        Deque next;
        public Deque() {}
        public Deque(int _key, int _value) {
            key = _key; 
            value = _value;
        }
    }
    private Deque head = new Deque();
    private Deque tail = new Deque();
    private Map<Integer,Deque> map = new HashMap<Integer,Deque>();
    private int size;
    private int capacity;
    public LRUCache(int capacity) {
        this.size = 0;
        this.capacity = capacity;
        head.next = tail;
        tail.prev = head;
    }
    
    public int get(int key) {
        Deque node = map.get(key);
        if (node == null) {
            return -1;
        }
        // 如果 key 存在，先通过哈希表定位，再移到头部
        moveHead(node);
        return node.value;
    }
    
    public void put(int key, int value) {
        Deque node = map.get(key);
        if(node == null){
            Deque newnode = new Deque(key,value);
            map.put(key,newnode);
            size++;
            addNode(newnode);
            if (size > capacity) {
                Deque tail = removetail();
                map.remove(tail.key);
                --size;
            }
        }else{
            node.value = value;
            moveHead(node);
        }
    }
        void removeNode(Deque node){
            node.prev.next = node.next;
            node.next.prev = node.prev;
        }

        void addNode(Deque node ){
            node.prev = head;
            node.next = head.next;
            head.next.prev = node;
            head.next = node;
        }

        void moveHead(Deque node){
            removeNode(node);
            addNode(node);
        }

        Deque removetail(){
            Deque res = tail.prev;
            removeNode(res);
            return res;
        }
}

总结

慢慢剖析自己需要的功能之后,思路还是比较清晰的,希望下次做还能做出来