LRU是Least Recently Used的缩写，即最近最少使用，是一种常用的页面置换算法，选择最近最久未使用的页面予以淘汰。该算法赋予每个页面一个访问字段，用来记录一个页面自上次被访问以来所经历的时间 t，当须淘汰一个页面时，选择现有页面中其 t 值最大的，即最近最少使用的页面予以淘汰。

LRU 缓存机制可以通过哈希表辅以双向链表实现，用一个哈希表和一个双向链表维护所有在缓存中的键值对。

双向链表按照被使用的顺序存储了这些键值对，靠近头部的键值对是最近使用的，而靠近尾部的键值对是最久未使用的。
哈希表即为普通的哈希映射（HashMap），通过缓存数据的键映射到其在双向链表中的位置。

这样以来，我们首先使用哈希表进行定位，找出缓存项在双向链表中的位置，随后将其移动到双向链表的头部，即可在 O(1)) 的时间内完成 get 或者 put 操作。

对于 get 操作，首先判断 key 是否存在：

如果 key 不存在，则返回 -1；
如果 key 存在，则 key 对应的节点是最近被使用的节点。通过哈希表定位到该节点在双向链表中的位置，并将其移动到双向链表的头部，最后返回该节点的值。

对于 put 操作，首先判断 key 是否存在：

如果 key 不存在，使用 key 和 value 创建一个新的节点，在双向链表的头部添加该节点，并将 key 和该节点添加进哈希表中。然后判断双向链表的节点数是否超出容量，如果超出容量，则删除双向链表的尾部节点，并删除哈希表中对应的项；
如果 key 存在，则与 get 操作类似，先通过哈希表定位，再将对应的节点的值更新为 value，并将该节点移到双向链表的头部。

上面的操作，访问哈希表的时间复杂度为 O(1)，在双向链表的头部添加节点、在双向链表的尾部删除节点的复杂度也为 O(1)。而将一个节点移到双向链表的头部，可以分成删除该节点和在双向链表的头部添加节点两步操作，都可以在 O(1)时间内完成。

/*
实现LRU算法, 需要用到哈希表和一个双向链表
*/

import 'dart:core';

class Node {
  Node? next;
  Node? previous;
  final String key;
  var value;

  Node({this.next, this.previous, required this.key, required this.value});
}

class LRUCache {
  /// 头部节点、尾部节点
  Node? _head, _tail;

  final _entries = <String, Node>{};

  int _capacity = 0;

  int _size = 0;

  LRUCache({required capacity}) {
    _capacity = capacity;
  }

  get(String key) {
    final entry = _entries[key];
    if (entry == null) return null;

    /// 如果 key 存在，先通过哈希表定位，再移到头部
    _moveToHead(entry);
    return entry.value;
  }

 put(String key, value) {
   final entry = _entries[key];
    if (entry == null) {
        /// 如果 key 不存在，创建一个新的节点
          final node = Node(key: key, value: value);
          /// 添加进哈希表
          _entries[key] = node;

          ///  添加至双向链表的头部
          addToHead(node);
          _size += 1;
          if (_size > _capacity) {
            /// 如果超出容量，删除双向链表的尾部节点
              final removed = removeTail();
              /// 删除哈希表中对应的项
              _entries.remove(removed.key);
              _size -= 1;
          }
    } else {
      /// 如果 key 存在，先通过哈希表定位，再修改 value，并移到头部
      final node = _entries[key];
      node?.value = value;
      _moveToHead(node);
    }
 }
     

  /// 清空数据
  clear() {
    _entries.clear();
    _head = null;
    _tail = null;
  }

  addToHead(Node node) {
    node.previous = _head;
    node.next = _head?.next;
    _head?.next?.previous = node;
    _head?.next = node;
  }

  removeNode(node) {
    if (node == _tail) {
      _tail = node.next;
      _tail?.previous = null;
    }
    if (node == _head) {
      _head = node.previous;
      _head?.next = null;
    }
  }

  _moveToHead(node) {
    if (node == _head) return;
    if (node == _tail) {
      _tail = node.next;
    }
    if (node.previous != null) {
      node.previous!.next = node.next;
    }
    if (node.next != null) {
      node.next!.previous = node.previous;
    }
    addToHead(node);
  }

  removeTail() {
    if (isEmpty()) throw LruEmptyException();
    final Node node = _tail!.previous!;
    removeNode(node);
    return node;
  }

  /// 判断链表是否为空
  bool isEmpty() {
    return _head == null;
  }
}

class LruOverFlowException implements Exception {
  const LruOverFlowException();
  String toString() => 'LruOverFlowException';
}

class LruEmptyException implements Exception {
  const LruEmptyException();
  String toString() => 'LruEmptyException';
}

参考资料

LRU 缓存

LRU 缓存机制 - 题目解析

数据结构与算法(Dart)之LRU算法(九)

参考资料