算法leetcode 彻底搞懂LRU和LFU缓存问题

简介

LRU (Least Recently Used) 缓存，即在缓存容量达到上限的条件下，删除最久未使用过的数据，腾出空间存储新的数据。

LFU (Least Frequently Used) 缓存，即在缓存容量达到上限的条件下，删除使用频率最少的数据，当使用频率相同时，删除最久未使用的数据。

这两种缓存算法在实践中用得非常普遍，例如MySQL的内存数据页淘汰算法，Redis的淘汰策略等。

例题

• 1. T146. LRU缓存机制 中等
• 2. T460. LFU缓存 困难

以上题目均来自leetcode.

详细

146. LRU缓存机制

题目描述

运用你所掌握的数据结构，设计和实现一个 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

分析

这道题有很多实现方式，我们直接看进阶要求，要求 put 和 get 操作要在 O(1) 时间复杂度下完成。

我们可以用一个双向链表存储数据，这样方便移除最久未使用的数据，同时，用一个字典存储 key 和链表中节点的映射关系，方便直接从 key 获取节点，从而进行删除节点等操作。

同时，每次put或者get数据，将数据移动到链表尾部。

代码

lass LRUCache {

    class Node {
        private int key;
        private int value;
        private Node next;
        private Node pre;

        public Node() {
        }

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

    }

    private int capacity;
    private int count;
    private Map<Integer, Node> map;
    private Node head;
    private Node tail;

    public LRUCache(int capacity) {
        this.capacity = capacity;
        count = 0;
        map = new HashMap<>();
        head = new Node();
        tail = new Node();
        head.next = tail;
        tail.pre = head;
    }
	
	// 移动节点到链表尾部
    private void moveToTail(Node node) {
        // 取出
        node.pre.next = node.next;
        node.next.pre = node.pre;
        // 插入尾部
        addNode(node);
    }
	
	// 在尾部添加一个节点
    private void addNode(Node node) {
        Node pre = tail.pre;
        node.pre = pre;
        pre.next = node;
        node.next = tail;
        tail.pre = node;
    }
	
	// 删除第一个节点
    private void deleteFirst() {
        Node node = head.next;
        node.pre.next = node.next;
        node.next.pre = node.pre;
        map.remove(node.key);
    }

    public int get(int key) {
        if (!map.containsKey(key)) {
            return -1;
        }
        Node node = map.get(key);
        moveToTail(node);
        return node.value;
    }

    public void put(int key, int value) {
        if (map.containsKey(key)) {
            Node node = map.get(key);
            node.value = value;
            moveToTail(node);
        } else {
            Node node = new Node(key, value);
            if (count < capacity) {
                count++;
                map.put(key, node);
                addNode(node);
            } else {
                deleteFirst();
                map.put(key, node);
                addNode(node);
            }
        }
    }
}

说明：在双向链表中，创建虚拟的头结点和尾节点，这样保证链表始终不为空，并且添加进入的数据不会是头结点和尾节点，这样可以省去很多空值的判断。

460. LFU缓存

简介

请你为 最不经常使用（LFU）缓存算法设计并实现数据结构。它应该支持以下操作：get 和 put。

get(key) - 如果键存在于缓存中，则获取键的值（总是正数），否则返回 -1。
put(key, value) - 如果键已存在，则变更其值；如果键不存在，请插入键值对。当缓存达到其容量时，则应该在插入新项之前，使最不经常使用的项无效。在此问题中，当存在平局（即两个或更多个键具有相同使用频率）时，应该去除最久未使用的键。
「项的使用次数」就是自插入该项以来对其调用 get 和 put 函数的次数之和。使用次数会在对应项被移除后置为 0 。

进阶：
你是否可以在 O(1) 时间复杂度内执行两项操作？

示例：

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

分析

LFU 和 LRU 的区别在于需要保存每条数据的使用频率。

我们为每个频率保存一个双向链表，同时建立一个频率和相应链表的映射freqMap。

建立另一个keyMap，记录存储数据的 key和对应节点的映射。

代码

class LFUCache {

    class Node {
        private int key;
        private int value;
        private int freq;
        private Node next;
        private Node pre;

        public Node() {
        }

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

    // 不同频率对应的链表头节点和尾节点
    private Map<Integer, Node[]> freqMap;
    // 键对应的节点
    private Map<Integer, Node> keyMap;
    private int capacity;
    private int count;
    // 记录当前的最小频率
    private int minFreq;

    public LFUCache(int capacity) {
        this.capacity = capacity;
        count = 0;
        freqMap = new HashMap<>();
        keyMap = new HashMap<>();
        minFreq = -1;
    }
	
	// 初始化一个双向链表的首位节点
    private Node[] intiDLinked() {
        Node head = new Node();
        Node tail = new Node();
        head.next = tail;
        tail.pre = head;
        return new Node[]{head, tail};
    }
	
	// 删除一个指定的节点，并修改minFreq
    private void deleteNode(Node node) {
        node.next.pre = node.pre;
        node.pre.next = node.next;
        // check minFreq
        int freq = node.freq;
        Node[] headAndTail = freqMap.get(node.freq);
        if (minFreq == freq && headAndTail[0].next == headAndTail[1]) {
            minFreq++;
        }
    }
	
	// 插入一个节点，根据节点的频率插入到相应的链表中
    private void insertInto(Node node) {
        int freq = node.freq;
        Node tail;
        if (!freqMap.containsKey(freq)) {
            Node[] headAndTail = intiDLinked();
            tail = headAndTail[1];
            freqMap.put(freq, headAndTail);
        } else {
            tail = freqMap.get(freq)[1];
        }
        Node pre = tail.pre;
        pre.next = node;
        node.pre = pre;
        node.next = tail;
        tail.pre = node;
    }
	
	// 将一个节点频率加一后插入新的链表
    private void addFreq(Node node) {
        // get from origin freq
        deleteNode(node);
        node.freq++;
        // insert into new freq
        insertInto(node);
    }
	
	// 淘汰最小频率
    private void deleteMinFreq() {
        Node[] headAndTail = freqMap.get(minFreq);
        Node head = headAndTail[0], tail = headAndTail[1];
        Node node = head.next;
        node.next.pre = node.pre;
        node.pre.next = node.next;
        keyMap.remove(node.key);
        if (head.next == tail) {
            minFreq = 1;  // 此时肯定是有新的数据插入导致需要删除最小频率的数，所以minFreq变为1
        }
    }

    public int get(int key) {
        if (!keyMap.containsKey(key)) {
            return -1;
        }
        Node node = keyMap.get(key);
        addFreq(node);
        return node.value;
    }

    public void put(int key, int value) {
        if (keyMap.containsKey(key)) {
            Node node = keyMap.get(key);
            node.value = value;
            addFreq(node);
        } else {
            Node node = new Node(key, value);
            if (capacity == 0) {
                return;
            } else if (count < capacity) {
                count++;
            } else {
                // 最小频率
                deleteMinFreq();
            }
            node.freq = 1;
            minFreq = 1;
            insertInto(node);
            keyMap.put(key, node);
        }
    }
}

注意：维护一个minFreq，记录当前的最小频率，这样在淘汰元素的时候可以直接去对象的链表删除节点，避免了循环查找最小频率。