【数据结构】设计LRU缓存

package collection;

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

class LRUCache {
	class SLDode {
		int key, value;
		SLDode prev, next;
		public SLDode() {
		}
		public SLDode(int key, int value) {
			this.key = key;
			this.value = value;
		}
	}

	private Map<Integer, SLDode> cache = new HashMap<Integer, SLDode>();
	private int size;
	private int capacity;
	private SLDode head, tail;

	public LRUCache(int capacity) {
		this.size = 0;
		this.capacity = capacity;
		head = new SLDode();
		tail = new SLDode();
		head.next = tail;
		tail.prev = head;
	}

	public int get(int key) {
		SLDode node = cache.get(key);
		if (node == null) {
			return -1;
		}
		moveHead(node);
		return node.value;
	}

	public void put(int key, int value) {
		SLDode node = cache.get(key);
		if (node == null) {
			SLDode newNode = new SLDode(key, value);
			cache.put(key, newNode);
			// 加至头部
			addHead(newNode);
			++size;
			if (size > capacity) {
				// 超出容量，删除尾节点
				SLDode tail = removeTail();
				cache.remove(tail.key);
				--size;
			}
		} else {
			//key 存在，移到头部
			node.value = value;
			moveHead(node);
		}
	}
	

	private void addHead(SLDode node) {
		node.prev = head;
		node.next = head.next;
		head.next.prev = node;
		head.next = node;
	}

	private void removeNode(SLDode node) {
		node.prev.next = node.next;
		node.next.prev = node.prev;
	}

	private void moveHead(SLDode node) {
		removeNode(node);
		addHead(node);
	}

	private SLDode removeTail() {
		SLDode res = tail.prev;
		removeNode(res);
		return res;
	}
}

public class Solution {
	public static void main(String args[]) {
		int[][] a = { 
				{ 1, 1, 1 }, 
				{ 1, 2, 2 }, 
				{ 2, 1},   
				{ 1, 3,3 }, 
				{ 2, 2 },
				{ 1, 4,4 }, 
				{ 2, 1 },
				{ 2, 2 },
				{ 2, 4 }
			};
		for (int i = 0; i < LRU(a, 2).length; i++) {
			System.out.print(LRU(a, 2)[i] + ",");
		}

	}

	public static int[] LRU(int[][] a, int size) {

		LRUCache cache = new LRUCache(size);  //cache缓存容量2
		ArrayList<Integer> getNode = new ArrayList<>();  
		for (int[] b : a) {
			int operation = b[0];//[0]代表某1/2操作
			if (operation == 1) {
				cache.put(b[1], b[2]);  //存入
			} else {
				getNode.add(cache.get(b[1]));  //取出
			}
		}
		int length = getNode.size();  
		int[] result = new int[length];
		for (int i = 0; i < length; i++) {
			result[i] = getNode.get(i);  //得操作结果
		}
		return result;

	}

}