一文彻底搞懂基于数组和链表分别实现LRU算法

文章目录

1. LRU算法
2. 基于数组实现LRU算法
3. 基于链表实现LRU算法

1. LRU算法

常见的缓存淘汰策略有三种，分别是：先进先出策略FIFO（First In，First Out）、最少使用策略LFU（Least Frequently Used）、最近最少使用策略LRU（Least Recently Used）

先进先出策略（FIFO）：即最先进入缓存的数据最先被淘汰。这种策略类似于队列的工作方式，新数据加入到队列的尾部，而最先进入队列的数据会被淘汰。
最少使用策略（LFU）：即最少被访问的数据最先被淘汰。LFU策略根据数据的访问频率来决定淘汰顺序，访问次数最少的数据会被优先淘汰。
最近最少使用策略（LRU）：即最近最少被访问的数据最先被淘汰。LRU策略根据数据的访问时间来决定淘汰顺序，最近最久未被访问的数据会被优先淘汰。

LRU算法的工作原理：

首先，我们定义一个容量为4的整型数组来模拟缓存，初始状态数组为空
我们开始向数组中查询数据，如果数据存在就返回，数据不存在就插入数据
2.1 查询数据1：由于缓存为空，将数据1插入到数组头部（下标0）
2.2 查询数据2：由于缓存中已有数据1，根据LRU算法，将数据2插入到数组头部，将原来的数据1向后位移，数组中的数据是2、1
2.3 查询数据3和4：类似地，数据3和4被插入到数组的头部，数组中的数据变为4、3、2、1，此时数组达到了缓存的最大容量
继续访问数据就有两种方式
3.1 访问缓存中没有的数据，比如5，那么由于此是数组已经满了，所以根据LRU算法定义，我们把数组尾部的数据1剔除，然后把1之前的数据，都向右位移一位，此时数组是：null、4、3、2，然后再将数据5插入到数组的头部，那么此时数组中的数据就是：5、4、3、2
3.2 访问缓存中已经有的数据，比如2，那么不管此时数组是否已经满了，我们可以在数组中找到数据2，那么我们就先把数组中数据是2的数据删除，然后把2之前的数据显向右位移一位，此时数组中的数据是：null、4、3、1，然后我们再把数据2插入到数组的头部之后，数组中的数据是：2、4、3、1

2. 基于数组实现LRU算法

import java.util.HashMap;
import java.util.Map;/*** 基于数组实现LRU算法*/
public class LRUBaseArray<T> {private static final int DEFAULT_CAPACITY = 8;private int capacity; // 缓存容量private int count; // 缓存中元素数量private T[] value; // 存放元素的数组，模拟缓存private Map<T, Integer> holder; // 存储数据的位置public LRUBaseArray() {this(DEFAULT_CAPACITY);}public LRUBaseArray(int capacity) {this.capacity = capacity;value = (T[]) new Object[capacity];count = 0;holder = new HashMap<>(capacity);}/*** 访问某个值，有的话更新到头部，没有的话尝试插入到头部** @param object 待插入的元素*/public void offer(T object) {if (object == null) {throw new IllegalArgumentException("缓存容器不支持null");}Integer index = holder.get(object);if (index == null) {if (isFull()) {removeAndCache(object);} else {cache(object);}} else {update(index);}}/*** 将新元素插入缓存头部** @param object 待插入的元素*/private void cache(T object) {rightShift(count);value[0] = object;holder.put(object, 0);count++;}/*** 更新已存在元素的位置到缓存头部** @param index 元素在缓存中的位置索引*/private void update(Integer index) {T target = value[index];rightShift(index);value[0] = target;holder.put(target, 0);}/*** 缓存满的情况下，删除尾部元素，并将新元素插入缓存头部** @param object 待插入的元素*/private void removeAndCache(T object) {T key = value[--count];holder.remove(key);cache(object);}/*** 将数组中的元素向右移动一位** @param end 数组边界*/public void rightShift(int end) {for (int i = end - 1; i >= 0; i--) {value[i + 1] = value[i];holder.put(value[i], i + 1);}}/*** 判断缓存是否已满** @return 缓存是否已满*/private boolean isFull() {return count == capacity;}@Overridepublic String toString() {StringBuilder sb = new StringBuilder();for (int i = 0; i < count; i++) {sb.append(value[i]);sb.append(" ");}return sb.toString();}public static void main(String[] args) {LRUBaseArray<Integer> lru = new LRUBaseArray<>();lru.offer(1);lru.offer(2);lru.offer(3);lru.offer(4);lru.offer(5);System.out.println(lru);lru.offer(6);lru.offer(7);lru.offer(8);lru.offer(9);System.out.println(lru);}
}

执行结果

5 4 3 2 
9 8 7 6

首先将数字1到5依次加入缓存，当缓存容量达到上限4时，数字1被替换出去，然后继续添加数字6到9，此时数字5被替换出去，最终缓存中只剩下数字6到9。

3. 基于链表实现LRU算法

import java.util.HashMap;
import java.util.Map;/*** 基于单链表实现LRU算法* @param <T>*/
public class LRUBaseLinkedList<T> {// 默认链表容量private final static int DEFAULT_CAPACITY = 5;// 头节点private Node<T> head;// 链表长度private int size;// 链表容量private int capacity;// 记录节点的前一个节点，方便删除操作private Map<T, Node<T>> prevNodeMap;public LRUBaseLinkedList() {this(DEFAULT_CAPACITY);}public LRUBaseLinkedList(int capacity) {this.capacity = capacity;this.size = 0;this.head = new Node<>();this.prevNodeMap = new HashMap<>();}/*** 插入元素** @param data 待插入的元素*/public void add(T data) {if (data == null) {throw new IllegalArgumentException("Data cannot be null");}Node<T> prevNode = prevNodeMap.get(data);if (prevNode != null) {deleteElem(prevNode);} else {if (size >= capacity) {deleteLastElem();}}insertElemAtHead(data);}// 删除尾节点private void deleteLastElem() {Node<T> ptr = head;while (ptr.next.next != null) {ptr = ptr.next;}prevNodeMap.remove(ptr.next.data);ptr.next = null;size--;}// 删除当前节点的下一个节点private void deleteElem(Node<T> prevNode) {Node<T> temp = prevNode.next;prevNode.next = temp.next;prevNodeMap.remove(temp.data);temp = null;size--;}// 插入元素到链表头节点private void insertElemAtHead(T data) {Node<T> next = head.next;head.next = new Node<>(data, next);prevNodeMap.put(data, head);size++;}// 定义内部存储结构private static class Node<T> {T data;Node<T> next;Node() {}Node(T data, Node<T> next) {this.data = data;this.next = next;}}@Overridepublic String toString() {StringBuilder sb = new StringBuilder();Node<T> temp = head.next;while (temp != null) {sb.append(temp.data).append(" ");temp = temp.next;}return sb.toString();}public static void main(String[] args) {LRUBaseLinkedList<Integer> list = new LRUBaseLinkedList<>();list.add(1);list.add(2);list.add(3);list.add(4);list.add(5);System.out.println(list);list.add(6);System.out.println(list);list.add(4);System.out.println(list);}
}

执行结果