【Leetcode】LRU Cache

Design and implement a data structure for Least Recently Used (LRU) cache. It should support the following operations: get and set.

get(key) - Get the value (will always be positive) of the key if the key exists in the cache, otherwise return -1.

set(key, value) - Set or insert the value if the key is not already present. When the cache reached its capacity, it should invalidate the least recently used item before inserting a new item.

------------------------------------------------------------------------------------------------------------------------

No wonder the low pass rate. This question could be the top few hard among all leetcode problems. Classic and deeply testing interviewee's data structure ability.

When I came to this question problem firstly, I realize we need to build like a "HashQueue".

1<-2<-3<-4<-5, when "2" come again, it turns into 1<-3<-4<-5-<2.

Or 1<-2<-3<-4<-5, when 6 come for the first time, it turns into 2<-3<-4<-5-<6. We kicked out the oldest element. 

Thus, if we can build a hashtable / hashmap, ensuring the uniqueness of an element, and in the meantime first in first out OR update appeared element.

However, we don't have such a data structure called "hashqueue" so we have to build one on our own.

So my idea is like this: HashMap<key, Node>, where Node is {key, value, pre, next}. Node is basically containing all information and pointing to the pre or next element. Based on such data structure, we can easily manipulate the whole "stream", or say queue.

import java.util.HashMap;

public class LRU {
	//define how many element could contains in the cache
	int capacity;
	//we need a hashmap to ensure every incoming element is unique. 
	//By using hashmap, we can find corresponding Node to move.
	HashMap<Integer, Node> map = new HashMap<Integer, Node>();
	//we need to define the head (latest node) and end (least recent node) 
	Node head = null;
	Node end = null;
	
	public LRU(int capacity) {
		this.capacity = capacity;
	}
    
    public int get(int key) {
    	if(map.containsKey(key)){
    		Node n = map.get(key);
    		
    		remove(n);
    		//let n be the latest element
    		setHead(n);
    	}
		return -1;
    }
    
    private void remove(Node n){
    	if(n.pre!=null){
    		n.pre.next = n.next;
    	}
    	if(n.next!=null){
    		n.next.pre = n.pre;
    	}
    	
    		
    }
    
    private void setHead(Node n){
    	n.next = head;
    	n.pre = null;
    	head.pre = n;
    	head = n;
    	//not sure about below
    	 if(end ==null)
             end = head;
    }
    
    
    public void set(int key, int value) {
        if(map.get(key)!=null){
        	Node old = map.get(key);
        	remove(old);
        	setHead(old);
        }
        else{
        	Node new_ = new Node(key, value);
        	if(map.size() > capacity){
        		map.remove(end.key);
        		remove(end);
        		setHead(new_);
        	}
        	else{
        		setHead(new_);
        	}
        	map.put(key, new_);
        }
        
        	
    }
    
    //define the data structure of a single Node as a double-linkedlist
    class Node{
    	int key;
    	int value;
    	Node pre;
    	Node next;
    	public Node(int k, int v){
    		this.key = k;
    		this.value = v;
    	}
    }
}

 Moreover!!!!!

I found another method that directly extended LinkedHashMap, which largely facilitate the whole process.

import java.util.LinkedHashMap;
import java.util.Map.Entry;
 
public class LRUCache extends LinkedHashMap<Integer, Integer> {
   
    private int capacity;
   
    public LRUCache(int capacity) {
        super(capacity+1, 1.0f, true);  // for access order
        this.capacity = capacity;
    }
   
    public int get(int key) {
        if(super.get(key) == null)
            return -1;
        else
            return ((int) super.get(key));
    }
   
    public void set(int key, int value) {
        super.put(key, value);
    }
   
    protected boolean removeEldestEntry(Entry entry) {
        return (size() > this.capacity);
    }
}

What you need to know:

LinkedHashMap(int capacity, float fillRatio, boolean Order)

This constructor allows you to specify whether the elements will be stored in the linked list by insertion order, or by order of last access. If Order is true, then access order is used. If Order is false, then insertion order is used. .

protected boolean removeEldestEntry(Map.Entry eldest)

Returns true if this map should remove its eldest entry.

If you wanna know more about LinkedHashMap, here we go:

http://zhangshixi.iteye.com/blog/673789