146. LRU 缓存机制（Medium）

• 题解
  

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):
        self.capacity = capacity
        self.hashmap = {}
        # 新建两个节点 head 和 tail
        self.head = ListNode()
        self.tail = ListNode()
        # 初始化链表为 head <-> tail
        self.head.next = self.tail
        self.tail.prev = self.head

    # 因为get与put操作都可能需要将双向链表中的某个节点移到末尾，所以定义一个方法
    def move_node_to_tail(self, key):
        # 先将哈希表key指向的节点node拎出来，并改变node前、后节点的指向
        #      hashmap[key]                               hashmap[key]
        #           |                                          |
        #           V              -->                         V
        # prev <-> node <-> next         pre <-> next   ...   node
        node = self.hashmap[key]
        node.prev.next = node.next
        node.next.prev = node.prev
        # 之后将node插入到伪尾节点前，并改变伪尾节点前、后节点的指向
        #                 hashmap[key]                 hashmap[key]
        #                      |                            |
        #                      V        -->                 V
        # prev <-> tail  ...  node                prev <-> node <-> tail
        node.prev = self.tail.prev
        node.next = self.tail
        self.tail.prev.next = node
        self.tail.prev = node

    def get(self, key: int) -> int:
    	# 如果已经在链表中了就把它移到末尾（变成最新访问的）
        if key in self.hashmap:
            self.move_node_to_tail(key)
            
        res = self.hashmap.get(key, -1)
        # 若未查询到返回-1，否则返回查询到的值
        return res.value if res != -1 else -1

    def put(self, key: int, value: int) -> None:
    	# 如果key本身已经在哈希表中了就不需要在链表中加入新的节点
        if key in self.hashmap:
            # 但是需要更新字典该值对应节点的value
            self.hashmap[key].value = value
            # 之后将该节点移到末尾
            self.move_node_to_tail(key)
        # 如果key不在哈希表中，则需要在链表中加入新的节点
        else:
        	# 是否达到最大容量？
            if len(self.hashmap) == self.capacity:
                # 去掉最久没有被访问过的节点，即头节点之后的节点
                self.hashmap.pop(self.head.next.key)
                # 改变相应的指向
                self.head.next = self.head.next.next
                self.head.next.prev = self.head
                
            # 如果不在的话就插入到尾节点前
            new = ListNode(key, value)
            self.hashmap[key] = new
            new.prev = self.tail.prev
            new.next = self.tail
            self.tail.prev.next = new
            self.tail.prev = new

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


class LRUCache:
    
    def __init__(self, capacity: int):
        self.cache = dict()
        # 使用伪头部和伪尾部节点    
        self.head = DLinkedNode()
        self.tail = DLinkedNode()
        self.head.next = self.tail
        self.tail.prev = self.head
        self.capacity = capacity
        self.size = 0

    def get(self, key: int) -> int:
        if key not in self.cache:
            return -1
        # 如果 key 存在，先通过哈希表定位，再移到头部
        node = self.cache[key]
        self.moveToHead(node)
        return node.value

    def put(self, key: int, value: int) -> None:
        if key not in self.cache:
            # 如果 key 不存在，创建一个新的节点
            node = DLinkedNode(key, value)
            # 添加进哈希表
            self.cache[key] = node
            # 添加至双向链表的头部
            self.addToHead(node)
            self.size += 1
            if self.size > self.capacity:
                # 如果超出容量，删除双向链表的尾部节点
                removed = self.removeTail()
                # 删除哈希表中对应的项
                self.cache.pop(removed.key)
                self.size -= 1
        else:
            # 如果 key 存在，先通过哈希表定位，再修改 value，并移到头部
            node = self.cache[key]
            node.value = value
            self.moveToHead(node)
    
    def addToHead(self, node):
        node.prev = self.head
        node.next = self.head.next
        self.head.next.prev = node
        self.head.next = node
    
    def removeNode(self, node):
        node.prev.next = node.next
        node.next.prev = node.prev

    def moveToHead(self, node):
        self.removeNode(node)
        self.addToHead(node)

    def removeTail(self):
        node = self.tail.prev
        self.removeNode(node)
        return node

牛客

题目链接

# lru design
# @param operators int整型二维数组 the ops
# @param k int整型 the k
# @return int整型一维数组
#
class Solution:
    def __init__(self, k):
        self.k = k
        self.keys = []
        self.dct = {}
        
#         self.res = []
        
#     def LRU(self , operators , k ):
#         # write code here
#         for op in operators:
#             if op[0] == 1: self.set(op[1], op[2])
#             else: self.res.append(self.get(op[1]))
        
#         return self.res
    
    def gets(self, key):
        if key in self.dct:
            self.keys.remove(key) # 先remove，再append表示操作位置的更新
            self.keys.append(key)
            return self.dct[key]
        return -1
        
    def sets(self, key, v):
        if key in self.dct:
            self.keys.remove(key)
            self.keys.append(key)
        else:
            self.keys.append(key)
            self.dct[key] =  v
        if len(self.keys) > self.k:
            self.dct.pop(self.keys.pop(0)) # 删掉最远未用的（即第0个）

import sys
for line in sys.stdin.readlines():
    a = line.strip().replace(' ', '').split(']],')
    s = Solution(int(a[1]))
    
    res = []
    for item in a[0][2:].split('],['):
        m = item.split(',')
        if m[0] == '1':
            s.sets(int(m[1]), int(m[2]))
        else:
            res.append(s.gets(int(m[1])))
            
    print(str(res).replace(' ', ''))