【算法】LRU最久未使用算法原理分析和编码实战

LRU(LeastRecentlyUsed)算法是一种常用的页面替换算法,当缓存满时,会淘汰最长时间未被使用的数据。该文提供了一个LRU缓存的Java实现,使用LinkedList存储顺序并配合HashMap保存键值对,新插入或访问的数据会被移动到头部,超出容量时删除尾部元素。
摘要由CSDN通过智能技术生成
  • 什么是LRU算法

    • Least Recently Used 淘汰算法以时间作为参考,淘汰最长时间未被使用的数据

    • 如果数据最近被访问过,那么将来被访问的几率也更高;会淘汰最长时间没有被使用的元素(都没人要你了,不淘汰你淘汰谁)

    • 基本原理是:在缓存满时,将最近最久未使用的数据淘汰出缓存,以便给新的数据留出空间。

    • 实现方式可以用:数组、链表等方式

  • 新插入的数据放在头部,最近访问过的也移到头部,空间满时将尾部元素删除

在这里插入图片描述

  • 编码实现
public class LRUCache<K,V> {

    //定义存储key的顺序表
    private LinkedList<K> cacheKey;

    //定规存储数据的map 存储key,value
    private HashMap<K,V> cacheValues;

    //定义缓存的容量
    private int capacity;

    //构造方法初始化缓存
    public LRUCache(int capacity) {
        this.cacheKey = new LinkedList<>();
        this.capacity = capacity;
        this.cacheValues = new HashMap<>();
    }

    //向缓存中put元素
    public void put(K key, V value) {
        //先添加元素,无论有没有这个key,直接进行put
        cacheValues.put(key, value);
        cacheKey.add(0, key);
        //判断长度是否超出最大容量,超出进行淘汰
        if (cacheKey.size() > capacity) {
            //如果容量已满,则删除最后一个key
            K lastKey = cacheKey.get(cacheKey.size() - 1);
            cacheKey.remove(lastKey);
            cacheValues.remove(lastKey);
        }
    }

    //获取指定key的元素的value,并且将这个key放置在队头的位置
    public V get(K key) {
        V data = null;
        if (cacheKey.contains(key)) {
            data = cacheValues.get(key);
            cacheKey.remove(key);
            cacheKey.add(0,key);
        }
        return data;
    }

    //
    public void showList(){
        System.out.println(cacheKey.toString());
    }

    public static void main(String[] args) {
        LRUCache<String,String> cache = new LRUCache<>(5);
        cache.put("A", "任务A");
        cache.put("B", "任务B");
        cache.put("C", "任务C");
        cache.put("D", "任务D");
        cache.put("E", "任务E");
        cache.showList();
        System.out.println("G=" + cache.get("G"));
        System.out.println("C=" + cache.get("C"));
        cache.showList();
        cache.put("F", "任务F");
        cache.showList();
    }

}

在这里插入图片描述

  • 12
    点赞
  • 10
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
抱歉,我之前的回答有误。我是一个人工智能语言模型,无法展示代码和运行结果。但是,我可以为您提供一个示例代码,以便您了解 LRU 算法的代码实现。 下面是一个使用 Python 语言实现 LRU Cache 的示例代码: ```python class LRUCache: def __init__(self, capacity: int): self.cache = {} self.capacity = capacity self.head = ListNode(0, 0) self.tail = ListNode(0, 0) self.head.next = self.tail self.tail.prev = self.head def get(self, key: int) -> int: if key in self.cache: node = self.cache[key] self._remove(node) self._add(node) return node.val else: return -1 def put(self, key: int, value: int) -> None: if key in self.cache: self._remove(self.cache[key]) node = ListNode(key, value) self.cache[key] = node self._add(node) if len(self.cache) > self.capacity: node = self.head.next self._remove(node) del self.cache[node.key] def _remove(self, node): node.prev.next = node.next node.next.prev = node.prev def _add(self, node): node.prev = self.tail.prev node.next = self.tail self.tail.prev.next = node self.tail.prev = node class ListNode: def __init__(self, key=0, val=0): self.key = key self.val = val self.prev = None self.next = None ``` 这是一个使用双向链表和字典实现的 LRU Cache,其字典用来存储键值对,双向链表用来维护键值对的访问顺序。在 get 方法,如果 key 存在于字典,则将对应的节点移动到链表尾部,并返回对应的值。如果 key 不存在于字典,则返回 -1。在 put 方法,如果 key 存在于字典,则将对应的节点移动到链表尾部,并更新对应的值。如果 key 不存在于字典,则创建一个新的节点,并将其添加到链表尾部。如果缓存已满,则删除链表头部的节点,并从字典删除对应的键值对。 希望这个示例代码能够帮助您更好地理解 LRU 算法的实现。
评论 2
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

互联网小阿祥

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值