左神算法笔记（二十）——LRU缓存算法实现

LRU

思路

准备两张表，一个哈希表，一个双向链表。假设A，3存入表中，则map中key还是原始的key，key=A，value加工一下，包括A和3.
对于双向链表从尾部加，从头部出。如果需要将某个元素从拿出，则此时将需要拿出的元素拿出，放到链表的最后，此时，该元素优先级最高。
如果缓存大小超过了k，此时将双向链表的头结点拿出，取出其中的key，使得原来map中删除该元素，将新的元素放入map中，同时将元素放到双向链表的末尾。

由于node给出的是一个泛型的node参数，所以代码中采用了两个map，如果想用一个map就实现整个代码，就需要将node泛型修改，改为Node.

代码

public static class NodeDOubleLinkedList<V>{
	private Node<V> head;
	private Node<V> tail;
	//新建双端链表
	public NodeDoubleLinkedList(){
		this.head = null;
		this.tail = null;
	}
	//增加节点
	public void addNode(Node<V> newNode){
		if(newNode == null){
			return;
		}
		if(this.head == null){
			this.head = newNode;
			this.tail = newNode;
		}else{
			this.tail.next = newNode;
			newNode.last = this.tail;
			this.tail = newNode;
		}
	}
	//将节点移到结尾的位置
	public void moveNodeToTail(Node<V> node){
		if(this.tail == node){
			return ;
		}
		if(this.head == node){
			this.head = node.next;
			this.head.last = null;
		}else{
			node.last.next = node.next;
			node.next.last = node.last;
		}
		node.last = this.tail;
		node.next = null;
		this.tail.next = node;
		this.tail = node;
	}
	//移除头节点
	public Node<V> removeHead(){
		if(this.head == null){
			return null;
		}
		Node<V> res = this.head;
		//如果整个链表中只含有一个元素，移除后头和尾都要指向空
		if(this.head == this.tail){
			this.head = null;
			this.tail = null;
		}else{
			this.head = res.next;
			res.next = null;
			this.head.last = null;
		}
		return res;
	}
}
//node存入map中，存入的是内存地址，而不会存入具体的数值，即使node中有很多的文本，也不会有很大影响
public static class MyCache<K,V> {
	private HashMap<K,Node<V>> keyNodeMap;
	private HashMap<Node<V>,K> nodeKeyMap;
	private NodeDoubleLinkedList<V> nodeList;
	private int capacity;

	public MyCache(int capacity){
		if(capacity <1){
			throw new RuntimeException("should be more than 0"):
		}
		this.keyNodeMap = new HashMap<K，Node<V>>();
		this.nodeKeyMap = new HashMap<Node<V>,K>();
		this.nodeList = new NodeDoubleLinkedList<V>();
		this.capacity = capacity;
	}

	public V get(K key){
		if(this.keyNodeMap.containsKey(key)){
			Node<V> res = this.keyNode<ap.get(key);
			this.nodeList.moveNodeToTail(res);
			return res.value;
		}
		return null;
	}

	public void set(K key,V value){
		if(this.keyNodeMap.containsKey(key)){
			Node<V> node = this.keyNodeMap.get(key);
			node.value = value ;
			this.nodeList.moveNodeToTail(node);
		}else{
			Node<V> newNode = new Node<V>(value);
			this.keyNodeMap.put(key,newNode);
			this.nodeKeyMap.put(newNode,key);
			this.nodeList.addNode(newNode);
			if(this.keyNodeMap.size() == this.capacity +1){
				this.removeMostUnusedCache();
			}
		}
	}

	private void removeMostUnusedCache(){
		Node<V> removeNode = this.nodeList.removeHead();
		K removeKey = this.nodeKeyMap.get(removeNode);
		this.nodeKeyMap.remove(removeNode);
		this.keyNodeMap.remove(removeKey);
	}
}

LRU设计的思路并不难，主要考察边界条件的思考和不同操作之间的组合，做好这种题目的唯一方法就是多练codeing能力。