[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.

 

Solution:

数据结构

LRU的典型实现是hash map + doubly linked list， 双向链表用于存储数据结点，并且它是按照结点最近被使用的时间来存储的。 如果一个结点被访问了， 我们有理由相信它在接下来的一段时间被访问的概率要大于其它结点。于是， 我们把它放到双向链表的头部。当我们往双向链表里插入一个结点， 我们也有可能很快就会使用到它，同样把它插入到头部。 我们使用这种方式不断地调整着双向链表，链表尾部的结点自然也就是最近一段时间， 最久没有使用到的结点。那么，当我们的Cache满了， 需要替换掉的就是双向链表中最后的那个结点(不是尾结点，头尾结点不存储实际内容)。

如下是双向链表示意图，注意头尾结点不存储实际内容：

头 --> 结 --> 结 --> 结 --> 尾
结     点     点     点     结
点 <-- 1  <-- 2 <-- 3  <-- 点

假如上图Cache已满了，我们要替换的就是结点3。

哈希表的作用是什么呢？如果没有哈希表，我们要访问某个结点，就需要顺序地一个个找， 时间复杂度是O(n)。使用哈希表可以让我们在O(1)的时间找到想要访问的结点， 或者返回未找到。

http://huntfor.iteye.com/blog/2075379 

 

package POJ;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;

public class LRUCache {
    private HashMap<Integer, Node> hm=new HashMap<Integer, Node>();
    int capacity=0;
    Node head=new Node();
    Node tail=new Node();

    public LRUCache(int capacity) {
        this.capacity=capacity;
        head.next=tail;
        tail.pre=head;
    }
    
    public int get(int key) {
        if(hm.containsKey(key)){
            Node e=hm.get(key);
            delete(e);
            insert(head,e);
            return e.value;
        }
        return -1;
    }
    
    public void set(int key, int value) {
        Node e = new Node(key,value);
        if(hm.containsKey(key)){
            Node exist=hm.get(key);
            delete(exist);
            hm.remove(key);
            insert(head,e);
            hm.put(key, e);
        }else{
            if(hm.size()<capacity){
                hm.put(key, e);
                insert(head,e);
            }else if(hm.size()==capacity){
                hm.remove(tail.pre.key);
                delete(tail.pre);
                insert(head,e);
                hm.put(key, e);
            }
        }
    }

    private void insert(Node head, Node e) {
        // TODO Auto-generated method stub
        e.pre=head;
        e.next=head.next;
        head.next=e;
        e.next.pre=e;
    }

    private void delete(Node exist) {
        // TODO Auto-generated method stub
        Node pre= exist.pre;
        Node next=exist.next;
        pre.next=next;
        next.pre=pre;
    }
}
class Node{
    public int key;
    public int value;
    public Node pre;
    public Node next;
    public Node(){
        this.key=Integer.MIN_VALUE;
        this.value=Integer.MIN_VALUE;
        pre=null;
        next=null;
    }
    public Node(int key,int value){
        this.key=key;
        this.value=value;
        pre=null;
        next=null;
    }
}