《leetcode》：哈希表

目录

146. LRU 缓存

---

146. LRU 缓存

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

解题思路：LRU 缓存机制可以通过哈希表辅以双向链表实现，我们用一个哈希表和一个双向链表维护所有在缓存中的键值对。双向链表按照被使用的顺序存储了这些键值对，靠近头部的键值对是最近使用的，而靠近尾部的键值对是最久未使用的。哈希表即为普通的哈希映射（HashMap），通过缓存数据的键映射到其在双向链表中的位置。这样以来，我们首先使用哈希表进行定位，找出缓存项在双向链表中的位置，随后将其移动到双向链表的头部，即可在 O(1)O(1) 的时间内完成 get 或者 put 操作。具体的方法如下：

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

LRU缓存机制，即采用最近最少使用的缓存策略。它的原则是，如果一个数据最近没有被访问到，那么它将来被访问的几率也很小，也就是说当限定的内存空间已没有其他空间可用时，应该把最久没有访问到的数据去除掉。

class LRUCache {
    // 定义双链表
    class DLinkNode{
        int key;
        int value;
        DLinkNode pre;
        DLinkNode next;
        public DLinkNode(){}
        public DLinkNode(int _key,int _value){
            key=_key;
            value=_value;
        }
    }
    //定义哈希表、头指针、尾指针等全局变量
    private Map<Integer,DLinkNode>cache=new HashMap<Integer,DLinkNode>();
    int size;
    int capacity;
    private DLinkNode head,tail;
    //定义LRUCache函数体
    public LRUCache(int capacity) {
        this.size=0;
        this.capacity=capacity;
        head=new DLinkNode();
        tail=new DLinkNode();
        head.next=tail;
        tail.pre=head;
    }
    
    public int get(int key) {
        DLinkNode node=cache.get(key);
        if(node==null)
            return -1;
        //把查到的结点移到头结点上
        moveToHead(node);
        return node.value;
    }
    
    public void put(int key, int value) {
        //1、先查有没有这个结点
        DLinkNode node=cache.get(key);
        if(node==null){
            DLinkNode temp=new DLinkNode(key,value);
            cache.put(key,temp);
            addToHead(temp);
            ++size;
            if(size>capacity){
                DLinkNode tailnode=deleteTail();
                cache.remove(tailnode.key);
                --size;
            }
        }
        else{
            node.value=value;
            moveToHead(node);
        }
    }
    //将结点插入至头结点后
    public void addToHead(DLinkNode node){
        node.next=head.next;
        head.next.pre=node;
        node.pre=head;
        head.next=node;
    }
    //把查到的结点移到头结点上
    public void moveToHead(DLinkNode node){
        deleteNode(node);
        addToHead(node);
    }
    void deleteNode(DLinkNode node){
        node.pre.next=node.next;
        node.next.pre=node.pre;
    }
    //删除尾结点
    public DLinkNode deleteTail(){
        DLinkNode deleteres=tail.pre;
        deleteNode(deleteres);
        return deleteres;
    }
}

/**
 * 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);
 */