leetcode: LRU Cache

这道题的话其实是比较奇怪的。

LRU Cache考虑两个操作：查找和插入。

查找：寻找匹配的项，并且把该项设为最近访问。

插入：没满，把元素插入，并把插入的元素设为最近访问；满了，删除最近最少访问的元素，插入，并把插入的元素设为最近访问。

在实际的系统中我们应该考虑两个问题：1.cache的命中率是相当高的，这意味着查找的次数远多于插入的次数。2.Cache的空间有限而且宝贵，运算速度（主要是load和store的速度）极快，所以我们应该考虑的是用时间换空间的做法，而没有多余的空间可以让我们存储额外的数据结构。

在不考虑组相联的情况下，我们可以用冒泡数组来实现，越靠近数组头的元素是越最近使用的。我们应该删除数组末尾的元素。

public class LRUCache {
	
	public int[][] cacheBuffer;
	public int last;
	
    public LRUCache(int capacity) {
        cacheBuffer=new int[capacity][2];
        for(int i=0;i<capacity;i++)
        {
            cacheBuffer[i][0]=-1;
            cacheBuffer[i][1]=-1;
        }
        last=0;
    }
    
    public int get(int key) {
    	int tmpValue=-1;
        for(int i=0;i<last;i++)
        {
        	if(cacheBuffer[i][0]==key)
        	{
        		tmpValue=cacheBuffer[i][1];
        		for(int j=i;j>0;j--)
        		{
        			cacheBuffer[j][0]=cacheBuffer[j-1][0];
        			cacheBuffer[j][1]=cacheBuffer[j-1][1];
        		}
        		cacheBuffer[0][0]=key;
        		cacheBuffer[0][1]=tmpValue;
        		return tmpValue;
        	}
        }
        return tmpValue;		
    }
    
    public void set(int key, int value) {
        if(last<cacheBuffer.length)
        	last++;
        for(int j=last-1;j>0;j--)
		{
			cacheBuffer[j][0]=cacheBuffer[j-1][0];
			cacheBuffer[j][1]=cacheBuffer[j-1][1];
		}
		cacheBuffer[0][0]=key;
		cacheBuffer[0][1]=value;
    }
}

但是leetcode上超时，所以刷题永远不是解决实际问题能比的。好吧我们知道了这个题其实和cache没什么关系，要的还是空间换时间。那么比数组更快的查询方式是什么？Hash。比数组更快的删除，添加方式是什么？链表（这里用双向链表）。只要记录一下链表的尾巴，就能保证查找，删除，添加都是O(1)时间了。如下面的代码所示。

import java.util.Map;
import java.util.HashMap;


public class LRUCache {    
	Map<Integer,ListNode> cacheMap;
	ListNode head;
	ListNode tail;
	public int cap;
	public int last;
    
	public LRUCache(int capacity) {
		cacheMap=new HashMap<Integer,ListNode>();
		cap=capacity;
		head=null;
		tail=null;
        last=0;
    }
    
    public int get(int key) {
    	if(!cacheMap.containsKey(key))
    		return -1;
    	ListNode p=cacheMap.get(key);
    	if(p.prev!=null)
    	{
    		if(tail==p)
    			tail=p.prev;
    		p.prev.next=p.next;
    	}
    	else
			head=p.next;
    	if(p.next!=null)
    		p.next.prev=p.prev;
    	if(head!=null)
    		head.prev=p;
    	p.next=head;
    	p.prev=null;
    	head=p;
    	return p.value;
    }
    
    public void set(int key, int value) {
    	ListNode p;
    	if(cacheMap.containsKey(key))
    	{
    		p=cacheMap.get(key);
    		p.value=value;
    		if(p==head)
    			return;
    		else if(p==tail)
    		{
    			tail=p.prev;
    			if(tail!=null)
    				tail.next=null;
    		}
    		else
    		{
    			if(p.prev!=null)
    				p.prev.next=p.next;
    			if(p.next!=null)
    				p.next.prev=p.prev;
    			p.next=null;
    			p.prev=null;
    		}
    		cacheMap.remove(key);
    	}
    	else
    	{
    		p=new ListNode(key,value);
    		if(tail==null)
    			tail=p;
    		if(last<cap)
    			last++;
    		else
    		{
    			cacheMap.remove(tail.key);
    			tail=tail.prev;
    			if(tail!=null)
    				tail.next=null;
    		}
    	}
    	if(head!=null)
    		head.prev=p;
    	p.next=head;
    	p.prev=null;
    	head=p;
    	cacheMap.put(key, p);
    }
}

class ListNode {
    int key;
    int value;
    ListNode prev;
    ListNode next;
    ListNode(int _key, int _value) {
        key = _key;
        value = _value;
        prev = null;
        next = null;
    }
}