My code:
public class LRUCache {
private class Node {
Node next;
Node prev;
int key;
int val;
private Node(int key, int val) {
this.key = key;
this.val = val;
}
}
private final int capacity;
private int counter;
private HashMap<Integer, Node> LRU;
private Node head;
private Node tail;
public LRUCache(int capacity) {
this.capacity = capacity;
counter = 0;
LRU = new HashMap<Integer, Node>();
}
public int get(int key) {
if (LRU.containsKey(key)) {
Node temp = LRU.get(key);
int ret = temp.val;
remove(temp);
addToFirst(temp);
return ret;
}
else
return -1;
}
public void set(int key, int value) {
if (LRU.containsKey(key)) {
Node temp = LRU.get(key);
temp.val = value;
remove(temp);
addToFirst(temp);
}
else {
counter++;
Node temp = new Node(key, value);
addToFirst(temp);
LRU.put(key, temp);
if (counter > capacity) {
LRU.remove(tail.key);
remove(tail);
counter = capacity;
}
}
}
private void remove(Node temp) {
if (temp == null)
return;
if (temp.prev == null) { // head node
if (temp.next == null) {
head = null;
tail = null;
}
else {
head = temp.next;
temp.next.prev = null;
}
}
else if (temp.next == null) { // tail nod
if (temp.prev == null) {
head = null;
tail = null;
}
else {
tail = temp.prev;
temp.prev.next = null;
}
}
else {
temp.prev.next = temp.next;
temp.next.prev = temp.prev;
}
}
private void addToFirst(Node p) {
if (p == null)
return;
if (head == null) {
head = p;
tail = p;
}
else {
head.prev = p;
p.next = head;
p.prev = null;
head = p;
}
}
}
這道題目還是挺有意思的。一開始寫出來超出時間了，沒有怎么仔細分析。
兩個操作，
get,
set,最理想情況下都必須 O(1)
因為當超過限度后，需要把最不常用的刪除掉，所以，為了使時間復雜度最低，必須得用鏈表。
然后，get操作，根據key返回value，復雜度要O(1)，所以要用HashMap
那么key value 各自是什么呢？
key -> Integer, value -> Node(int key, int value)
然后我們get操作時，通過HashMap的key來找到Node再返回他的value。
然后再根據這個Node，將其從當前位置刪除，移動到首結點位置。
我們在進行set操作時，如果HashMap已經存在了這個key，那么直接修改原值，然后移動到鏈表頭部。
如果沒有，則新建結點，插到頭部。如果超過了限度，那么就把尾巴刪除掉。記得先從哈希表中刪除該鍵值對，再刪除該結點（尾結點）。所以，Node里面必須要有key這個成員。然后再通過key去哈希表里面刪除對應的鍵值對。
這道題目就是得思考，get, set操作需要那幾個原子級別的操作。
然后發現需要HashMap, 和鏈表。然后需要有添加頭結點，刪除特定結點的操作。
參考網頁：
http://www.programcreek.com/2013/03/leetcode-lru-cache-java/
Anyway, Good luck, Richardo!
My code:
public class LRUCache {
private class ListNode {
ListNode pre;
ListNode next;
int key;
int val;
ListNode(int key, int val) {
this.key = key;
this.val = val;
}
}
HashMap<Integer, ListNode> map = new HashMap<Integer, ListNode>();
int capacity = 0;
ListNode dummy = new ListNode(-1, -1);
ListNode tail = dummy;
int size = 0;
public LRUCache(int capacity) {
this.capacity = capacity;
}
public int get(int key) {
if (!map.containsKey(key)) {
return -1;
}
ListNode node = map.get(key);
remove(node);
addFirst(node);
return node.val;
}
public void set(int key, int value) {
if (map.containsKey(key)) {
ListNode node = map.get(key);
node.val = value;
remove(node);
// insert it at the head of list
addFirst(node);
}
else {
ListNode node = new ListNode(key, value);
map.put(key, node);
addFirst(node);
size++;
if (size > capacity) {
map.remove(tail.key);
remove(tail);
size--;
}
}
}
private void addFirst(ListNode node) {
ListNode head = dummy.next;
dummy.next = node;
node.pre = dummy;
node.next = head;
if (head != null) {
head.pre = node;
}
else {
tail = node;
}
}
private void remove(ListNode node) {
if (node.next == null) {
tail = node.pre;
node.pre.next = node.next;
}
else {
node.pre.next = node.next;
node.next.pre = node.pre;
}
}
}
這道題目寫了挺久，挺慚愧的。昨天還和人說這是簡單題。。。
主要就是，我想到了用雙向鏈表，但覺得沒必要那么認真。
后來越改錯誤越多。
于是，看了下答案。再重寫了下。
剛剛學長和我說，Google今年三月份面過了，被凍了一年，不能再面了。。。
這是再開玩笑嘛？？
Google, 就要這樣錯過嗎？
是不是很滑稽啊？？？
Anyway, Good luck, Richardo! -- 09/15/2016
