lru算法java实现伪代码_程序员应该如何学习算法？

最新推荐文章于 2022-05-06 09:24:23 发布
最新推荐文章于 2022-05-06 09:24:23 发布
阅读量218 收藏
点赞数
文章标签： lru算法java实现伪代码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42529366/article/details/114323093
版权

推荐一份资源：

一位从1998年就开始讲课的老教授Jeff Erickson，把他20年来在UIUC讲课的内容整理成了一本算法书，名字简单粗暴，就叫《算法》(Algorithms)。

这本书在网上公布后，很快就成了国外计算机系学生讨论的热门话题，在Hacker News已经收获超过1000赞。

原因当然是他在学生当中的名气。Jeff是计算机视觉领域知名学者，有扎实专业知识。难能可贵的是，他教学风格轻松愉快，广受学生欢迎，甚至一位20年前的学生也亲自发帖为他打call。

书本内容

《算法》总共有448页，，除去前言和简介部分，总共包含了12个章节的内容，主要谈到了以下一些算法：

递归、回溯、动态编程、贪心算法、基本图算法、深度优先搜索、最小生成树、最短路径、全局最短路径、最大流最小割、流量与切割的应用、NP困难等。

Jeff把这本书称作出版印刷前的“第0版”，你可以去他的GitHub页下载到《算法》这本书的PDF版，帮忙找排版和内容上的bug。

喜欢看纸质书的小伙伴也不用着急，《算法》的纸质版即将发行。至于电子版也会一直免费提供下去。

既然是讲义的整理，除了基本教学内容外，当然还有习题和考卷，每年都会根据教学内容实时更新。如果你想要随附习题的答案，Jeff本人是拒绝的，还是自己动手吧。这本书没有习题答案！

Jeff教师认为，教材有时候在大学教学和自学者之间有不可调和的矛盾。Jeff显然更看重课堂上的学生，如果提供标准答案，只会让学生死记硬背，忽略了答案背后的逻辑。

而且，Jeff说那些想要答案的学位往往是爱作弊的学生。学渣们你们颤抖了吗？

关于作者

如果仅凭以上内容，就认为Jeff是一个不讲情面的大学教授就完全错了。

在考试方面，Jeff对待学生可以说是相当“宽松”。学生在考试题下面写“我不知道”，就能得到25%的分数。

这么做是为了鼓励学生承认自己的缺点，助教也不必为审阅垃圾答案浪费时间。

有趣的是，这位Jeff教授不是一个唯成绩论的人。

因为他自己当初就是一个不折不扣的学渣，GPA得分只有2.4(满分4.0)。他却靠自身努力成为知名教授。

对那些成绩很差却想继续深造的学生，Jeff传授了一点他自己过往的人生经验：

让导师看到你的努力和在专业方面的技能，比如你曾经在计算机领域的就业经历。让导师相信，你出色的能力让他愿意承担风险。(Jeff自己在攻读硕士前就曾是软件工程师。)

最后，Jeff有个幸福的家庭，上面的画像就是他12岁女儿所画。

资源汇总

-完-

量子位 · QbitAI

վ'ᴗ' ի 追踪AI技术和产品新动态量子位​www.zhihu.comac94264df0664e4557bfe282928c8604.png

欢迎大家关注我们，以及订阅我们的知乎专栏

隔壁倒霉孩子
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
leetcode伪代码-LRUCache:LRU缓存机制
06-30
leetcode伪代码 LRU缓存 刷leetcode每日一题，记录一下 思路分析 使用哈希表解决查找和插入O(1)的问题 使用双向链表解决缓存热度 结合下就是哈希链表（#233） 实现过程 在实现的过程中，大部分时间花费在边界的处理，想砸键盘 巧用伪元素来减少编码的复杂度 看了leetcode的官方解读，觉得自己还是太年轻 伪元素 创建首尾伪元素，在链表操作时可以忽略边界处理，下面列出部分代码，可以查看完整 /// <summary> /// 伪首元素，可以忽略边界处理 /// </summary> private readonly DoubleLinkedListNode _first = new DoubleLinkedListNode(default, default); /// <summary> /// 伪尾元素，可以忽略边界处理 /// </summary> private readonly DoubleLinkedListNode _last = new DoubleLinkedListNode(default, default); ... 其它元素 private v
Java实现LRU算法.zip
11-13
LRU（Least Recently Used）算法是一种常见的页面替换算法，用于解决计算机内存有限而数据页数量过多的问题。...通过学习和理解LRU算法的实现，我们可以更好地理解和处理内存限制问题，提高系统的性能和效率。
java算法学习_程序员应该如何学习算法？
weixin_42504649的博客
02-12 372
推荐一份资源：一位从1998年就开始讲课的老教授Jeff Erickson，把他20年来在UIUC讲课的内容整理成了一本算法书，名字简单粗暴，就叫《算法》(Algorithms)。这本书在网上公布后，很快就成了国外计算机系学生讨论的热门话题，在Hacker News已经收获超过1000赞。原因当然是他在学生当中的名气。Jeff是计算机视觉领域知名学者，有扎实专业知识。难能可贵的是，他教学风格轻松愉...
lru算法java实现伪代码_CFTL: 混合固态硬盘代码仿真（师兄的旧版本的代码，存在各种问题，但实现思路可参考借鉴，代码目前已废弃）...
weixin_32027779的博客
02-17 405
CFTL运行代码需要注意的地方编译环境代码是直接运行在Ubuntu10.04的机子上,gcc-2.95,在实验室的那台老机子上,我已经打包压缩好了,注意使用前备份代码替换注意项注意本代码不能直接独立编译运行!!!!只是Flashsim修改后的代码Flashsim的代码必须编译运行在disksim3.0的仿真器上,因此必须先安装成功disksim+flashsim的仿真器后,将主目录下的src换成该...
Java算法怎么学？算法是什么？
qq_52198123的博客
03-10 897
什么是算法？算法的定义？ 算法其实说大白话，他就是解决问题的一种办法，不分高低贵贱，就说一个很简单的例子吧，我给你一个数组，数组是[5,2,12,4,22,45,1]，我的要求是让你把他给我按从小到大排序，你这么做？ 很多人第一想法就是冒泡排序，那么冒泡排序就是算法。看起来冒泡排序的代码很简单就是个简单的for循环，但为什么他叫算法？因为他解决了问题，解决问题就是算法。 算法怎么学？都有什么？ 还是拿我们上面提到的数组排序来说，你会想到什么？第一想法我想很多人都是说 冒泡排序 冒泡排序，那除了冒泡排.
Java算法怎么学？算法是什么？（下）
qq_52198123的博客
03-11 650
接着昨天的讲吧。现在大家对算法应该都有了点最基本的概念了吧？那么我们下面来说一下，算法的几个特征，算法的基本特征有五个，分别是输入，输出，确定性，可行性，有穷性。 目录算法五大特征1. 输出和输入2. 确定性3. 可行性4. 有穷性算法设计的要求1. 正确性2. 可读性3. 健壮性4. 效率，内存 算法五大特征 1. 输出和输入 输出和输入就比较好理解了吧？输入就是指输入参数，绝大多数的算法都是要有输入参数的，这就是他的输入特征，输出呢，输出是算法必须要用到的，因为你算出来的结果你要返回，或者去打印出来，不
LRU.rar_LRU_lru 算法_lru算法
09-23
在提供的压缩包文件中，"LRU.rar"可能包含了关于LRU算法的实现代码或详细解释。"www.pudn.com.txt"可能是从网站pudn.com下载的有关LRU的资料。解压后，可以通过阅读这些文件来深入理解LRU算法的原理和具体实现。
LRU算法 java实现
01-15
以下是一个简单的LRU缓存实现的Java代码框架： ```java class LRUCache, V> { private int capacity; private HashMap, Node> map; private DoublyLinkedList<Node> list; public LRUCache(int capacity) { ...
FIFO与LRU 算法实现（java）.rar_FIFO Java_LRU_fifo
09-22
在提供的文档"FIFO与LRU 算法实现（java）.doc"中，可能包含了具体的代码实现和分析，而"www.pudn.com.txt"可能是文档的来源或补充信息。如果文档中的内容难以理解，建议寻求社区的帮助，或者尝试自己根据上述原理...
LRU.rar_LRU_lru 算法_visual c
09-22
在这个"LRU.rar"压缩包中，"LRU.txt"文件很可能包含了用C语言实现LRU算法的源代码，通过分析这个文本文件，我们可以深入理解LRU算法的具体实现细节。 一个简单的LRU链表实现包括以下几个步骤： 1. 初始化链表：创建...
机器学习算法的java实现
09-09
可用于学习机器学习算法时的实验与实现 最好是在了解了机器学习相关基本理论后再看这个。
android，java整理学习的代码，包括设计模式，算法，数据结构等
02-06
java，设计模式，算法，数据结构
JAVA部分算法学习（理论）
qwer179qwer179的博客
03-29 795
一·二分查找算法 基本的二分查找，剩下两种有时间搞明白再写 思路： int binarySearch(int[] nums, int target) { int left = 0; int right = nums.length - 1; //确定搜索区间 while(left <= right) { int mid = left+(right-left)/2;//确定中间值的下标,等同于left/2+right/2,此处是为了防止溢出，一个小细节
java常用算法学习整理
qq_28403781的博客
07-22 203
又叫折半查找，要求待查找的序列有序。每次取中间位置的值与待查关键字比较，如果中间位置的值比待查关键字大，则在前半部分循环这个查找的过程，如果中间位置的值比待查关键字小，则在后半部分循环这个查找的过程。直到查找到了为止，否则序列中没有待查的关键字。 public static int biSearch(int []array,int a){ int lo=0; int hi=array.length-1; int mid; while(lo<=hi){ mid=(lo+hi)/2;//中间位置 i
LRU算法代码
朱家小旺
03-20 565
// 最近最少缓存算法（key,value） class LRUCache { private: // 1、list双向链表 std::list<std::pair< int, int> > _list; // 2、使用unordered_map // 由于需要快速定位链表的结点，故在map中使用value字段来存储链表的结点，这里是使用了迭代器。 std::unordered_map< int, std::list<std::p
Java 基础算法
Azurecs的博客
05-06 229
本文记录了在平时的Java学习中遇到的一些基础算法
编程实现一个LRU算法
qq_41445952的博客
07-18 689
这一题要我们设计一个LRU（最近最少使用算法），我的思路是用一个hash表加一个双向链表实现，其插入，删除，获取节点时间复杂度均在O(1)，代码如下 class LRUCache { public: struct node { int key; int val; node* front; node* next; node() : val(0), front(NULL), ...
LRU算法代码实现记录一下
qq_41665452的博客
08-13 314
前言 之前有写过一篇关于LRU淘汰算法的文章 LRU算法记录一下，LRU算法思想是淘汰最近最少使用的元素，当一个元素在一段时间内没有访问过后，那么在之后的一段时间也极有可能不会被访问，然后当数据池满了后将其淘汰掉。 这次把关于LFU算法的三种不同实现方式写一下，那废话不多说，show me code LRU实现之数组 O(N) /** * LRU实现之数组 O(N) * * @Author: ZRH * @Date: 2021/8/13 10:32 */ public class ArrayL
手写LRU
secretx的专栏
06-30 299
手写LRU 1.要求 put / get 均是 O(1) 时间复杂度 超出容量自动删除最老数据 2.用什么数据结构？ 任意查找要求 O(1),必然有哈希 时间需要有序，必然链表或者数组 由于删除需求，也要控制在O(1),数组淘汰 由于单链表删除节点，需要寻找前驱，并非 O(1)，所以单链表淘汰 所以结论，哈希(key-->node) + 双链表，哈希存key维持映射关系，双链表维持时序以及val 3.进一步，链表的Node定义是？ 初版 class Node(o
使用Java实现lru算法详细代码
最新发布
09-22
### 回答1： LRU算法（Least Recently Used）可以使用Java集合框架中的LinkedHashMap来实现，LinkedHashMap提供了一种按访问顺序排序的功能，具体实现示例如下：import java.util.*;public class LRUCache { // 容量 private int capacity; // 使用LinkedHashMap保存缓存的内容 private LinkedHashMap<Integer, Integer> cache; // 构造函数 public LRUCache(int capacity) { this.capacity = capacity; cache = new LinkedHashMap<Integer, Integer>(capacity, 0.75f, true){ // 重写removeEldestEntry方法 @Override protected boolean removeEldestEntry(Map.Entry<Integer, Integer> eldest) { return size() > capacity; } }; } // 根据key获取缓存内容 public int get(int key) { Integer value = cache.get(key); if (value == null) { return -1; } else { return value; } } // 存入key-value public void put(int key, int value) { cache.put(key, value); } } ### 回答2： LRU算法（Least Recently Used，最近最少使用）是一种用于缓存替换策略的算法，它保留最近使用的数据，并淘汰最久未使用的数据。以下是使用Java实现LRU算法的详细代码： ```java import java.util.HashMap; class Node { int key; int value; Node prev; Node next; public Node(int key, int value) { this.key = key; this.value = value; } } class LRUCache { private int capacity; private HashMap<Integer, Node> map; private Node head; private Node tail; public LRUCache(int capacity) { this.capacity = capacity; this.map = new HashMap<>(); this.head = new Node(0, 0); this.tail = new Node(0, 0); head.next = tail; tail.prev = head; } public int get(int key) { if (map.containsKey(key)) { Node node = map.get(key); remove(node); addToHead(node); return node.value; } return -1; } public void put(int key, int value) { if (map.containsKey(key)) { Node node = map.get(key); node.value = value; remove(node); addToHead(node); } else { if (map.size() == capacity) { map.remove(tail.prev.key); remove(tail.prev); } Node newNode = new Node(key, value); map.put(key, newNode); addToHead(newNode); } } private void addToHead(Node node) { node.next = head.next; node.next.prev = node; node.prev = head; head.next = node; } private void remove(Node node) { node.prev.next = node.next; node.next.prev = node.prev; } } ``` 本实现使用HashMap来存储缓存数据，HashMap的键为键值，值为对应的Node节点。 LRUCache类有一个构造函数用于初始化缓存容量。get方法用于获取缓存中的值，它首先判断缓存是否包含该键值，如果包含，则将对应的节点移至链表头部并返回对应的值；如果不包含则返回-1。put方法用于存储缓存数据，如果缓存中已存在该键值，则更新对应的值并将对应的节点移至链表头部；如果缓存大小已达到容量上限，则删除最久未使用的节点，并将新节点添加至链表头部。addToHead和remove方法用于调整链表节点的位置，将最近使用的节点移至链表头部，最久未使用的节点移至链表尾部。 以上就是使用Java实现LRU算法的详细代码。 ### 回答3： LRU（最近最少使用）算法是一种缓存淘汰策略，它根据缓存中数据的访问时间来进行淘汰。当缓存已满时，会淘汰掉最近最少使用的数据。下面是使用Java实现LRU算法的详细代码： ```java import java.util.HashMap; public class LRUCache { private int capacity; private HashMap<Integer, Node> cache; private Node head; private Node tail; public LRUCache(int capacity) { this.capacity = capacity; cache = new HashMap<>(); head = new Node(-1, -1); tail = new Node(-1, -1); head.next = tail; tail.prev = head; } public int get(int key) { if (cache.containsKey(key)) { Node node = cache.get(key); // 将访问的节点移到链表头部 removeNode(node); addToHead(node); return node.value; } return -1; } public void put(int key, int value) { if (cache.containsKey(key)) { Node node = cache.get(key); node.value = value; // 将访问的节点移到链表头部 removeNode(node); addToHead(node); } else { if (cache.size() == capacity) { // 移除最近最少使用的节点 cache.remove(tail.prev.key); removeNode(tail.prev); } Node newNode = new Node(key, value); cache.put(key, newNode); addToHead(newNode); } } private void removeNode(Node node) { node.prev.next = node.next; node.next.prev = node.prev; } private void addToHead(Node node) { node.next = head.next; node.prev = head; head.next.prev = node; head.next = node; } private class Node { private int key; private int value; private Node prev; private Node next; public Node(int key, int value) { this.key = key; this.value = value; } } } ``` 以上代码实现了一个LRUCache类，里面包含了LRU算法的核心逻辑。LRUCache类有一个构造函数用于初始化缓存容量，get()方法用于获取缓存中的数据，put()方法用于往缓存中添加数据。算法通过双向链表和哈希表实现，双向链表中的节点按照访问顺序从头到尾依次排列，哈希表用于加快查找节点的速度。当缓存已满时，淘汰最近最少使用的节点，即双向链表的尾节点。对于get操作和put操作，都会将访问的节点移到链表头部，保证头部节点是最近访问的节点。这样即可以实现LRU算法的缓存淘汰策略。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值