LeetCode刷题3：LRU缓存机制

请你设计并实现一个满足  LRU (最近最少使用) 缓存 约束的数据结构。

具体题目：146. LRU 缓存 - 力扣（LeetCode） (leetcode-cn.com)

首先设计哈希表加双向链表的数据结构

HashMap<Integer,Node>cache

通过哈希表的键可以找到缓存数据在双向链表中的位置，而双向链表主则按照键值对使用的顺序进行顺序存储

 

 

 

 

 

class LRUCache {
    private int cap;
    public Node head;
    public Node tail;
    public HashMap<Integer,Node>cache;

    //初始化缓存
    public LRUCache(int capacity) {
        cache=new HashMap<>();
        head=new Node(-1,-1);
        tail=new Node(-1,-1);
        head.next=tail;
        tail.pre=head;
        this.cap=capacity;
    }
    
    public int get(int key) {
        Node node=cache.get(key);
        if(node==null)
        return -1;
        moveToTail(node,node.val);//最近使用
        return node.val;
    }
    
    public void put(int key, int value) {
        if(cache.containsKey(key)){//已存在则为最近使用，移到末尾
            Node node=cache.get(key);
            moveToTail(node,value);
        }
        else
        {
            if(cache.size()==this.cap){//cache是否已满
                Node node=head.next;
                delete(node);
                cache.remove(node.key);
            }
            Node newNode=new Node(key,value);
            insertTail(newNode);
            cache.put(key,newNode);
        }
    }

    public void insertTail(Node node){
        node.pre=tail.pre;
        node.next=tail;
        tail.pre.next=node;
        tail.pre=node;
    }

    public void delete(Node node){
        node.pre.next=node.next;
        node.next.pre=node.pre;
    }

    public void moveToTail(Node node,int val){
        delete(node);
        insertTail(node);
        node.val=val;
    }
}

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