146.LRU缓存--hash-双链表

# 初始化双向链表
class ListNode:
    
    def __init__(self,key=None,value=None):
 
        self.key=key
        self.value=value
        self.prev=None
        self.next=None
        
 
 
class LRUCache:
 
    def __init__(self, capacity: int):
        # 初始化capacity hashmap
        self.capacity=capacity
        self.hashmap={}
        # 建立保护节点
        self.head=ListNode()
        self.tail=ListNode()
        # 初始化列表head<->tail
        self.head.next=self.tail
        self.tail.prev=self.head
    
    # 删除操作
    def Pop_node(self, node):
        
        node.prev.next = node.next
        node.next.prev=node.prev
 
    # 头插操作
    def Insert_head(self,key,value):
        # 新建节点
        node=ListNode()
        node.value=value
        node.key=key
 
        # 头插
        node.next=self.head.next
        self.head.next.prev=node
        self.head.next=node
        node.prev=self.head
        return node
 
 
        
    def get(self, key: int) -> int:
        # 如果存在列表中，就删除并移到头部,不存在返回-1
        if key not in self.hashmap: 
            return -1
            # 找到结点
        node= self.hashmap[key]
            # 删除节点
        self.Pop_node(node)
            # 移到头部
        self.Insert_head(node.key,node.value)
        return node.value
 
 
    def put(self, key: int, value: int) -> None:
 
        # 如果在列表中：删除并移到头部
        if key in self.hashmap:
            # 先找到
            node=hashmap[key]
            self.Pop_node(node)
            self.Insert_head(node.key,node.value)
        else:
 
            # 如果不在列表中：新节点添加到头部
            node=self.Insert_head(key,value)
            # 建立映射关系
            self.hashmap[key] = node
 
        # 如果空间满了，删除尾部
        if len(self.hashmap)>self.capacity:
            self.Pop_node(self.tail.prev)
 
 
 
# Your LRUCache object will be instantiated and called as such:
# obj = LRUCache(capacity)
# param_1 = obj.get(key)
# obj.put(key,value)