缓存算法及其代码实现

FIFO

FIFO（first in first out，先进先出）
当缓存满了之后，我们会将最找进入缓存的数据淘汰
要实现这个功能，我们只需要一个hash加链表就可以实现

public class FIFOCache {
    private int capacity;
    //使用hash表了，快速寻找这个key是否在缓存中
    private final Map<Integer, Integer> map = new HashMap<>();
    //使用队列实现先进先出的效果
    private final LinkedList<Integer> queue = new LinkedList<>();

    public FIFOCache(int capacity) {
        this.capacity = capacity;
    }

    public int get(int key) {
        if (map.containsKey(key)) {
            return map.get(key);
        }
        return -1;
    }

    public void put(int key, int value) {
        map.put(key, value);
        queue.addFirst(key);
        if (map.size() > capacity) {
            int last = queue.removeLast();
            map.remove(last);
        }
    }
}

LRU

LRU（Least recently used，最近最少使用）
当我们的缓存满了以后，将最久没有使用的过的数据淘汰
要实现这个功能，我们首先就要去维护这样一个队列，队列的头是刚刚加入或修改过的key，而尾部是最久没有使用的key。我们需要在修改key的同时，将这个key放到队伍的头部，并将原先位置的key删除
显然这个队列需要进行大量的数据的删除，添加，因此我们需要采用一个双向的链表
同时，我们还可以将双向链表的结点作为一个hash表的value，这样，我们我们就可以实现o（1）时间复杂度的查找。

class LRUCache {

    class Node {
        private int key;
        private int value;
        private Node prev;
        private NOde next;

        public Node() {
        }

        public Node(int key, int value) {
            this.key = key;
            this.value = value;
        }
    }

    private final int capacity;
    //哨兵结点
    private final Node dummy = new Node(-1, -1);
    private final HashMap<Integer, Node> map = new HashMap<>();


    public LRUCache(int capacity) {
        this.capacity = capacity;
        dummy.prev = dummy;
        dummy.next = dummy;
    }

    public int get(int key) {
        Node node = getNode(key);
        return node == null ? -1 : node.value;
    }

    public void put(int key, int value) {
        Node node = getNode(key);
        if (node != null) {
            node.value = value;
            return;
        }
        Node newNode = new Node(key, value);
        addFirst(newNode);
        map.put(key, newNode);
        if (map.size() > capacity) {
            Node last = dummy.prev;
            map.remove(last.key);
            remove(last);
        }
        return;
    }


    private Node getNode(int key) {
        if (!map.containsKey(key)) {
            return null;
        }
        Node node = map.get(key);
        remove(node);
        addFirst(node);
        return node;
    }


    private void remove(Node node) {
        node.prev.next = node.next;
        node.next.prev = node.prev;
    }

    private void addFirst(Node node) {
        node.prev = dummy;
        node.next = dummy.next;
        node.next.prev = node;
        dummy.next = node;
    }
}

LFU

LFU(Least Frequently Used,最近最少使用算法)
如果一个数据在一段时间内被访问的频率最小，我们就会将其淘汰。
要实现这个功能，我们同样也要使用一个双向链表。显然，在这里我们还需要在节点上添加一个访问次数的属性。
之后我们还需要根据访问次数，将数据再分成几个链表。这样我们只需要在访问次数最小的链表的寻找要淘汰的数据就可以了。因此我们还需要维护一个全局的最小访问次数。

class LFUCache {
    class Node {
        private int key;
        private int value;
        private int frequency;
        private Node prev;
        private Node next;

        public Node() {
        }

        public Node(int key, int value, int frequency) {
            this.key = key;
            this.value = value;
            this.frequency = frequency;
        }

        public Node(int key, int value) {
            this.key = key;
            this.value = value;
        }

        public int getFrequency() {
            return frequency;
        }

        public void setFrequency(int frequency) {
            this.frequency = frequency;
        }
    }

    private final int capacity;
    //最小访问次数
    private int minfrequency;
    //key和节点的hash表
    private final Map<Integer, Node> map = new HashMap<>();
    //访问次数和哨兵节点的hash表
    private final Map<Integer, Node> frequencyMap = new HashMap<>();


    public LFUCache(int capacity) {
        this.capacity = capacity;
    }

    public int get(int key) {
        Node node = getNode(key);
        return node == null ? -1 : node.value;
    }

    public void put(int key, int value) {
        Node node = getNode(key);
        if (node != null) {
            node.value = value;
            return;
        }
        if (capacity == map.size()) {
            //淘汰访问次数最少，并且时最近使用过的
            Node dummy = frequencyMap.get(minfrequency);
            Node last = dummy.prev;
            map.remove(last.key);
            remove(last);
        }
        node = new Node(key, value);
        node.setFrequency(1);
        map.put(key, node);
        //将节点添加到访问次数的hash表
        addFirst(node, 1);
        minfrequency = 1;
    }

    private Node getNode(int key) {
        if (!map.containsKey(key)) {
            return null;
        }
        Node node = map.get(key);
        remove(node);
        Node dummy = frequencyMap.get(node.getFrequency());
        //判断链表是否为空
        if (dummy.prev == dummy) {
            //判断最小访问次数是否要更新
            if (minfrequency == node.getFrequency()) {
                minfrequency++;
            }
        }
        node.setFrequency(node.frequency + 1);
        addFirst(node, node.getFrequency());
        return node;
    }

    //创建一个新的哨兵节点
    private Node addList() {
        Node dummy = new Node(-1, -1);
        dummy.next = dummy;
        dummy.prev = dummy;
        return dummy;
    }


    private void remove(Node node) {
        node.prev.next = node.next;
        node.next.prev = node.prev;
    }

    private void addFirst(Node node, int frequency) {
        //如果存在这个key，就返回对应的值，不存在就执行内部的逻辑
        Node dummy = frequencyMap.computeIfAbsent(frequency, f -> addList());
        node.prev = dummy;
        node.next = dummy.next;
        dummy.next = node;
        node.next.prev = node;
    }

}