JAVA实现LRU缓存

1. 题目：

设计LRU缓存结构，该结构在构造时确定大小，假设大小为K,并有如下两个功能：
（1）set(key,Value)：将记录（key,Value）插入该结构
（2）gte(key)：返回key对应的value值

2. 要求：

（1）set和get方法的时间复杂度为O(1)。
（2）某个key的set或get操作一旦发生，认为这个key的记录成了最常使用的。
（3）当缓存的大小超过K时，移除最不经常使用的记录，即set和get最久远的。

3. 思路：

实现一个双向链表，功能：
	增加节点
	删除头节点
	将使用的节点放在尾端
建立一个key-node的map，用于查找node

4. 代码实现

• 双向链表

class LRUCache {
    private Map<Integer,DoubleLinkedList> map;
    private int capacity;
    private DoubleLinkedList head;
    private DoubleLinkedList tail;
    public LRUCache(int capacity) {
        this.capacity=capacity;
        map=new HashMap<>();
        head=new DoubleLinkedList(-1,-1);
        tail=new DoubleLinkedList(-1,-1);
        head.next=tail;
        tail.pre=head;
    }
    
    public int get(int key) {
    	//说明不存在
        if(!map.containsKey(key)){
            return -1;
        }
        //断开当前节点
        DoubleLinkedList node=map.get(key);
        node.next.pre=node.pre;
        node.pre.next=node.next;
        //将当前节点放到尾结点
        removeToTail(node);
        return node.val;
    }
    
    public void put(int key, int value) {
        //如果存在，则将value值更新，get方法会将其移动到最后面
        if(get(key)!=-1){
            map.get(key).val=value;
            return;
        }
        //不存在，在尾部添加一个
        DoubleLinkedList node=new DoubleLinkedList(key,value);
        removeToTail(node);
        map.put(key,node);
        //如果大小大于最大值了
        if(map.size()>capacity){
            map.remove(head.next.key);
            //移除头节点
            head.next=head.next.next;
            head.next.pre=head;
        }
    }

    private void removeToTail(DoubleLinkedList node){
        tail.pre.next=node;
        node.pre=tail.pre;
        node.next=tail;
        tail.pre=node;
    }

    private class DoubleLinkedList{
        int key;
        int val;
        DoubleLinkedList pre;
        DoubleLinkedList next;

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