今日頭條高頻面試題LRU

轉自知乎:zhuanlan.zhihu.com/p/34133067

題目

運用你所掌握的數據結構，設計和實現一個 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
複製代碼

題解

這道題在今日頭條、快手或者硅谷的公司中是比較常見的，代碼要寫的還蠻多的，難度也是hard級別。

最重要的是LRU 這個策略怎麼去實現, 很容易想到用一個鏈表去實現最近使用的放在鏈表的最前面。 好比get一個元素,至關於被使用過了，這個時候它須要放到最前面，再返回值, set同理。 那如何把一個鏈表的中間元素，快速的放到鏈表的開頭呢？ 很天然的咱們想到了雙端鏈表。

基於 HashMap 和 雙向鏈表實現 LRU 的

總體的設計思路是，可使用 HashMap 存儲 key，這樣能夠作到 save 和 get key的時間都是 O(1)，而 HashMap 的 Value 指向雙向鏈表實現的 LRU 的 Node 節點，如圖所示。

LRU 存儲是基於雙向鏈表實現的，下面的圖演示了它的原理。其中 head 表明雙向鏈表的表頭，tail 表明尾部。首先預先設置 LRU 的容量，若是存儲滿了，能夠經過 O(1) 的時間淘汰掉雙向鏈表的尾部，每次新增和訪問數據，均可以經過 O(1)的效率把新的節點增長到對頭，或者把已經存在的節點移動到隊頭。

下面展現了，預設大小是 3 的，LRU存儲的在存儲和訪問過程當中的變化。爲了簡化圖複雜度，圖中沒有展現 HashMap部分的變化，僅僅演示了上圖 LRU 雙向鏈表的變化。咱們對這個LRU緩存的操做序列以下：

save("key1", 7)
save("key2", 0)
save("key3", 1)
save("key4", 2)
get("key2")
save("key5", 3)
get("key2")
save("key6", 4)
複製代碼

相應的 LRU 雙向鏈表部分變化以下：

總結一下核心操做的步驟:

save(key, value)，首先在 HashMap 找到 Key 對應的節點，若是節點存在，更新節點的值，並把這個節點移動隊頭。若是不存在，須要構造新的節點，而且嘗試把節點塞到隊頭，若是LRU空間不足，則經過 tail 淘汰掉隊尾的節點，同時在 HashMap 中移除 Key。

get(key)，經過 HashMap 找到 LRU 鏈表節點，由於根據LRU 原理，這個節點是最新訪問的，因此要把節點插入到隊頭，而後返回緩存的值。

private static class DLinkedNode {
        int key;
        int value;
        DLinkedNode pre;
        DLinkedNode post;
    }

    /**
     * 老是在頭節點中插入新節點.
     */
    private void addNode(DLinkedNode node) {

        node.pre = head;
        node.post = head.post;

        head.post.pre = node;
        head.post = node;
    }

    /**
     * 摘除一個節點.
     */
    private void removeNode(DLinkedNode node) {
        DLinkedNode pre = node.pre;
        DLinkedNode post = node.post;

        pre.post = post;
        post.pre = pre;
    }

    /**
     * 摘除一個節點,而且將它移動到開頭
     */
    private void moveToHead(DLinkedNode node) {
        this.removeNode(node);
        this.addNode(node);
    }

    /**
     * 彈出最尾巴節點
     */
    private DLinkedNode popTail() {
        DLinkedNode res = tail.pre;
        this.removeNode(res);
        return res;
    }

    private HashMap<Integer, DLinkedNode>
            cache = new HashMap<Integer, DLinkedNode>();
    private int count;
    private int capacity;
    private DLinkedNode head, tail;

    public LRUCache(int capacity) {
        this.count = 0;
        this.capacity = capacity;

        head = new DLinkedNode();
        head.pre = null;

        tail = new DLinkedNode();
        tail.post = null;

        head.post = tail;
        tail.pre = head;
    }

    public int get(int key) {

        DLinkedNode node = cache.get(key);
        if (node == null) {
            return -1; // cache裏面沒有
        }

        // cache 命中,挪到開頭
        this.moveToHead(node);

        return node.value;
    }


    public void put(int key, int value) {
        DLinkedNode node = cache.get(key);

        if (node == null) {

            DLinkedNode newNode = new DLinkedNode();
            newNode.key = key;
            newNode.value = value;

            this.cache.put(key, newNode);
            this.addNode(newNode);

            ++count;

            if (count > capacity) {
                // 最後一個節點彈出
                DLinkedNode tail = this.popTail();
                this.cache.remove(tail.key);
                count--;
            }
        } else {
            // cache命中,更新cache.
            node.value = value;
            this.moveToHead(node);
        }
    }
    
複製代碼

熱門閱讀

• 技術文章彙總
• 【Leetcode】101. 對稱二叉樹
• 【Leetcode】100. 相同的樹
• 【Leetcode】98. 驗證二叉搜索樹