JavaScript双向链表实现LRU缓存算法，轻松玩转缓存技术

闲谈

2023-11-18 15:41:01

缓存与缓存淘汰

在计算机科学中，缓存是一种临时存储数据的地方。它用于存储最近使用过的数据，以便在下次需要时能够快速访问。缓存可以提高应用程序的性能，因为它可以减少从较慢的存储设备（如磁盘）中检索数据的次数。

然而，缓存的空间是有限的。当缓存已满时，就需要使用缓存淘汰策略来决定哪些数据应该被删除。缓存淘汰策略决定了哪些数据应该被删除，以便为新数据腾出空间。

2. LRU缓存算法简介

LRU（最近最少使用）缓存算法是一种常用的缓存淘汰策略。LRU缓存算法会跟踪每个数据项最近被访问的时间。当缓存已满时，LRU缓存算法会删除最近最少使用的数据项。

3. 使用JavaScript双向链表实现LRU缓存

现在，我们使用JavaScript双向链表来实现LRU缓存。双向链表是一种特殊的数据结构，它允许我们快速地从链表的任意位置添加或删除元素。

class Node {
  constructor(key, value) {
    this.key = key;
    this.value = value;
    this.prev = null;
    this.next = null;
  }
}

class LRUCache {
  constructor(capacity) {
    this.capacity = capacity;
    this.size = 0;
    this.head = new Node(null, null);
    this.tail = new Node(null, null);
    this.head.next = this.tail;
    this.tail.prev = this.head;
  }

  get(key) {
    const node = this.getNodeByKey(key);
    if (node) {
      this.moveToHead(node);
      return node.value;
    }
    return null;
  }

  put(key, value) {
    const node = this.getNodeByKey(key);
    if (node) {
      node.value = value;
      this.moveToHead(node);
    } else {
      const newNode = new Node(key, value);
      this.addNodeToHead(newNode);
      this.size++;
      if (this.size > this.capacity) {
        this.removeLeastRecentlyUsedNode();
      }
    }
  }

  getNodeByKey(key) {
    let current = this.head.next;
    while (current !== this.tail) {
      if (current.key === key) {
        return current;
      }
      current = current.next;
    }
    return null;
  }

  moveToHead(node) {
    this.removeNode(node);
    this.addNodeToHead(node);
  }

  addNodeToHead(node) {
    node.next = this.head.next;
    node.prev = this.head;
    this.head.next = node;
    node.next.prev = node;
  }

  removeNode(node) {
    node.prev.next = node.next;
    node.next.prev = node.prev;
  }

  removeLeastRecentlyUsedNode() {
    const node = this.tail.prev;
    this.removeNode(node);
    this.size--;
  }
}