leetcode链表之全O(1)的数据结构

432、全O(1)的数据结构

题目：

请你设计一个用于存储字符串计数的数据结构，并能够返回计数最小和最大的字符串。

实现 AllOne 类：

• AllOne() 初始化数据结构的对象。
• inc(String key) 字符串 key 的计数增加 1 。如果数据结构中尚不存在 key ，那么插入计数为 1 的 key 。
• dec(String key) 字符串 key 的计数减少 1 。如果 key 的计数在减少后为 0 ，那么需要将这个 key 从数据结构中删除。测试用例保证：在减少计数前，key 存在于数据结构中。
• getMaxKey() 返回任意一个计数最大的字符串。如果没有元素存在，返回一个空字符串 “” 。
• getMinKey() 返回任意一个计数最小的字符串。如果没有元素存在，返回一个空字符串 “” 。

---

思路：

这道题初看起来有点懵，不知道采用什么数据结构，不过在题目中需要返回计数最大的字符串，和计数最小的字符串，这是不是和之前LRU缓存有点像呢？

不过这里和LRU缓存不同的是，这里每个key都是有一个计数次数的，而不是和LRU缓存一样，直接插入到队列首部。

既然分析这么多，那就开始写代码吧

class DoubleLinkedList:
    def __init__(self, key="", value=None, next=None, prev=None):
        self.key = key
        # 这里的value记录着结点的计数
        self.value = value
        self.next = next
        self.prev = prev

class AllOne:
		# 这里初始化和LRU缓存一样，一个缓存，一个头结点和一个尾结点，这里不需要记录整个缓存的大小。
    def __init__(self):
        self.cache = {}
        self.head = DoubleLinkedList()
        self.tail = DoubleLinkedList()
        self.head.next = self.tail
        self.tail.prev = self.head

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

    def move_to_prev(self, node, prev):
        self.remove_node(node)
        self.add_to_prev(node, prev)

    def add_to_prev(self, node, prev):
        node.next = prev.next
        node.prev = prev
        prev.next.prev = node
        prev.next = node
		# 加一操作
    def inc(self, key: str) -> None:
      	# 如果key在缓存中，说明之前已经添加了key，这个时候循环向前遍历，将其向前移动
        if key in self.cache:
            node = self.cache[key]
            count = node.value + 1
            # 更新node的value值
            node.value = count
            cur = node
            while cur.prev:
              	# 此时要考虑，如果要更新的结点，没有比其更大的结点，那么循环遍历会遍历的头结点
                if not cur.prev.value or cur.prev.value >= count:
                    break
                cur = cur.prev
            # 如果当前结点的前一个结点和要新增的结点不是一个的时候，也就是说需要进行结点的移动
            if node.prev != cur.prev:
                self.move_to_prev(node, cur.prev)
        # 如果key不再缓存中，直接插到链表结尾即可
        else:
            node = DoubleLinkedList(key, 1)
            self.add_to_prev(node, self.tail.prev)
            self.cache[key] = node

    def dec(self, key: str) -> None:
        if key not in self.cache: return
        node = self.cache[key]
        count = node.value - 1
        node.value = count
        # 减计数需要考虑是否减到0了，如果减到0，需要删除结点，并从缓存中删除
        if count <= 0:
            self.remove_node(node)
            self.cache.pop(key)
        else:
            cur = node
            # 如果不为0， 那么就需要向后将结点放到合适的位置
            while cur.next:
                if not cur.next.value or  cur.next.value <= count:
                    break
                cur = cur.next
            if cur.next != node.next:
                self.move_to_prev(node, cur)
		#此时getMax就是头部结点的key
    def getMaxKey(self) -> str:
        return self.head.next.key

		# getMin获取尾结点的key
    def getMinKey(self) -> str:
        return self.tail.prev.key