设计循环双端队列 两种解法（Python）

数组实现

class MyCircularDeque:

    def __init__(self, k: int):
        '''
        front last 都从0开始
        front始终指向第一个元素的位置，从队首插入 先循环前移front再插入
        last 指向最后一个元素的下一个的位置，从队尾插入，先存值，再后移last
        '''
        self.front = 0
        self.last = 0
        self.capacity = k + 1
        self.data = [0] * self.capacity


    def insertFront(self, value: int) -> bool:
        if self.isFull():
            return False
        # 前移操作 加上数组长度再求余
        self.front = (self.front - 1 + self.capacity) % self.capacity
        self.data[self.front] = value
        return True

    def insertLast(self, value: int) -> bool:
        if self.isFull():
            return False
        self.data[self.last] = value
        # 后移操作直接+1 再求余
        self.last = (self.last + 1) % self.capacity
        return True

    def deleteFront(self) -> bool:
        if self.isEmpty():
            return False
        # 从队首删除 直接后移front即可 不用清除值
        self.front = (self.front + 1) % self.capacity
        return True


    def deleteLast(self) -> bool:
        if self.isEmpty():
            return False
        # 从队尾删除 直接前移last即可 
        self.last = (self.last - 1 + self.capacity) % self.capacity
        return  True

    def getFront(self) -> int:
        if self.isEmpty():
            return -1
        return self.data[self.front]


    def getRear(self) -> int:
        if self.isEmpty():
            return -1
        # 最后一个元素处于 last的前一个位置
        return self.data[(self.last - 1 + self.capacity) % self.capacity]


    def isEmpty(self) -> bool:
        return self.front == self.last

    def isFull(self) -> bool:
        # 特地留一个空元素 是的full判断和empty判断区分开
        return (self.last + 1) % self.capacity == self.front

链表实现

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

class MyCircularDeque:

    def __init__(self, k: int):
        self.size = 0
        self.capacity = k
        self.head = Node()
        self.tail = Node()
        self.head.next = self.tail
        self.tail.prev = self.head


    def insertFront(self, value: int) -> bool:
        if self.isFull():
            return False
        headNext = self.head.next
        newNode = Node(value)
        self.head.next = newNode
        newNode.prev = self.head
        newNode.next = headNext
        headNext.prev = newNode
        self.size += 1
        return True


    def insertLast(self, value: int) -> bool:
        if self.isFull():
            return False
        tailPrev = self.tail.prev
        newNode = Node(value)
        tailPrev.next = newNode
        newNode.prev = tailPrev
        newNode.next = self.tail
        self.tail.prev = newNode
        self.size += 1
        return True


    def deleteFront(self) -> bool:
        if self.isEmpty():
            return False
        # 有趣的删除节点操作
        # 被删除的节点虽然保持着对next节点的引用 但是不用担心 因为没有了对被删除节点的引用 会被GC 
        self.head.next = self.head.next.next
        self.head.next.prev = self.head
        self.size -= 1
        return True
        


    def deleteLast(self) -> bool:
        if self.isEmpty():
            return False
        self.tail.prev = self.tail.prev.prev
        self.tail.prev.next = self.tail
        self.size -= 1
        return True
        


    def getFront(self) -> int:
        if self.isEmpty():
            return -1
        return self.head.next.value


    def getRear(self) -> int:
        if self.isEmpty():
            return -1
        return self.tail.prev.value


    def isEmpty(self) -> bool:
        return self.size == 0

    def isFull(self) -> bool:
        return self.size == self.capacity