Leetcode: LRU Cache 解題報告

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 1:

利用了JAVA 自帶的LinkedHashMap ，其實這相當於作弊了，面試官不太可能會過。但是我們仍然可以練習一下如何使用LinkedHashMap.

同學們可以參考一下它的官方文檔：

https://docs.oracle.com/javase/7/docs/api/java/util/LinkedHashMap.html#LinkedHashMap(int)

1. OverRide removeEldestEntry 函數，在Size達到最大值最，刪除最長時間未訪問的節點。

protected boolean removeEldestEntry(Map.Entry eldest) {

       return size() > capacity;

}

2. 在Get/ Set的時候，都更新節點，即刪除之，再添加之，這樣它會作為最新的節點加到雙向鏈表中。

package Algorithms.hash;

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

public class LRUCache2 {
    public static void main(String[] strs) {
        LRUCache2 lrc2 = new LRUCache2(2);
        lrc2.set(1,3);
        lrc2.set(2,2);
        lrc2.set(1,4);
        lrc2.set(4,2);
        
        System.out.println(lrc2.get(1));
    }
    
    LinkedHashMap<Integer, Integer> map;
    int capacity;
    
    public LRUCache2(final int capacity) {
        // create a map.
        map = new LinkedHashMap<Integer, Integer>(capacity) {
            /**
             * 
             */
            private static final long serialVersionUID = 1L;

            protected boolean removeEldestEntry(Map.Entry eldest) {
                return size() > capacity;
            }
        };
        this.capacity = capacity;
    }
    
    public int get(int key) {
        Integer ret = map.get(key);
        if (ret == null) {
            return -1;
        } else {
            map.remove(key);
            map.put(key, ret);
        }
        
        return ret;
    }
    
    public void set(int key, int value) {
        map.remove(key);
        map.put(key, value);
    }
}

SOLUTION 2:

使用 HashMap+ 雙向鏈表實現：

1. 如果需要移除老的節點，我們從頭節點移除。

2. 如果某個節點被訪問（SET/GET），將其移除並掛在雙向鏈表的結尾。

3. 鏈表滿了后，我們刪除頭節點。

4. 最近訪問的節點在鏈尾。最久被訪問的節點在鏈頭。

package Algorithms.hash;

import java.util.HashMap;

public class LRUCache {
    private class DLink {
        DLink pre;
        DLink next;
        int val;
        int key;
        DLink(int key, int val) {
            this.val = val;
            this.key = key;
            pre = null;
            next = null;
        }
    }
    
    HashMap<Integer, DLink> map;
    
    DLink head;
    DLink tail;
    
    int capacity;

    public void removeFist() {
        removeNode(head.next);
    }
    
    public void removeNode(DLink node) {
        node.pre.next = node.next;
        node.next.pre = node.pre;
    }
    
    // add a node to the tail.
    public void addToTail(DLink node) {
        tail.pre.next = node;
        
        node.pre = tail.pre;
        node.next = tail;
        
        tail.pre = node;
    }
    
    public LRUCache(int capacity) {
        map = new HashMap<Integer, DLink>();
        
        // two dummy nodes. In that case, we can deal with them more conviencely.
        head = new DLink(-1, -1);
        tail = new DLink(-1, -1);
        head.next = tail;
        tail.pre = head;
        
        this.capacity = capacity;
    }
    
    public int get(int key) {
        if (map.get(key) == null) {
            return -1;
        }
        
        // update the node.
        DLink node = map.get(key);
        removeNode(node);
        addToTail(node);
        
        return node.val;
    }
    
    public void set(int key, int value) {
        DLink node = map.get(key);
        if (node == null) {
            // create a node and add the key-node pair into the map.
            node = new DLink(key, value);
            map.put(key, node);
        } else {
            // update the value of the node.
            node.val = value;
            removeNode(node);
        }
        
        addToTail(node);
        
        // if the LRU is full, just remove a node.
        if (map.size() > capacity) {
            map.remove(head.next.key);
            removeFist();
        }
    }
}

 

請移步至主頁君的GITHUB代碼：

https://github.com/yuzhangcmu/LeetCode_algorithm/blob/master/hash/LRUCache.java

https://github.com/yuzhangcmu/LeetCode_algorithm/blob/master/hash/LRUCache2.java