LRU和LFU算法的实现

LRU 是一种内存管理算法，也就是最近最少使用，长期不被使用的数据，在未来被用到的几率也不大，因此，当数据所占内存达到一定阈值时，要移除最近最少被使用的数据。可是怎么知道哈希表中哪些key-value最近被访问过，哪些没被访问过，总不能给每一个 Value 加上时间戳，然后遍历整个哈希表。这就涉及到LRU算法的精妙所在，在LRU算法中，使用了一种有趣的数据结构，这汇总数据结构叫做哈希链表。

我们都知道，哈希表是由若干个key-value所组成。在逻辑上，这些key-value是无所谓排列顺序的，谁先谁后都一样

在哈希链表当中，这些key-value不再是彼此无关的存在，而是被一个链条串了起来。每一个key-value都具有它的前驱key-value，后继key-value，就像双向链表中的节点一样

这样一来，原本无序的哈希表拥有了固定的排列顺序

让我们以用户信息的需求为例，来演示一下LRU算法的基本思路：
1.假设我们使用哈希链表来缓存用户信息，目前缓存了4个用户，这4个用户是按照时间顺序依次从链表右端插入的。

2.此时，业务方访问用户5，由于哈希链表中没有用户5的数据，我们从数据库中读取出来，插入到缓存当中。这时候，链表中最右端是最新访问到的用户5，最左端是最近最少访问的用户1。

3.接下来，业务方访问用户2，哈希链表中存在用户2的数据，我们怎么做呢？我们把用户2从它的前驱节点和后继节点之间移除，重新插入到链表最右端。这时候，链表中最右端变成了最新访问到的用户2，最左端仍然是最近最少访问的用户1。

4.接下来，业务方请求修改用户4的信息。同样道理，我们把用户4从原来的位置移动到链表最右侧，并把用户信息的值更新。这时候，链表中最右端是最新访问到的用户4，最左端仍然是最近最少访问的用户1。

5.后来业务方换口味了，访问用户6，用户6在缓存里没有，需要插入到哈希链表。假设这时候缓存容量已经达到上限，必须先删除最近最少访问的数据，那么位于哈希链表最左端的用户1就会被删除掉，然后再把用户6插入到最右端。

class Node {
    public Node pre;
    public Node next;
    public String key;
    public String value;
    Node(String key, String value){
        this.key = key;
        this.value = value;
    }
}
public class LRUCache {
    private Node head; // 头结点
    private Node end; // 尾节点
    private int limit; // 缓存存储上限

    private HashMap<String, Node> hashMap;
    public LRUCache(int limit){   // 初始化存储上限
        this.limit = limit;
        hashMap = new HashMap<String, Node>();
    }
    public String get(String key){
        Node node = hashMap.get(key);
        if (node==null){
            return null;
        }
        refreshNode(node); // 刷新被访问的节点位置，如果访问的是尾节点，无需移动节点
        return node.value;
    }
    public void put(String key, String value){
        Node node = hashMap.get(key);
        if (node==null){
            if (hashMap.size() >= limit){ //插入节点不存在，大于存储上限，移除头节点
                String oldKey = removeNode(head);
                hashMap.remove(oldKey);
            }
            node = new Node(key, value);
            addNode(node);
            hashMap.put(key, node);
        } else {
            node.value = value;
            refreshNode(node);
        }
    }
    public void remove(String key){
        Node node = hashMap.get(key);
        removeNode(node);
        hashMap.remove(key);
    }
    private void refreshNode(Node node){
        if (node==end){
            return;
        }
        removeNode(node);
        addNode(node);
    }
    private String removeNode(Node node){
        if (node==end){
            end = end.pre;
        } else if (node==head){
            head = head.next;
        } else {
            node.pre.next = node.next;
            node.next.pre = node.pre;
        }
        return node.key;
    }
    private void addNode(Node node){
        if (end!=null){     // 如果end不为空，新节点插入尾节点位置
            end.next = node;
            node.pre = end;
            node.next = null;
        }
        end = node; 
        if (head == null){
            head = node;
        }
    }

}

 public static void main(String[] args) {
        LRUCache lruCache = new LRUCache(5);
        lruCache.put("001","用户1信息");
        lruCache.put("002","用户2信息");
        lruCache.put("003","用户3信息");
        lruCache.put("004","用户4信息");
        lruCache.put("005","用户5信息");
        lruCache.get("002");
        lruCache.put("004","用户4信息");
        lruCache.put("006","用户6信息");
        System.out.println(lruCache.get("001"));
        System.out.println(lruCache.get("006"));
    }

转载自：csdn 程序员小灰

---

最近期间内经常使用是一种用计算机管理内存的算法。关于这种方法的标准的特征是，系统追踪在内存中，block被引用的次数。当内存满了，需要等多的空间时，系统会去除掉最少使用次数的项目。

使用LFU算法，最简单的方法是，为每个导入内存中的block安排计数器。每一次block被引用一次，计数器就会自动加一。当内存达到容量并且有新的block被插入时，系统将会查找使用次数最少的项目，将它从内存中除去。

转载： https://www.cnblogs.com/lihao007/p/7501662.html

 

//来自：https://leetcode-cn.com/problems/lfu-cache/solution/java-shuang-ha-xi-biao-shuang-xiang-lian-biao-by-m/
class ListNode{
    int key, val, cnt;
    ListNode left, right;
    public ListNode(){
        this.val = -1;
    }
    public ListNode(int key, int val){
        this.key = key;
        this.val = val;
        cnt = 0;
    }
}

class LFUCache {
    private Map<Integer, ListNode> map; // 存储key对应的value所在的节点
    private Map<Integer, ListNode> tailMap; //存储每个区间的最左边
    private int capacity;
    private ListNode head; //链表最左边

    public LFUCache(int capacity){
        this.capacity = capacity;
        this.map = new HashMap<>();
        this.tailMap = new HashMap<>();
        head = new ListNode();
        head.left = new ListNode();
        head.left.right = head;
        tailMap.put(0, head.left);
    }

    public int get(int key){
        if (capacity<=0 || !map.containsKey(key)) return -1;
        ListNode cur = map.get(key);
        use(cur);
        return cur.val;
    }
    // 使用节点，移动该节点在链表的位置
    public void use(ListNode cur){
        cur.cnt++;
        if (cur.left!=null) cur.left.right = cur.right;
        if (cur.right!=null) cur.right.left = cur.left;
        if (!tailMap.containsKey(cur.cnt)){
            ListNode node = new ListNode();
            node.right = tailMap.get(cur.cnt-1);
            node.right.left = node;
            tailMap.put(cur.cnt,node);
        }
        ListNode tail = tailMap.get(cur.cnt);
        cur.left = tail;
        cur.right = tail.right;
        cur.right.left = cur;
        tail.right = cur;
    }
    public void put (int key, int val){
        if (capacity == 0) return;
        ListNode node = map.getOrDefault(key, null);
        if (node != null){
            node.val = val;
            use(node);
            return;
        }
        if (map.size() == capacity) removeFirst();
        node = new ListNode(key, val);
        ListNode tail = tailMap.get(node.cnt);
        node.left = tail;
        node.right = tail.right;
        node.right.left = node;
        tail.right = node;
        map.put(key, node);
    }
    public void removeFirst(){
        ListNode cur = head;
        while (cur.val == -1){
            cur = cur.left;
        }
        cur.left.right = cur.right;
        cur.right.left = cur.left;
        map.remove(cur.key);
    }
}

public class Test {
    public static void main(String[] args) {
        LFUCache cache = new LFUCache(2);
        cache.put(1, 1);
        cache.put(2, 2);
        System.out.println(cache.get(1));       // 返回 1
        cache.put(3, 3);    // 去除 key 2
        System.out.println(cache.get(2));       // 返回 -1 (未找到key 2)
        System.out.println(cache.get(3));       // 返回 3
        cache.put(4, 4);    // 去除 key 1
        System.out.println(cache.get(1));       // 返回 -1 (未找到 key 1)
        System.out.println(cache.get(3));       // 返回 3
        System.out.println(cache.get(4));       // 返回 4

    }
}