【146】LRU缓存机制

运用你所掌握的数据结构，设计和实现一个  LRU (最近最少使用) 缓存机制 。
实现 LRUCache 类：

LRUCache(int capacity) 以正整数作为容量 capacity 初始化 LRU 缓存
int get(int key) 如果关键字 key 存在于缓存中，则返回关键字的值，否则返回 -1 。
void put(int key, int value) 如果关键字已经存在，则变更其数据值；如果关键字不存在，则插入该组「关键字-值」。当缓存容量达到上限时，它应该在写入新数据之前删除最久未使用的数据值，从而为新的数据值留出空间。
 

进阶：你是否可以在 O(1) 时间复杂度内完成这两种操作？

 

示例：

输入
["LRUCache", "put", "put", "get", "put", "get", "put", "get", "get", "get"]
[[2], [1, 1], [2, 2], [1], [3, 3], [2], [4, 4], [1], [3], [4]]
输出
[null, null, null, 1, null, -1, null, -1, 3, 4]

解释
LRUCache lRUCache = new LRUCache(2);
lRUCache.put(1, 1); // 缓存是 {1=1}
lRUCache.put(2, 2); // 缓存是 {1=1, 2=2}
lRUCache.get(1);    // 返回 1
lRUCache.put(3, 3); // 该操作会使得关键字 2 作废，缓存是 {1=1, 3=3}
lRUCache.get(2);    // 返回 -1 (未找到)
lRUCache.put(4, 4); // 该操作会使得关键字 1 作废，缓存是 {4=4, 3=3}
lRUCache.get(1);    // 返回 -1 (未找到)
lRUCache.get(3);    // 返回 3
lRUCache.get(4);    // 返回 4

 思考：关键是处理好插入操作，当插入后保证已有的数据有序，当已有数据达到capacity后，我们选择最久没有“使用”过得数字删除。由于数据保存是使用key value形式的，也就是用字典保存，如何保证字典有序，用链表保存顺序信息。python里面是没有链表的。通过手动实现一个双向链表进行保存。（方法2）或者使用直接使用collections.OrderDict(方法1)。

方法一：

from collections import OrderedDict
class LRUCache(object):

    def __init__(self, capacity):
        """
        :type capacity: int
        """
        self.capacity = capacity
        
        self.orderdict = OrderedDict()
        


    def get(self, key):
        """
        :type key: int
        :rtype: int
        """
        if key not in self.orderdict:return -1
        res = self.orderdict[key]
        self.orderdict.pop(key)
        self.orderdict[key] = res
        return res


    def put(self, key, value):
        """
        :type key: int
        :type value: int
        :rtype: None
        """
        if key in self.orderdict:self.orderdict.pop(key)
        if len(self.orderdict)==self.capacity:
            self.orderdict.popitem(False)        
        self.orderdict[key] = value        



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

注：关于collection.OrderedDict链表字典的使用：

保证插入的数据有序，同时可以弹出头部和尾部元素。

from collections import OrderedDict

a = OrderedDict()
a['a'] = 1
a['b'] = 2
a['c'] = 3
a.popitem(False)# 弹出最早插入的元素 OrderedDict([('b', 2), ('c', 3)])
a.popitem()# 弹出最早插入的元素 OrderedDict([('a', 1), ('b', 2)])

#######################
######################popitem()实现源码##########
    def popitem(self, last=True):
        '''od.popitem() -> (k, v), return and remove a (key, value) pair.
        Pairs are returned in LIFO order if last is true or FIFO order if false.

        '''
        if not self:
            raise KeyError('dictionary is empty')
        key = next(reversed(self) if last else iter(self))
        value = self.pop(key)
        return key, value

 

方法二：

对于保证有序的问题，可以手动实现一个双向链表。get() put()操作后都将访问的元素放在链表的头部，用链表的操作是这里有很多插入删除操作，数组需要多次搬移。同时维护一个字典，保存key-node形式。node为链表中的节点。

为了更快找到头、尾。链表的头和尾单独保存。例如移动到头部可以立刻找到位置，删除尾部元素也可以o(1)找到。

class NodeList(object):
    def __init__(self,key=0,val=0):
        self.key = key
        self.val = val
        self.pre = None
        self.next = None

class LRUCache(object):    

    def __init__(self, capacity):
        """
        :type capacity: int
        """
        self.cache = {}
        self.capacity = capacity
        self.size = 0
        self.head = NodeList()
        self.tail = NodeList()
        self.head.next = self.tail
        self.tail.pre = self.head



    def get(self, key):
        """
        :type key: int
        :rtype: int
        """
        if key not in self.cache:
            return -1
        self.moveTohead(self.cache[key])
        return self.cache[key].val


    def put(self, key, value):
        """
        :type key: int
        :type value: int
        :rtype: None
        """
        if key not in self.cache:
            node = NodeList(key,value)
            self.addTohead(node)
            self.cache[key] = node
            self.size+=1
            if self.size>self.capacity:
                node = self.removeTail()
                self.cache.pop(node.key)
                self.size-=1
        else:
            oldnode = self.cache[key]             
            oldnode.val = value
            self.moveTohead(oldnode)
            
    
    def removeNode(self,node):
        node.pre.next = node.next
        node.next.pre = node.pre

    
    def addTohead(self,node):
        node.pre = self.head
        node.next = self.head.next
        self.head.next.pre = node
        self.head.next = node        

    def moveTohead(self,node):
        self.removeNode(node)
        self.addTohead(node)
    
    def removeTail(self):
        node = self.tail.pre
        self.removeNode(node)
        return node
        
        




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