Java实现LRU

用Java实现LRU算法

LRU算法简介

LRU是Least Recently Used的缩写，即最近最少使用，是一种常用的页面置换算法，选择最近最久未使用的数据予以淘汰。

LRU的思想

设计思想

1. 所谓缓存，必须要有读+写两个操作，按照命中率的思路考虑，写操作+读操作时间复杂度都需要为O(1)
2. 特性要求
   1. 必须要有顺序之分，一区分最近使用的和很久没有使用的数据排序。
   2. 写和读操作一次搞定。
   3. 如果容量(坑位)满了要删除最不长用的数据，每次新访问还要把新的数据插入到队头(按照业务你自己设定左右那一边是队头)

查找快、插入快、删除快，且还需要先后排序---------->什么样的数据结构可以满足这个问题？

你是否可以在O(1)时间复杂度内完成这两种操作？

如果一次就可以找到，你觉得什么数据结构最合适？

答案：LRU的算法核心是哈希链表

编码手写如何实现LRU

本质就是HashMap + DoubleLinkedList

时间复杂度是O(1)，哈希表+双向链表

下图是算法示意图：

方法一：继承LinkedHashmap

public class LRUCacheDemo<k,v> extends LinkedHashMap<k,v>{
    private int capacity;
	
    public LRUCacheDemo(int capacity) {
        super(capacity,0.75F,true);      //最后一个参数代表是否更新到最新处
        this.capacity = capacity;
    }
	
    //重写removeEldestEntry，设置移除元素的规则，大于容量capacity则移除
    @Override
    protected boolean removeEldestEntry(Map.Entry<k, v> eldest) {
        return super.size() > capacity;
    }

    public static void main(String[] args) {
        LRUCacheDemo lruCacheDemo = new LRUCacheDemo(3);
        lruCacheDemo.put(1,"a");
        lruCacheDemo.put(2,"b");
        lruCacheDemo.put(3,"c");
        System.out.println(lruCacheDemo.keySet());
        lruCacheDemo.put(4,"d");
        System.out.println(lruCacheDemo.keySet());
        lruCacheDemo.get(2);
        System.out.println(lruCacheDemo.keySet());
    }
}

方法二：哈希表+双向链表

public class LRUCacheDemo2 {
    class Node<K,V>{
        K key;
        V value;
        Node<K,V> prev;
        Node<K,V> next;

        public Node() {
            this.prev = this.next = null;
        }
        public Node(K key,V value){
            super();
            this.key = key;
            this.value = value;
        }
    }

    class DoubleLinkedList<K,V>{
        Node<K,V> head;
        Node<K,V> tail;

        public DoubleLinkedList() {
            this.head = new Node<K,V>();
            this.tail = new Node<K,V>();
            this.head.next = this.tail;
            this.tail.prev = this.head;
        }

        public void addHead(Node<K,V> node){
            node.next = this.head.next;
            node.prev = this.head;
            this.head.next.prev = node;
            this.head.next = node;
        }

        public void removeNode(Node<K,V> node){
            node.prev.next = node.next;
            node.next.prev = node.prev;
            node.prev = null;
            node.next = null;
        }

        public Node<K,V> getLast(){
            if(this.tail.prev == this.head) return null;
            return this.tail.prev;
        }

        @Override
        public String toString() {
            List<K> list = new ArrayList<>();
            Node<K,V> pos = head.next;
            while (pos != tail){
                list.add(pos.key);
                pos = pos.next;
            }
            Collections.reverse(list);
            return list.toString();
        }
    }

    private int cacheSize;
    private Map<Integer,Node<Integer,Integer>> map;
    private DoubleLinkedList<Integer,Integer> doubleLinkedList;

    public LRUCacheDemo2(int cacheSize){
        this.cacheSize = cacheSize;
        map = new HashMap<>();
        doubleLinkedList = new DoubleLinkedList<>();
    }

    public int get(int  key){
        if(!map.containsKey(key)) return -1;
        Node<Integer,Integer> node = map.get(key);

        doubleLinkedList.removeNode(node);
        doubleLinkedList.addHead(node);
        return node.value;
    }

    public void put(int key,int value){
        if(map.containsKey(key)){
            Node<Integer,Integer> node = map.get(key);
            node.value = value;

            doubleLinkedList.removeNode(node);
            doubleLinkedList.addHead(node);
        }else {
            if(map.size() == cacheSize){
                Node<Integer, Integer> last = doubleLinkedList.getLast();
                map.remove(last.key);
                doubleLinkedList.removeNode(last);
            }
            Node<Integer, Integer> node = new Node<>(key, value);
            doubleLinkedList.addHead(node);
            map.put(key,node);
        }
    }

    public static void main(String[] args) {
        LRUCacheDemo2 lruCacheDemo = new LRUCacheDemo2(3);
        lruCacheDemo.put(1,1);
        lruCacheDemo.put(2,2);
        lruCacheDemo.put(3,3);
        System.out.println(lruCacheDemo.doubleLinkedList);
        lruCacheDemo.put(4,4);
        System.out.println(lruCacheDemo.doubleLinkedList);
        lruCacheDemo.get(2);
        System.out.println(lruCacheDemo.doubleLinkedList);
    }
}

方法三：如果没有O(1)的要求，也可以如下实现，原理同方法二

public class LRUCacheDemo3 {
    private List<Integer> list;
    private Map<Integer,Integer> map;
    private int cacheSize;

    public LRUCacheDemo3(int cacheSize) {
        this.cacheSize = cacheSize;
        list = new LinkedList<>();
        map = new HashMap<>();
    }

    public int get(int key){
        if(!map.containsKey(key)) return -1;
        list.add(list.remove(0));
        return map.get(key);
    }

    public void put(int key,int value){
        if(map.containsKey(key)){
            map.put(key,value);
            list.remove(Integer.valueOf(key));
        }else {
            if(map.size() == cacheSize){
                map.remove( list.remove(0));
            }
            map.put(key,value);
        }
        list.add(key);
    }

    public static void main(String[] args) {
        LRUCacheDemo3 lruCache = new LRUCacheDemo3(3);
        lruCache.put(1,1);
        lruCache.put(2,2);
        lruCache.put(3,3);
        System.out.println(lruCache.list);
        lruCache.put(4,4);
        System.out.println(lruCache.list);
        lruCache.get(2);
        System.out.println(lruCache.list);
    }
}

方法二能够O(1)主要是利用空间换取时间，用node记录数据，在链表查询的时候能达到O(1)。方法三中每次链表查询都与要遍历链表，故时间复杂度为O(N)。