LRU缓存--基础算法

设计和构建一个“最近最少使用”缓存，该缓存会删除最近最少使用的项目。缓存应该从键映射到值(允许你插入和检索特定键对应的值)，并在初始化时指定最大容量。当缓存被填满时，它应该删除最近最少使用的项目。

它应该支持以下操作： 获取数据 get 和 写入数据 put 。

获取数据 get(key) - 如果密钥 (key) 存在于缓存中，则获取密钥的值（总是正数），否则返回 -1。
写入数据 put(key, value) - 如果密钥不存在，则写入其数据值。当缓存容量达到上限时，它应该在写入新数据之前删除最近最少使用的数据值，从而为新的数据值留出空间。

示例:

LRUCache cache = new LRUCache( 2 /* 缓存容量 */ );

cache.put(1, 1);
cache.put(2, 2);
cache.get(1);       // 返回  1
cache.put(3, 3);    // 该操作会使得密钥 2 作废
cache.get(2);       // 返回 -1 (未找到)
cache.put(4, 4);    // 该操作会使得密钥 1 作废
cache.get(1);       // 返回 -1 (未找到)
cache.get(3);       // 返回  3
cache.get(4);       // 返回  4

来源：力扣（LeetCode）

---

代码：

# -*- coding: utf-8 -*-
"""
Created on Tue Aug  4 11:29:38 2020

@author: WowlNAN

@github: https://github.com/WowlNAN

@csdn: https://blog.csdn.net/qq_21264377

"""
import time


class LRUCache:

    def __init__(self, capacity: int):
        self.capacity=capacity
        self.cache={}
        self.access={}

    def get(self, key: int) -> int:
        if self.cache==None or self.cache=={}:
            return -1
        try:
            value=self.cache.get(key, -1)
            if value!=-1:
                self.access[key]=time.time()
            return value
        except:
            return -1

    def put(self, key: int, value: int) -> None:
        if len(self.cache)>=self.capacity:
            if self.get(key)!=-1:
                self.cache[key]=value
                self.access[key]=time.time()
            else:
                acs=self.access.items()
                last_access=None
                last_key=None
                for o in acs:
                    if last_key==None and last_access==None:
                        last_access=o[1]
                        last_key=o[0]
                    elif last_access>o[1]:
                        last_access=o[1]
                        last_key=o[0]
                del self.cache[last_key]
                del self.access[last_key]
                self.cache[key]=value
                self.access[key]=time.time()
        else:
            self.cache[key]=value
            self.access[key]=time.time()


# Your LRUCache object will be instantiated and called as such:
# obj = LRUCache(capacity)
# param_1 = obj.get(key)
# obj.put(key,value)

s=LRUCache(2)
s.put(1,1)
s.put(2,2)
print(s.get(1))
s.put(3,3)
print(s.get(2))
s.put(4,4)
print(s.get(1))
print(s.get(3))
print(s.get(4))
print(s.cache)

LRU缓存遵循“最近最少使用”的基本准则。“使用”的概念包含访问和修改等。这里直接使用时间戳来描述规则。这样的做法比较简单基础。复杂点的应该加入使用次数。进行put操作超出指定的元素长度时，时间复杂度理论是O(n)，实际是O(2n)。