方案一：LinkedList+HashMap

• 時間複雜度o(n)

class LRUCache{

    private Map<Integer, Integer> map;
    private Queue<Integer> queue;
    private int capacity;

    public LRUCache(int capacity) {
        this.capacity = capacity;
        map = new  HashMap<Integer, Integer>();
        //隊首為最近不使用，隊尾為最近經常使用
        queue = new LinkedList<Integer>();
    }
    
    public int get(int key) {
        if(queue.contains(key)){
            queue.remove(key);//時間複雜度o(n)
            queue.add(key);
            return map.get(key);
        }else{
            return -1;
        }
    }
    
    public void put(int key, int value) {
        if(queue.contains(key)){
            queue.remove(key);
            queue.add(key);
            map.put(key, value);
        }else if(capacity == 0){
            queue.poll();
            map.remove(key);
            queue.add(key);
 

方案二：雙向連結串列+HashMap

• 時間複雜度o(1)

class LRUCache{
    class Node{
        int key, val;
        Node next, prev;
        public Node(int k, int v){
            this.key = k;
            this.val = v;
        }
    }

    class DoubleList{
        private Node head, tail;
        private int size;

        public void addFirst(Node node){
            if(head == null){
                head = tail = node;
            }else{
                head.prev = node;
                node.next = head;
                head = node;
            }
            size++;
        }

        public void remove(Node node){
            if(head == node && tail == node){
                head = tail = null;
            }else if(tail == node){
                node.prev.next = null;
                tail = node.prev;
            }else if(head == node){
                node.next.prev = null;
                head = node.next;
            }else{
                node.next.prev = node.prev;
                node.prev.next = node.next;
            }
            size--;
        }

        public Node removeLast(){
            Node node = tail;
            remove(tail);
            return node;
        }

        public int getSize(){
            return size;
        }
    }

    private Map<Integer, Node> map;
    private DoubleList cache;
    private int cap;

    public LRUCache(int capacity){
        this.map = new HashMap<Integer,Node>();
        this.cache = new DoubleList();
        this.cap = capacity;
    }

    public int get(int key){
        if(!map.containsKey(key)) return -1;
        int val = map.get(key).val;
        put(key, val);
        return val;
    }

    public void put(int key, int val){
        Node x = new Node(key, val);
        if(map.containsKey(key)){
            cache.remove(map.get(key));
            cache.addFirst(x);
            map.put(key, x);
        }else{
            if(cap == cache.getSize()){
                Node node = cache.removeLast();
                map.remove(node.key);
            }
            cache.addFirst(x);
            map.put(key, x);
        }
    }
}
 

方案三：LinkedHashMap

• Java的API實現

class LRUCache extends LinkedHashMap<Integer, Integer>{
    private int capacity;
    
    public LRUCache(int capacity) {
        super(capacity, 0.75F, true);
        this.capacity = capacity;
    }

    public int get(int key) {
        return super.getOrDefault(key, -1);
    }

    // 這個可不寫
    public void put(int key, int value) {
        super.put(key, value);
    }

    @Override
    protected boolean removeEldestEntry(Map.Entry<Integer, Integer> eldest) {
        return size() > capacity; 
    }
}