Leetcode之LRU Cache

最新推荐文章于 2021-08-02 21:41:13 发布
最新推荐文章于 2021-08-02 21:41:13 发布
阅读量793 收藏
点赞数
分类专栏： 算法 leetcode 文章标签： leetcode java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lingchixin/article/details/42319063
版权

Design and implement a data structure for Least Recently Used (LRU) cache. It should support the following operations: get and set.

get(key) - Get the value (will always be positive) of the key if the key exists in the cache, otherwise return -1.
set(key, value) - Set or insert the value if the key is not already present. When the cache reached its capacity, it should invalidate the least recently used item before inserting a new item.


题述如上。

第一次编写的代码，思路是通过引用计数器来实现，功能通过，但又因为要不断地维护这个计数器而效率低下导致未accepted。


public class LRUCache {
	class Cache {
		int key;
		int value;
		int count;
	}

	Cache[] Cc;

	public LRUCache(int capacity) {
		Cc = new Cache[capacity];
		for (int i = 0; i < Cc.length; i++) {
			Cc[i] = new Cache();
			Cc[i].value = -1;
			Cc[i].count = i;
		}
	}

	public int get(int key) {
		for (int i = 0; i < Cc.length; i++) {
			if (Cc[i].key == key) {
				if (Cc[i].count != Cc.length - 1) {
					Cc[i].count = Cc.length - 1;
					for (int j = 0; j < Cc.length; j++) {
						Cc[j].count--;
					}
				}
				return Cc[i].value;
			}
		}
		return -1;
	}

	public void set(int key, int value) {
		for (int i = 0; i < Cc.length; i++) {
			Cc[i].count--;
			if (Cc[i].count == -1) {
				Cc[i].key = key;
				Cc[i].value = value;
				Cc[i].count = Cc.length - 1;
			}
		}
	}

	public static void main(String[] args) {
		LRUCache lru = new LRUCache(10);
		lru.set(2, 2);
		lru.set(3, 2);
		lru.set(11, 9);
		for (int i = 0; i < lru.Cc.length; i++) {
			System.out.println(lru.Cc[i].key + "count" + lru.Cc[i].count
					+ "value" + lru.Cc[i].value);
		}

		System.out.println(lru.get(11));
	}
}

然后我又默默的优化了一下。思路还是一样的。但是少了很多多余的变量 

class Map {
		int key;
		int value;
	}

	Map[] map;
	int capacity;

	public LRUCache(int capacity) {
		map = new Map[capacity];
		for (int i = 0; i < capacity; i++) {
			map[i] = new Map();
		}
		this.capacity = capacity;
	}

	public int get(int key) {
		int i = capacity - 1;
		int result = -1;
		Map temp = new Map();
		while (i > 0) {
			if (map[i].key == key) {
				result = map[i].value;
				temp = map[i];
				while (i < capacity - 1) {
					map[i] = map[i + 1];
					i++;
				}
				map[capacity - 1] = temp;
				break;
			}
			i--;
		}

		return result;
	}

	public void set(int key, int value) {
		int i = 0;
		while (i < capacity - 1) {
			map[i].key = map[i + 1].key;
			map[i].value = map[i + 1].value;
			i++;
		}
		map[capacity - 1].key = key;
		map[capacity - 1].value = value;
	}

但是还是没有通过：

Time Limit Exceeded
然后就不淡然了。。主要的问题是如何维护一个管道 。而且还是可调配顺序的。免不了要去用循环向后压数据，那么问题就在于如何去‘压’这个数。

然后。。想到了。。指针。。然后是自然的链表，有key和value其实可以用hashmap.但是不太想用已经现有的东西。所以我决定写一个由简到繁的代码。

第一个：用java里边自带的linkedhashmap。简直就是完全为了本题而出的。
简直像cheating. 
public class LRUCache {
    private int capacity;
    private Map<Integer, Integer> map;

    public LRUCache(int c) {
      this.capacity = c;
      this.map = new LinkedHashMap<Integer, Integer>(capacity, 0.75f, true) {
        protected boolean removeEldestEntry(Map.Entry<Integer, Integer> eldest) {
            return size() > capacity;
        }
      };
    }

    public int get(int key) {
        if (!map.containsKey(key)) {
            return -1;
        }
        return map.get(key);
    }

    public void set(int key, int value) {
        map.put(key, value);
    }
}


第二个就是自己写个链表。然后用hashmap的 
class Node {
		int key;
		int value;
		Node next;
		Node pre;

		Node(int key, int value) {
			this.key = key;
			this.value = value;
		}
	}

	int capacity;
	HashMap<Integer, Node> map;
	Node head = new Node(-1, -1);
	Node tail;
	int size = 0;

	public LRUCache(int capacity) {
		this.capacity = capacity;
		map = new HashMap<Integer, LRUCache.Node>(capacity);
	}

	public int get(int key) {
		Node temp = map.get(key);
		if (temp == null) {
			return -1;
		} else {
			removeNode(temp);
			temp = new Node(key, temp.value);
			addNodetoTail(temp);
			map.put(key, temp);
			return temp.value;
		}
	}

	public void set(int key, int value) {
		Node temp = map.get(key);
		if (temp == null) {
			if (size == capacity) {
				removeHead();
			}
			size++;
		} else {
			removeNode(temp);
		}
		temp = new Node(key, value);
		addNodetoTail(temp);
		map.put(key, temp);

	}

	private void removeHead() {
		// TODO Auto-generated method stub
		map.remove(head.key);
		if (size > 1) {
			head = head.next;
			head.pre = null;
		} else {
			head = null;
		}
		size--;
	}

	private void removeNode(Node temp) {
		// TODO Auto-generated method stub
		if (size > 1) {
			if (temp.pre != null) {// 证明是head结点
				temp.pre.next = temp.next;
			} else {
				head = head.next;
				head.pre = null;
			}
			if (temp.next != null)// 证明tail结点
			{
				temp.next.pre = temp.pre;
			} else {
				tail = tail.pre;
				tail.next = null;
			}
		} else {
			tail = null;
		}

	}

	private void addNodetoTail(Node node) {
		// TODO Auto-generated method stub
		if (tail == null || head == null) {
			head = node;
			tail = node;
			head.next = tail;
			tail.pre = head;
			head.pre = null;
			tail.next = null;
		} else {
			tail.next = node;
			node.pre = tail;
			node.next = null;
			tail = node;

		}
	}




可以看到自己写链表的话效率上会快那么 一点。主要是因为自己的功能单一。所以相当于精简了不必要的代码而提高了效率。

第三个比较有挑战性啦。那就是连hashmap都自己来实现一下
hashmap的结构特别像一个珠帘。同样下标的数据将会放在一串珠子上。 



public class LRUCache {
	class Node {
		int key;
		int value;
		Node next;
		Node pre;

		Node(int key, int value) {
			this.key = key;
			this.value = value;
		}
	}

	class Map {
		int key;
		Node value;
		Map next;

		Map(int key, Node value) {
			this.key = key;
			this.value = value;
		}

		Map(int key, Node value, Map next) {
			this.key = key;
			this.value = value;
			this.next = next;
		}
	}

	Map[] mymap;

	int capacity = 0;
	Node head = new Node(-1, -1);
	Node tail;
	int size = 0;
	int Mapsize = 1;

	public LRUCache(int capacity) {
		this.capacity = capacity;

		while (Mapsize < capacity) {
			Mapsize = Mapsize << 1;
		}
		mymap = new Map[Mapsize];
	}

	public int get(int key) {
		int index = key & Mapsize - 1;
		for (Map e = mymap[index]; e != null; e = e.next) {
			if (e.key == key) {
				removeNode(e.value);
				Node temp = new Node(key, e.value.value);
				addNodetoTail(temp);
				e.value = temp;
				return e.value.value;
			}
		}
		return -1;

	}

	public void set(int key, int value) {
		Node temp = new Node(key, value);
		int index = key & Mapsize - 1;
		Map e = mymap[index];
		for (; e != null; e = e.next) {
			if (e.key == key) {
				removeNode(e.value);
				e.value = temp;
				addNodetoTail(temp);
				return;
			}
		}
		Map next = mymap[index];
		mymap[index] = new Map(key, temp, next);
		if (size == capacity) {
			removeHead();
		}
		size++;
		addNodetoTail(temp);

	}

	private void removeHead() {
		// TODO Auto-generated method stub

		int index = head.key & Mapsize - 1;
		Map prev = mymap[index];
		Map e = prev;
		while (e != null) {
			Map next = e.next;
			if (e.value.key == head.key) {
				if (prev == e)
					mymap[index] = next;
				else
					prev.next = next;
			}
			prev = e;
			e = next;
		}
		if (size > 1) {
			head = head.next;
			head.pre = null;
		} else {
			head = null;
		}
		size--;
	}

	private void removeNode(Node temp) {
		// TODO Auto-generated method stub
		if (size > 1) {
			if (temp.pre != null) {// 证明是head结点
				temp.pre.next = temp.next;
			} else {
				head = head.next;
				head.pre = null;
			}
			if (temp.next != null)// 证明tail结点
			{
				temp.next.pre = temp.pre;
			} else {
				tail = tail.pre;
				tail.next = null;
			}
		} else {
			tail = null;
		}

	}

	private void addNodetoTail(Node node) {
		// TODO Auto-generated method stub
		if (tail == null) {
			head = node;
			tail = node;
			head.next = tail;
			tail.pre = head;
			head.pre = null;
			tail.next = null;
		} else {
			tail.next = node;
			node.pre = tail;
			node.next = null;
			tail = node;

		}
	}

	public static void main(String[] args) {
		LRUCache lru = new LRUCache(2);
		lru.set(1, 1);
		lru.set(2, 1);
		get(lru, 4);
		lru.set(4, 1);
		get(lru, 1);
		get(lru, 2);
		//
		// for (int i = 0; i < 4; i++) {
		// get(lru, i);
		//
		// }

		// // get(lru, 5);
		// // get(lru, 9);
		// lru.set(8, 4);
		// // get(lru, 7);
		// lru.set(8, 5);
		// get(lru, 3);
		// lru.set(80, 5);
		// lru.set(10, 5);
		// lru.set(11, 5);
		// lru.set(1123, 5);
		// lru.set(10, 5);
		// get(lru, 8);
		// get(lru, 10);
		// get(lru, 113);
		// get(lru, 11);
		System.out.println("---------------------------------------------");
		while (lru.head != null) {
			System.out.println(lru.head.key + "value" + lru.head.value);
			lru.head = lru.head.next;

		}
		System.out.println("---------------------------------------------"
				+ lru.size);
		while (lru.tail != null) {
			System.out.println(lru.tail.key + "value" + lru.tail.value);
			lru.tail = lru.tail.pre;
		}
		// [set(2,1),get(2),set(3,2),get(2),get(3)]
		// Output: [1,1,-1]
		// Expected: [1,-1,1]
		// set(2,1),set(1,1),get(2),set(4,1),get(1),get(2)
		// System.out.println(8 & 15);
	}

	private static void get(LRUCache lru, int key) {
		System.out.println(lru.get(key) + "key=" + key);
	}
}

高度参考 Hashmap的源代码，然后进行部分重现，对于Java 8的hashmap有时间将继续实现，Java 8在进行hashmap的实现时，如果 hash碰撞非常多将自动转换成treemap

主要实现难点及技巧： 
int capacity = 0;
	Node head = new Node(-1, -1);
	Node tail;
	int size = 0;
	int Mapsize = 1;

	public LRUCache(int capacity) {
		this.capacity = capacity;

		while (Mapsize < capacity) {
			Mapsize = Mapsize << 1;
		}
		mymap = new Map[Mapsize];
	}
在初始化的时候找到大于设置容量的最小的2的n次方。
用途：用于之后各种的计算下标，如想找到第5个数时，5&Mapsize-1。比如说Mapsize此时是16，那么就是5&15=5，101&1111=101=5.很神奇的地方是当下标大于size时，比如说16&15将等于0，也就是达到了循环赋值的目的。 



public void set(int key, int value) {
		Node temp = new Node(key, value);
		int index = key & Mapsize - 1;
		Map e = mymap[index];
		for (; e != null; e = e.next) {
			if (e.key == key) {
				removeNode(e.value);
				e.value = temp;
				addNodetoTail(temp);
				return;
			}
		}
		Map next = mymap[index];
		mymap[index] = new Map(key, temp, next);
		if (size == capacity) {
			removeHead();
		}
		size++;
		addNodetoTail(temp);

	}
set方法也是调试了许久，苦于java不支持指针所以要在map里加一个构造函数，    Map(int key, Node value, Map next),将新加入的结点到在链表头。 

private void removeHead() {
		// TODO Auto-generated method stub

		int index = head.key & Mapsize - 1;
		Map prev = mymap[index];
		Map e = prev;
		while (e != null) {
			Map next = e.next;
			if (e.value.key == head.key) {
				if (prev == e)
					mymap[index] = next;
				else
					prev.next = next;
			}
			prev = e;
			e = next;
		}
		if (size > 1) {
			head = head.next;
			head.pre = null;
		} else {
			head = null;
		}
		size--;
	}
删除头指针，关键代码在于 
                Map prev = mymap[index];
		Map e = prev;
		while (e != null) {
			Map next = e.next;
			if (e.value.key == head.key) {
				if (prev == e)
					mymap[index] = next;
				else
					prev.next = next;
			}
			prev = e;
			e = next;
		}

两个变量prev 和next 分别用于存储要删除结点的前一个和后一个结点，当找到要删除的结点e时，只需要将prev=next即可。
if (prev == e)是用来判断第一次循环时也就是mymap[index]的本身是不是要删除的那个结点，是的话直接等于下一个就好。

这次的运行效率自然应比上一个高了。





为了再次优化将构造函数变为 
while (Mapsize < capacity*2) {
			Mapsize = Mapsize << 1;
		}

以减少hash碰撞。




























Winney_x
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Leetcode: LRU Cache
ZkvIA的博客
11-11 1万+
Design and implement a data structure for Least Recently Used (LRU) cache. It should support the following operations: get and set. get(key) - Get the value (will always be positive) of the key if
LeetCode 146 LRU Cache的实现 Pyhton3
12-22
Design and implement a data structure for Least Recently Used (LRU) cache. It should support the following operations: get and put. get(key) – Get the value (will always be positive) of the key if ...
LRU Cache -- LeetCode
编程语言小筑
03-19 184
原题链接:http://oj.leetcode.com/problems/lru-cache/这是一道非常综合的题目，主要应用在操作系统的资源管理中。按照题目要求，要实现get和set功能，为了满足随机存储的需求我们首先想到的一般是用数组，如果用链表会有O(n)的访问时间。然而他又有另一个条件就是要维护least used的队列，也就是说经常用的放在前面，用的少的放在后面。这样当资源超过cache...
LRU Cache(LeetCode)
kyoto_hu的专栏
07-25 541
题目： 思路： zh
LeetCode - LRU Cache
weixin_45566492的博客
08-02 102
01.08.2021 小白一枚，文章仅当日记本记录学习进度 ;) 如被浏览，请多多指教，非常感谢大家纠错与建议！ （因留学顺便练习英语，所以部分用英文笔记，并无他意） cache : inmemory that holds the most recent result; LRU is a common cache algorithm 1. When you see put and get, you shold think of Hashmap immediately which hasi...
LeetCode:LRU Cache
whu_sky的AC之路
03-27 914
这题我个人感觉非常经典，虽然我们再操作系统上学过FIFO，random，LRU等好几种替换算法，但是实际上我们只是知道它的原理，却不知道怎么实现。我以前一直以为这种Cache是很难实现的一个东西，没想到看了两三个小时就可以做出来了，其实过程还是很简单的，一步一步来就好了。 先说LRU的原理，LRU是Least Recently Used 近期最少使用算法。 内存管理的一种页面置换算法，对于
lrucacheleetcode-Leetcode-LRU-cache:146.LRU缓存
06-29
Leetcode-LRU-cache LRU缓存 设计和实现最近最少使用 (LRU) 缓存的数据结构。 它应该支持以下操作：get 和 put。 get(key) - 如果键存在于缓存中，则获取键的值（将始终为正），否则返回 -1。 put(key, value) - ...
lrucacheleetcode-leetcode-LRU-Cache:我的leetcodeLRU缓存问题的解决方案
06-29
lru缓存leetcode 问题描述 设计一个遵循最近最少使用 (LRU) 缓存约束的数据结构。 实现 LRUCache 类： LRUCache(int capacity)使用正大小容量初始化 LRU 缓存。 int get(int key)如果键存在则返回键的值，否则返回-1...
lrucacheleetcode-LeetCode_LRU_Cache:使用包含双向链表的字典构建的最近最少使用的缓存
06-29
LeetCode_LRU_Cache 问题： 最近最少使用的缓存 目标是设计一种称为最近最少使用 (LRU) 缓存的数据结构。 LRU 缓存是一种缓存类型，当缓存内存达到其限制时，我们会删除最近最少使用的条目。 对于当前问题，将 get ...
js-leetcode题解之LRU缓存-题解.zip
最新发布
05-09
在LeetCode这个在线编程挑战平台上，有一道关于实现LRU缓存的题目，而“js_leetcode题解之LRU缓存_题解.zip”文件正是针对这道题目的JavaScript解法。 LRU缓存的主要思想是：当缓存满时，优先淘汰最近最少使用的...
javalruleetcode-LRU_cache:LRU_cache
06-29
java lru leetcode LRU_cache (Leetcode 146) 设计和实现最近最少使用 (LRU) 缓存的数据结构。 它应该支持以下操作：get 和 set。 get(key) – 如果键存在于缓存中，则获取键的值（将始终为正），否则返回 -1。 set(key, value) – 如果键不存在，则设置或插入值。 当缓存达到其容量时，它应该在插入新项目之前使最近最少使用的项目无效。 跟进：你能在 O(1) 时间复杂度内完成这两个操作吗？ 分析 LRU 缓存是将最近使用的项目保留在缓存中，并在缓存达到其容量时丢弃最近最少使用的项目。 因此，应按缓存中的“已用时间”按顺序保存项目。 我们需要跟踪每个项目的使用时间。 当我们调用 get(key) 函数时，除了返回它的值之外，我们还需要将其使用时间更新为最近的。 当我们调用 set(key, value) 函数时，我们也需要更新它的使用时间。 我们可以使用由双链表实现的 Queue 来保存项目。 Queue 中的顺序代表“使用时间”的顺序。 例如，头部表示最近使用的项目，尾部表示最近最少使用的项目。 我们执行“删除”和“
LRU Cache---Leetcode146
yanglj的博客
11-22 267
问题描述 Design and implement a data structure for Least Recently Used (LRU) cache. It should support the following operations: get and put. get(key) - Get the value (will always be positive) of the key i...
leetcode | LRU Cache
quinn的专栏
06-13 657
LRU Cache : https://leetcode.com/problems/lru-cache/ Degree： hardDesign and implement a data structure for Least Recently Used (LRU) cache. It should support the following operations: get and set.get
LRU Cache算法实现（leetcode）
jiangbo1017的专栏
03-28 798
题意实现一个LRU cache类，使得在我们需要获取一个key的值时，如果cache中有，那么直接返回值，否则就返回-1；同时我们还可以设置一个cache的值，这个主要是在我们出现cache miss的时候，我们需要替换其中的项或者需要从主存中载入对应的项。思路LRU，最近最少使用，也就说在出现cache满的时候，替换原则就是替换最近最少使用的项。类中必须体现出这个原则，那么我们应该如何来做呢？首先
LeetCode 146. LRU Cache（LRU缓存）
James Pan
05-26 818
原题网址：https://leetcode.com/problems/lru-cache/ Design and implement a data structure for Least Recently Used (LRU) cache. It should support the following operations: get and set. get(key) - Get
Leetcode 146.LRU缓存机制（LRU Cache）
qq_39378221的博客
05-25 136
Leetcode 146.LRU缓存机制 1 题目描述（Leetcode题目链接）   运用你所掌握的数据结构，设计和实现一个 LRU (最近最少使用) 缓存机制。它应该支持以下操作： 获取数据 get 和 写入数据 put 。 获取数据 get(key) - 如果密钥 (key) 存在于缓存中，则获取密钥的值（总是正数），否则返回 -1。 写入数据 put(key, value) - 如果密钥已经存在，则变更其数据值；如果密钥不存在，则插入该组「密钥/数据值」。当缓存容量达到上限时，它应该在写入新数据之
LeetCode || LRU Cache
布衣不舍的专栏
06-24 3196
Design and implement a data structure for Least Recently Used (LRU) cache. It should support the following operations: get and set. get(key) - Get the value (will always be positive) of the key if
leetcode 146. LRU Cache
蓝羽飞鸟的博客
01-18 145
Implement the LRUCache class: LRUCache(int capacity) Initialize the LRU cache with positive size capacity. int get(int key) Return the value of the key if the key exists, otherwise return -1. void put(int key, int value) Update the value of the key if the
LeetCode LRU Cache(最近最少使用缓存)
多看多听多总结
04-04 327
问题：设计一个最近最少使用缓存。支持get和put操作 1、如果get(key)中，key在缓存中不存在，返回-1 2、put(key,value),如果key在缓存中不存在，则插入。当缓存到达容量时，需要删除最近最小使用项 要求时间复杂度为O(1) 思路：使用LinkedHashMap，实现类继承它。设置accessOrder为true,当get时，调整对应项位置，同时重写removeE...
LeetCode 精选 TOP 面试题（4）1
08-04
1. 第一次，将整个区间分成连续的若干段，每段长度是2： 2. 第二次，将整个区间分成连续的若干段，每段长度是4： 3. 依此类推，直到每段小区间的长度大于等于

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值