【数据结构】LRU缓存机制

问题描述

运用你所掌握的数据结构，设计和实现一个  LRU (最近最少使用) 缓存机制。它应该支持以下操作： 获取数据 get 和 写入数据 put 。

获取数据 get(key) - 如果密钥 (key) 存在于缓存中，则获取密钥的值（总是正数），否则返回 -1。
写入数据 put(key, value) - 如果密钥不存在，则写入其数据值。当缓存容量达到上限时，它应该在写入新数据之前删除最近最少使用的数据值，从而为新的数据值留出空间。

进阶:

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

示例:

LRUCache cache = new LRUCache( 2 /* 缓存容量 */ );

cache.put(1, 1);
cache.put(2, 2);
cache.get(1);       // 返回  1
cache.put(3, 3);    // 该操作会使得密钥 2 作废
cache.get(2);       // 返回 -1 (未找到)
cache.put(4, 4);    // 该操作会使得密钥 1 作废
cache.get(1);       // 返回 -1 (未找到)
cache.get(3);       // 返回  3
cache.get(4);       // 返回  4

解法1：

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


class LRUCache {
    
    Map<Integer, Node> cache = new HashMap<Integer, Node>();
    private Node head;
    private Node tail;
    private int capacity;

    public LRUCache(int capacity) {
        this.capacity = capacity;
    }
    
    public int get(int key) {
    	Node node = cache.get(key);
    	if(null == node){
    		return -1;
    	}

    	remove(node);
    	addLast(node);
    	return node.value;
    }
    
    public void put(int key, int value) {
    	if(capacity <= 0){
    		return;
    	}
        if(cache.size() == capacity && !cache.containsKey(key)){
        	cache.remove(head.key);
        	remove(head);
        }

        Node node = cache.get(key);
        if(null != node){
        	node.setValue(value);
        	remove(node);
        }else{
        	node = new Node(key, value);
        }
        cache.put(key, node);

        addLast(node);
    }

    private void addLast(Node node){
    	if(null == head){
        	head = node;
        }

        if(null == tail){
        	tail = node;
        }else{
	        tail.next = node;
	        node.pre = tail;
	        tail = node;
	    }
    }

    private void remove(Node node){
    	if(head == node){
    		head = node.next;
    		if(null != head){
    			head.pre = null;
    		}
    	}else{
    		node.pre.next = node.next;
    	}

    	if(tail == node){
    		tail = node.pre;
    		if(null != tail){
    			tail.next = null;
    		}
    	}else{
    		node.next.pre = node.pre;
    	}
    }
    
    private static class Node{
    	private int key;
    	private int value;
    	private Node pre;
    	private Node next;

    	public Node(int key, int value){
    		this.key = key;
    		this.value = value;
    	}

    	public void setKey(int key){
    		this.key = key;
    	}

    	public void setValue(int value){
    		this.value = value;
    	}

    	public int getKey(){
    		return this.key;
    	}

    	public int getValue(){
    		return this.value;
    	}
    }
}

 

解法2：

import java.util.Map;
import java.util.LinkedHashMap;


class LRUCache {
    
    Map<Integer, Integer> cache = new LinkedHashMap<Integer, Integer>();
    private int capacity;

    public LRUCache(int capacity) {
        this.capacity = capacity;
    }
    
    public int get(int key) {
    	if(cache.containsKey(key)){
    		int value = cache.get(key);
    		cache.remove(key);
    		cache.put(key, value);
    		return value;
    	}else{
    		return -1;
    	}
    }
    
    public void put(int key, int value) {
    	if(cache.containsKey(key)){
    		cache.remove(key);
    	}

    	if(cache.size() == capacity){
    		cache.remove(cache.keySet().iterator().next());
    	}

    	cache.put(key, value);
    }
}