146. LRU缓存机制

题目：
运用你所掌握的数据结构，设计和实现一个 LRU (最近最少使用) 缓存机制。它应该支持以下操作： 获取数据 get 和 写入数据 put 。
获取数据 get(key) - 如果密钥 (key) 存在于缓存中，则获取密钥的值（总是正数），否则返回 -1。
写入数据 put(key, value) - 如果密钥不存在，则写入其数据值。当缓存容量达到上限时，它应该在写入新数据之前删除最近最少使用的数据值，从而为新的数据值留出空间。

要求：
在 O(1) 时间复杂度内完成这两种操作。

题解：
本题需要采用python中的有序字典OrderedDict
from collections import OrderedDict
该方法综合了哈希表和链表，代码如下：

from collections import OrderedDict
class LRUCache(OrderedDict):

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

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

    def put(self, key, value):
        """
        :type key: int
        :type value: int
        :rtype: void
        """
        if key in self:
            self.move_to_end(key)
        self[key] = value
        if len(self) > self.capacity:
            self.popitem(last = False)

# LRUCache 对象会以如下语句构造和调用:
# obj = LRUCache(capacity)
# param_1 = obj.get(key)
# obj.put(key,value)

作者：LeetCode
链接：https://leetcode-cn.com/problems/lru-cache/solution/lru-huan-cun-ji-zhi-by-leetcode/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

然后题解中给出了第二种方法：哈希表+双向链表
我觉得其实就是OrderedDict的内部逻辑实现
看完题解后参照这个思路自己写了一遍交了
强烈建议自己实现一遍哈希表+双向链表，会对OrderedDict有更深的理解

#!/usr/bin/env python3.6
# _*_coding:utf-8 _*_
# @Time   : 2019/10/30 13:13
# @Author : Grey

class DLinkedNode():
    def __init__(self):
        self.key = 0
        self.value = 0
        self.prev = None
        self.next = None

class LRUCache:
    def add_node(self, node):
        node.next = self.head.next
        node.prev = self.head

        self.head.next.prev = node
        self.head.next = node

    def remove_node(self, node):
        prev = node.prev
        next = node.next

        prev.next = next
        next.prev = prev

    def move_to_head(self, node):
        self.remove_node(node)
        self.add_node(node)

    def pop_tail(self):
        prev = self.tail.prev
        self.remove_node(prev)

    def __init__(self, capacity: int):
        self.capacity = capacity
        self.dic = {}
        self.size = 0
        self.head = DLinkedNode()
        self.tail = DLinkedNode()
        self.head.next = self.tail
        self.tail.prev = self.head

    def get(self, key: int) -> int:
        node = self.dic.get(key, None)
        if node == None:
            return -1
        else:
            self.move_to_head(node)
            return node.value

    def put(self, key: int, value: int) -> None:
        if key not in self.dic.keys():
            node = DLinkedNode()
            node.key = key
            node.value = value
            self.dic[key] = node
            if self.size == self.capacity:
                del self.dic[self.tail.prev.key]
                self.pop_tail()
                self.size = self.size - 1
            self.add_node(node)
            self.size = self.size + 1
        else:
            self.dic[key].value = value
            self.move_to_head(self.dic[key])


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