LRU简单实现

<pre name="code" class="java">import java.util.HashMap;
import java.util.Map;

public class LRUCache {
	private int capacity;
	private int len;

	class Data {
		int key;
		int value;
		Data next;
		Data pre;
	}

	private Map<Integer, Data> dataSet;

	private Data head;
	private Data rail;

	public LRUCache(int capacity) {
		this.capacity = capacity;
		this.len = 0;
		this.head = null;
		this.rail = null;
		this.dataSet = new HashMap<Integer, Data>();
	}

	public int get(int key) {
		if (!dataSet.containsKey(key))
			return -1;
		Data temp = dataSet.get(key);
		if (temp == head) {
			return temp.value;
		} else if (temp == rail) {
			temp.pre.next = null;
			rail = temp.pre;
		} else {
			temp.pre.next = temp.next;
			temp.next.pre = temp.pre;
		}
		temp.next = head;
		temp.pre = null;
		head.pre = temp;
		head = temp;
		return temp.value;

	}

	public void set(int key, int value) {
		if (capacity == 0)
			return;
		if (dataSet.containsKey(key)) {
			Data temp = dataSet.get(key);
			if (temp == head) {
				temp.value = value;
				dataSet.put(key, head);
				return;
			} else if (temp == rail) {
				temp.pre.next = null;
				rail = temp.pre;
			} else {
				temp.pre.next = temp.next;
				temp.next.pre = temp.pre;
			}
			temp.value = value;
			temp.next = head;
			temp.pre = null;
			head.pre = temp;
			head = temp;
			dataSet.put(key, head);
		} else {
			if (len == capacity) {
				dataSet.remove(rail.key);
				if (rail == head)
					head = null;
				else {
					rail.pre.next = null;
					rail = rail.pre;
				}
				len--;
			}

			if (head == null) {
				head = new Data();
				head.key = key;
				head.value = value;
				head.next = null;
				head.pre = null;
				dataSet.put(key, head);
				rail = head;
				len++;
			} else {
				Data temp = new Data();
				temp.key = key;
				temp.value = value;
				temp.next = head;
				temp.pre = null;
				head.pre = temp;
				head = temp;
				dataSet.put(key, head);
				len++;
			}

		}

	}

	public static void main(String args[]) {
		LRUCache l = new LRUCache(2);
		l.set(2, 1);
		l.set(1, 1);
		l.set(2, 3);
		l.set(4, 1);
		System.out.println(l.get(1));
		System.out.println(l.get(2));

	}

}
				
时间: 2024-10-27 10:14:54

LRU简单实现的相关文章

LRU Cache的简单实现

Cache这个东西可以说无处不在,处理器中的TLB,Linux系统中的高速页缓存,还有很多人熟知的开源软件memcached,都是cache的一种实现.LRU是Least Recently Used的缩写,即最近最少使用,是常用cache算法中的一种.因为cache的存储空间相对于后端存储来说更有限,将cache空间和后端存储空间映射后,还需要一些算法来解决cache满的问题并保证效率,LRU就是在cache满了以后,将最近最少访问到的内容移除,然后将新的内容放入cache,新的内容也成为了最近

简单LRU cache 实现

起因:我的同事需要一个固定大小的cache,如果记录在cache中,直接从cache中读取,否则从数据库中读取.python的dict 是一个非常简单的cache,但是由于数据量很大,内存很可能增长的过大,因此需要限定记录数,并用LRU算法丢弃旧记录.key 是整型,value是10KB左右的python对象 分析: 1)可以想到,在对于cache,我们需要维护 key -> value 的关系 2)而为了实现LRU,我们又需要一个基于时间的优先级队列,来维护   timestamp  ->

LRU的C++的简单实现

class LRUCache提供两个接口:get(int key)和set(int key,value) #include<iostream> using namespace std; class LRUCache{ public:     LRUCache(int cap):current(0),capacity(cap){         A=new node[cap];     }     int get(int key) {         for(int i=0;i<curre

LRU 缓存机制及 3 种简单实现

之前好几次接触到 LRU(Least Recently Used)算法,今天来总结下,并用 Java 和 Python 给出相应的实现. LRU是一种缓存替换算法,根据字面意思,就是将最近最少使用的页面或者元素进行替换,将最近最多使用的页面或者元素保持在缓存里.有关缓存的知识后面再仔细研究下.由于缓存的容量大小有限,这才有了LRU之类的缓存算法.还有一些其他的缓存算法,可以参考这个页面. 根据下面的图示进行LRU算法的理解. 其中 put 操作用于将最近使用的元素放置在缓存中,get 操作用于获

LRU算法简单实现

package two; import java.util.Scanner; public class LRU { public static void main(String[] args) { int l=0; Integer []now=new Integer[5]; // System.out.print(now[2]); System.out.println("输入多少个数值:"); Scanner in=new Scanner(System.in); int count=i

java基于Hash表和双向链表简单实现LRU Cache

package lru; import java.util.HashMap; public class LRUCache2<K,V> { public final int capacity; class DNode{ K key; V value; DNode next; DNode pre; public DNode(K key, V value, LRUCache2<K, V>.DNode pre, LRUCache2<K, V>.DNode next) { sup

基于LRU Cache的简单缓存

package com.test.testCache; import java.util.Map; import org.json.JSONArray; import org.json.JSONException; import android.content.Context; import android.content.SharedPreferences; import android.content.SharedPreferences.Editor; import android.text

简单LRU算法实现缓存大小的限制策略

参考:Android-Universal-Image-Loader private final Map<File, Long> mLastUsageDates = Collections.synchronizedMap(new HashMap<File, Long>()); private final AtomicInteger mCacheSize; private final int SIZE_LIMIT = 10 * 1024 * 1024; { mCacheSize = n

LRU 缓冲池 (不考虑多线程)

lru:(转)LRU算法的实现 什么是LRU算法? LRU是Least Recently Used的缩写,即最近最少使用页面置换算法,是为虚拟页式存储管理服务的.关于操作系统的内存管理,如何节省利用容量不大的内存为最多的进程提供资源,一直是研究的重要方向.而内存的虚拟存储管理,是现在最通用,最成功的方式——在内存有限的情况下,扩展一部分外存作为虚拟内存,真正的内存只存储当前运行时所用得到信息.这无疑极大地扩充了内存的功能,极大地提高了计算机的并发度.虚拟页式存储管理,则是将进程所需空间划分为多个