LeetCode刷题---LRU缓存

LRU

LRU是Least Recently Used的缩写，即最近最少使用，是一种内存管理算法，也可以用作缓存淘汰策略。

这种算法的核心思想是：如果数据最近被访问过，那么将来被访问的几率也更高。

因此，当内存或缓存容量有限，需要淘汰部分数据时，LRU算法会优先淘汰那些最长时间未被访问的数据。

解题思路

该题使用哈希表+双向链表的思想来解决

首先定义双向链表，链表中包含key和value

定义哈希表来存储双向链表中各个节点的位置，键为key，值为双向链表中的节点

根据LRU算法的特点，此处选择在双向链表的头部来插入数据，尾部则表示最近最少使用的数据(如果容量超出限制的时候，此处的节点需要被踢出)

在写get方法来获取某节点的时候，如果哈希表中存储了该节点，根据LRU算法，则先将该节点删除，再将该节点添加到链表中。如果哈希表中未存储该节点，则返回-1。

在写put方法的时候，如果哈希表中未存储该节点，则创建一个新的节点，节点中key和value分别为要添加的键和值，之后将key和新创建的节点添加到哈希表中，在将新的节点添加到链表头部。此时链表的大小size+1

再对size进行判断，如果size超过了定义的容量大小capacity，则根据LRU算法，需要将最近最少使用的元素(表尾节点删除)，使得size最大为capacity。如果哈希表中已经存储该节点，则需要对该节点的数据进行更新，首先根据key从哈希表中取出该节点，再对节点中的value重新赋值，之后根据LRU算法将该节点从链表中删除，再添加到链表表头的位置。

LeetCode LRU官方题解

复制代码

public class LRUCache {
    LRUNode head,tail;
    int size,capacity;
    Map<Integer,LRUNode> map=new HashMap<>();
    public LRUCache(int capacity) {
        this.capacity=capacity;
        this.size=0;
        //头尾相连
        head=new LRUNode();
        tail=new LRUNode();
        head.next=tail;
        tail.pre=head;

    }

    //如果最近使用了该节点，就将该节点放入表头
    public int get(int key) {
        if(!map.containsKey(key))
        {
            return -1;
        }
        else
        {
            LRUNode lruNode = map.get(key);
            moveNode(lruNode);
            return lruNode.val;
        }
    }

    public void put(int key, int value) {
        if(!map.containsKey(key))
        {
            //创建一个新的节点
            LRUNode lruNode=new LRUNode(key,value);
            //将新节点加入哈希表中
            map.put(key,lruNode);
            //将其添加到表头
            addNode(lruNode);
            //如果容量大于capacity
            ++size;
            if(size>capacity)
            {
                //如果超出容量，就将表尾节点删除
                LRUNode pre = tail.pre;
                removeNode(pre);
                //删除哈希表中的对应项
                map.remove(pre.key);
                --size;
            }

        }
        else
        {
            //如果key已经存在
            LRUNode lruNode = map.get(key);
            //先修改其节点的值
            lruNode.val=value;
            //再将其删除并重新添加至表头
            moveNode(lruNode);
        }

    }

    //删除节点
    public void removeNode(LRUNode node)
    {
        node.pre.next=node.next;
        node.next.pre=node.pre;
    }
    //添加节点
    public void addNode(LRUNode node)
    {
        node.pre=head;
        node.next=head.next;
        head.next.pre=node;
        head.next=node;

    }

    public void moveNode(LRUNode node)
    {
        removeNode(node);
        addNode(node);
    }



}

class LRUNode {
    int key,val;
    LRUNode pre,next;
    public LRUNode()
    {

    }

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