python--lintcode134. LRU缓存策略

描述

为最近最少使用（LRU）缓存策略设计一个数据结构，它应该支持以下操作：获取数据（get）和写入数据（set）。

获取数据get(key)：如果缓存中存在key，则获取其数据值（通常是正数），否则返回-1。

写入数据set(key, value)：如果key还没有在缓存中，则写入其数据值。当缓存达到上限，它应该在写入新数据之前删除最近最少使用的数据用来腾出空闲位置。

哇困难级别的一题，相当有意思。

我举个例子先，假设你的缓存有3的大小，然后数据慢慢进来。

1进入，缓存变成：1

2进入，缓存变成：1->2

3进入，变成：1->2->3

4进入，因为1是最久的数据了，所以缓存变成：2->3->4

3进入，因为缓存里已经有3，所以把3的优先级提到最高，变成：2->4->3

那总而言之一句话，就是我们的数据结构要有把任何一个结点删除的能力，并且要有新加到链表尾的能力。同时在判断缓存中是否有此元素的时候，用hashmap解决。但是要注意的是，因为需要删除结点的能力，所有这个hashmap的key是指向链表中的前一个结点。

具体可看注释：

class LinkedNode:

    def __init__(self, key=None, value=None, next=None):
        self.key = key
        self.value = value
        self.next = next


class LRUCache:

    #hash表里存的是前一个结点
    #比如如果链表是1->2->3
    #那么哈希表里hash[2]=1
    # @param capacity, an integer
    def __init__(self, capacity):
        self.hash = {}
        self.head = LinkedNode()
        self.tail = self.head
        self.capacity = capacity

    # 在链表尾插入（链表尾的元素为最近使用的）
    def push_back(self, node):
        self.hash[node.key] = self.tail
        self.tail.next = node
        self.tail = node

    # 在链表头删除
    def pop_front(self):
        del self.hash[self.head.next.key]
        self.head.next = self.head.next.next
        self.hash[self.head.next.key] = self.head

    # change "prev->node->next...->tail"
    # to "prev->next->...->tail->node"
    def kick(self, prev):
        node = prev.next
        if node == self.tail:
            return
        prev.next = node.next
        if node.next is not None:
            self.hash[node.next.key] = prev
            node.next = None
        self.push_back(node)

    # @return an integer
    def get(self, key):
        if key not in self.hash:
            return -1
        self.kick(self.hash[key])
        #因为hash[key]指向该结点的前一个结点，所以需要加上.next
        return self.hash[key].next.value

    # @param key, an integer
    # @param value, an integer
    # @return nothing
    def set(self, key, value):
        # 若缓存中有这个数据了，则将它优先级提到最高（删除后加到链表尾）
        if key in self.hash:
            self.kick(self.hash[key])
            self.hash[key].next.value = value
        # 若缓存中没这个数据，加到链表尾
        else:
            self.push_back(LinkedNode(key, value))
            if len(self.hash) > self.capacity:
                self.pop_front()