设计LFU缓存结构

加上最近访问会超时，不加倒数第二个用例过不去，求大佬优化一下循环，或者加一个最近访问的标记。

#
# 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
#
# lfu design
# @param operators int整型二维数组 ops
# @param k int整型 the k
# @return int整型一维数组
#
class Solution:
    def LFU(self , operators: List[List[int]], k: int) -> List[int]:
        # write code here
        buf = []
        res = []
        for i in operators:
            if i[0] == 1:  # opt=1插入数据
                if i[1] in [j[0] for j in buf]:  # 如果插入数据在缓存里
                    for j in buf:
                        if j[0] == i[1]:  # 找到该数据
                            j[1] = i[2]  # 更新value
                            j[2] += 1  # 访问次数+1
                    # # 调整为最近访问
                    # for j in buf:
                    #     if j[0] == i[1]:
                    #         buf.remove(j)
                    #         buf.append(j)

                else:  # 插入数据不在缓存里
                    if len(buf) >= k:  # 已经存满
                        minfw = min([j[2] for j in buf])  # 找到访问次数最少的
                        for j in buf:
                            if j[2] == minfw:  # 更新插入数据
                                j[0] = i[1]  # 更新key
                                j[1] = i[2]  # 更新value
                                j[2] = 1  # 首次访问
                        # # 调整为最近访问
                        # for j in buf:
                        #     if j[0] == i[1]:
                        #         buf.remove(j)
                        #         buf.append(j)
                    else:  # 还没存满
                        buf.append([i[1], i[2], 1])

            else:  # opt=2访问数据
                if i[1] in [j[0] for j in buf]:  # get(x)在缓存里
                    for j in buf:
                        if j[0] == i[1]:  # 找到该数据
                            j[2] += 1  # 访问次数+1
                            res.append(j[1])
                else:
                    res.append(-1)

        return res

#
# 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
#
# lfu design
# @param operators int整型二维数组 ops
# @param k int整型 the k
# @return int整型一维数组
#
class Solution:
    def __init__(self):
        """
        初始化桶及其对应的map集合
        :param capacity:
        """
        self.limit = 1
        self.head = Bucket(0)
        self.bmp = {}

    def get(self, key: int) -> int:
        if key in self.bmp.keys():
            tmp = self.bmp[key]
            self.set(key, tmp.val)
            return tmp.val
        else:
            return -1

    def set(self, key: int, value: int) -> None:
        tmp = None
        bucket = None
        if key in self.bmp.keys():
            tmp = self.remove(key)
        else:
            if len(self.bmp) == self.limit:
                self.remove(self.head.next.head.prev.key)
        if tmp:
            bucket = tmp.bucket
            if bucket.times + 1 == bucket.next.times:
                bucket = bucket.next
            else:
                bucket = Bucket(bucket.times+1)
                bucket.prev = self.head.prev
                self.head.prev = bucket
                bucket.prev.next = bucket
                bucket.next = self.head
        else:
            if len(self.bmp) == self.limit:
                self.remove(self.head.next.prev.key)
            if self.head.next.times == 1:
                bucket = self.head.next
            else:
                bucket = Bucket(1)
                bucket.next = self.head.next
                self.head.next = bucket
                bucket.next.prev = bucket
                bucket.prev = self.head
        tmp = BNode(key, value, bucket)
        tmp.next = bucket.head.next
        bucket.head.next = tmp
        tmp.next.prev = tmp
        tmp.prev = bucket.head
        self.bmp[key] = tmp

    def remove(self, key: int):
        if key in self.bmp:
            tmp = self.bmp[key]
            tmp.prev.next = tmp.next
            tmp.next.prev = tmp.prev
            self.bmp.pop(key)
            bucket = tmp.bucket
            if bucket.head == bucket.head.next:
                bucket.prev.next = bucket.next
                bucket.next.prev = bucket.prev
            return tmp


    def LFU(self , operators: List[List[int]], k: int) -> List[int]:
        ret = []
        self.limit = k
        for i in operators:
            if i[1] == -146502911:
                print(i[1])
            if i[0] == 1:
                self.set(i[1], i[2])
            elif i[0] == 2:
                ret.append(self.get(i[1]))
        return ret


class Bucket:
    def __init__(self, times: int):
        """
        定义双向链表桶，用于存放当前次数的Node节点
        :param times: 访问次数
        :return:
        """
        self.times = times
        self.head = BNode(-1, -1, self)
        self.prev = self
        self.next = self

    def push(self, bnode: "BNode"):
        bnode.next = self.head.next
        self.head.next = bnode
        bnode.prev = self.head
        bnode.next.prev = bnode

    def pop(self, bnode: "BNode"):
        bnode.prev.next = bnode.next
        bnode.next.prev = bnode.prev


class BNode:
    def __init__(self, key: int, val: int, bucket: Bucket):
        """
        定义数据节点
        :param key: 传入的key值
        :param val: 传入的val值
        :param bucket: 当前节点所属的桶
        """
        self.bucket = bucket
        self.prev = self
        self.next = self
        self.key = key
        self.val = val