操作系統-1-存儲管理之LFU頁面置換算法(leetcode460)

LFU緩存

題目：請你為 最不經常使用（LFU）緩存算法設計並實現數據結構。它應該支持以下操作：get 和 put。
　　　　get(key) - 如果鍵存在於緩存中，則獲取鍵的值（總是正數），否則返回 -1。
　　　　put(key, value) - 如果鍵不存在，請設置或插入值。當緩存達到其容量時，則應該在插入新項之前，使最不經常使用的項無效。

　　　　　　　　　　　 在此問題中，當存在平局（即兩個或更多個鍵具有相同使用頻率）時，應該去除 最近 最少使用的鍵。
　　　 「項的使用次數」就是自插入該項以來對其調用 get 和 put 函數的次數之和。使用次數會在對應項被移除后置為 0 。

示例：　　
　　　LFUCache cache = new LFUCache( 2 /* capacity (緩存容量) */ );

　　   cache.put(1, 1);
　　   cache.put(2, 2);
　　   cache.get(1);       // 返回 1
　　   cache.put(3, 3);    // 去除 key 2
　　   cache.get(2);       // 返回 -1 (未找到key 2)　　
　　   cache.get(3);       // 返回 3
　　   cache.put(4, 4);    // 去除 key 1
　　   cache.get(1);       // 返回 -1 (未找到 key 1)
　　   cache.get(3);       // 返回 3
　　   cache.get(4);       // 返回 4

代碼：

class LFUCache {

    public LFUCache(int capacity) {

    }
    
    public int get(int key) {

    }
    
    public void put(int key, int value) {

    }
}

/**
 * Your LFUCache object will be instantiated and called as such:
 * LFUCache obj = new LFUCache(capacity);
 * int param_1 = obj.get(key);
 * obj.put(key,value);
 */

LFU頁面置換算法(最不經常使用算法)

　　原理：

　　　　選擇到當前時間為止被訪問次數最少的頁面被置換；
　　　　每頁設置訪問計數器，每當頁面被訪問時，該頁面的訪問計數器加1；
　　　　發生缺頁中斷時，淘汰計數值最小的頁面，並將所有計數清零；

　　　　如圖：圖中的頁面為三頁，依次向存儲中加入432143543215這些數字。

　　　　　　　而存儲空間只能存儲三個頁面，所以會按照上述規則不斷淘汰已經存儲在頁面中的數字。

　　　　

解題思路(logN的思路)：

　　　 知道了LFU的置換規則后，由於此題需要存儲的是key和value,所以

　　　　　　首先，需要建一個類node，存放四樣東西，key,value,times(訪問計數器)，id(進入存儲空間的自然順序)

　　　　　　其次，選擇一種合適的數據結構來解決存儲優先級問題，此處我們采用內部是小頂堆的PriorityQueue優先級隊列用來

　　　　　　　　　實現times最小的元素在隊頭,如果times相等，則比較先后入隊的自然順序id。

　　　　　　　　　但是我們會在讓新元素入隊之前可能會刪除隊列中指定元素，當然可以去遍歷隊列，但是這樣太慢了

　　　　　　　　　我們可以再用一種HashMap的數據集合用來存儲節點，以便快速通過node的key來得到整個node。

　　　　　　最后，便是處理邏輯關系，寫題目要求的get,put方法了

解題代碼詳解(logN)：

public class node implements Comparable<node>{
    private int Key;//鍵
    private int Value;//值
    private int Times;//訪問計數器
    private int Id;//自然入隊順序標記，若訪問計數器值相同，則先淘汰id小的那個
    node() {}
    node(int key, int value, int id) {
        this.Key = key;
        this.Value = value;
        this.Id = id;
        this.Times = 1;
    }
    public int getKey() {
        return Key;
    }

    public void setKey(int Key) {
        this.Key = Key;
    }

    public int getValue() {
        return Value;
    }

    public void setValue(int Value) {
        this.Value = Value;
    }

    public int getTimes() {
        return Times;
    }

    public void setTimes(int Times) {
        this.Times = Times;
    }
    public int getId() {
        return Id;
    }

    public void setId(int id) {
        this.Id = id;
    }

    @Override
    public int compareTo(node o) {
        //實現times最小的元素在隊頭,如果times相等，則比較先后入隊順序
        int Timessub = Times - o.Times;
        return Timessub == 0 ? this.Id - o.Id: Timessub;
    }
}

class LFUCache {
    PriorityQueue<node> KeyValueTimes = new PriorityQueue();//用於實現優先級順序
    Map<Integer, node> nodeset;//用於O(1)取出某個具體的node
    public int Capacity = 0;//我的cache中最大容量
    public int nownum = 0;//cache的實時元素個數
    public int id = 0;//每個node的入隊自然順序標記

    public LFUCache(int capacity) {
        this.Capacity = capacity;//設置cache容量
        nodeset = new HashMap<Integer, node>(capacity);//用於O(1)取出某個具體的node，容量依然設置為capacity
    }
    
    public int get(int key) {
        if(this.Capacity == 0)//判斷容量是否為空，為空則直接返回-1
            return -1;
        node nownode = nodeset.get(key);//通過HashMap，快速通過key鍵快速得到node
        if (nownode == null) {//如果key這個鍵沒在隊列中，則返回-1
            return -1;
        }else{
            KeyValueTimes.remove(nownode);//移除隊列中當前的這個node
            nownode.setTimes(nownode.getTimes()+1);//更新當前這個node的訪問次數
            nownode.setId(id++);//更新自然入隊順序
            KeyValueTimes.offer(nownode);//再把它放回去
        }
        return nownode.getValue();
    }
    
    public void put(int key, int value) {
        if(this.Capacity == 0)//判斷容量是否為空,為空則不進行put
            return;
        node thisnode = new node(key,value,id++);
        node oldnode = nodeset.get(key);
        if(oldnode == null){//隊列里不存在這個key
            if(nownum < this.Capacity){//沒裝滿
                KeyValueTimes.offer(thisnode);//在隊列里添加新node
                nodeset.put(key,thisnode);//在HashMap里添加新node
                nownum++;//更新當前cache的元素個數
            }
            else{//裝滿了，需要LFU,最不經常使用被移除
                nodeset.remove(KeyValueTimes.poll().getKey());//移除隊列里的隊頭，移除HashMap對應的那個node
                KeyValueTimes.offer(thisnode);//在隊列里添加新node
                nodeset.put(key,thisnode);//在HashMap里添加新node
            }
        }
        else{//隊列里存在這個key
            thisnode.setTimes(oldnode.getTimes()+1);//將原來鍵為key的訪問次數復制給新的node
            KeyValueTimes.remove(oldnode);//移除隊列里鍵為key的node，移除HashMap對應的那個node
            nodeset.remove(oldnode.getKey());
            KeyValueTimes.offer(thisnode);//在隊列里添加新node,這里新的node的value值可能會不一樣，所以更新了value
            nodeset.put(key,thisnode);//在隊列里添加新node,這里新的node的value值可能會不一樣，所以更新了value
        }
    }
}