leetcode146.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

思路：

1.链表和哈希表，要对数据进行多次的插入和删除，所以选择链表结构优于选择顺序存储，还需要在O(1)的时间复杂度实现对数据的读取，所以选择使用哈希表建立映射关系，关键字作为字典的键，存放关键字和对应值的节点作为字典的值。
2.双向链表，想要通过把使用过的节点放在链表头的方式，来表示数据的使用情况，那用过的数据就需要移动到链表头，如果使用单链表，只能找到后继，找不到前驱，要移动这个节点就得先遍历到这个节点，不满足要求的时间复杂度，所以考虑使用双向链表，每个节点中存放了节点的值和前驱指针以及后继指针。
3.节点中要存放键key，因为当链表长度达到要求的长度时，要删除链表尾的节点，还要删除字典中对应的键值对，这一具体过程需要先移除节点，然后通过节点的key找到字典中对应的键值对，把它删除，最后链表长度减1。
4.代码具体实现

先定义一个双向链表，加了虚拟头节点和尾节点，这样在链表头添加元素和在链表尾删除元素时，方便了操作，然后实现这一缓存机制的初始化和get(),put()操作，最后一一实现这两个操作中用到的链表操作，包括删除链表尾节点，移除节点，将节点加在链表头，将节点移动到链表头。

class DlinkedNode():
    def __init__(self,key = 0,value = 0):
        self.key = key
        self.value = value
        self.prev = None
        self.next = None
# 定义双向链表的过程
class LRUCache(object):
    def __init__(self, capacity):
        """
        :type capacity: int
        """
        self.cache = dict()
        self.dummyhead = DlinkedNode()
        self.dummytail = DlinkedNode()
        self.dummyhead.next = self.dummytail
        self.dummytail.prev = self.dummyhead
        self.capacity = capacity #最大长度
        self.size = 0 # 用来计算长度
    def get(self, key):
        """
        :type key: int
        :rtype: int
        """
        if key not in self.cache:
            return -1
        node = self.cache[key]
        self.movetohead(node) # 移动到最前面表示刚使用过
        return node.value
    def put(self, key, value):
        """
        :type key: int
        :type value: int
        :rtype: None
        """
        if key not in self.cache:
            node = DlinkedNode(key,value)
            self.cache[key] = node # 注意这里键对应节点
            self.addtohead(node) #新加入的放在链表头
            self.size += 1
            if self.size > self.capacity:
                rnode = self.removetail() # 移动链尾元素
                self.cache.pop(rnode.key) # 哈希表中也删除该元素,通过键读取到
                self.size -= 1
        else:
            node = self.cache[key]
            node.value = value
            self.movetohead(node) #使用过就放在最前面
    # 几个函数实现
    def removetail(self):
        node = self.dummytail.prev
        self.removenode(node)
        return node 
    def removenode(self,node):
        node.prev.next = node.next
        node.next.prev = node.prev
    def addtohead(self,node):
        node.next =self.dummyhead.next
        self.dummyhead.next.prev = node
        node.prev = self.dummyhead
        self.dummyhead.next = node
    def movetohead(self,node):
        self.removenode(node)
        self.addtohead(node)
# Your LRUCache object will be instantiated and called as such:
# obj = LRUCache(capacity)
# param_1 = obj.get(key)
# obj.put(key,value)