LeetCode 1670. 设计前中后队列

1670. 设计前中后队列

请你设计一个队列，支持在前，中，后三个位置的 push 和 pop 操作。

请你完成 FrontMiddleBack 类：

• FrontMiddleBack() 初始化队列。
• void pushFront(int val) 将 val 添加到队列的 最前面 。
• void pushMiddle(int val) 将 val 添加到队列的 正中间 。
• void pushBack(int val) 将 val 添加到队里的 最后面 。
• int popFront() 将 最前面 的元素从队列中删除并返回值，如果删除之前队列为空，那么返回 -1 。
• int popMiddle() 将 正中间 的元素从队列中删除并返回值，如果删除之前队列为空，那么返回 -1 。
• int popBack() 将 最后面 的元素从队列中删除并返回值，如果删除之前队列为空，那么返回 -1 。

请注意当有 两个 中间位置的时候，选择靠前面的位置进行操作。比方说：

• 将 6 添加到 [1, 2, 3, 4, 5] 的中间位置，结果数组为 [1, 2, 6, 3, 4, 5] 。
• 从 [1, 2, 3, 4, 5, 6] 的中间位置弹出元素，返回 3 ，数组变为 [1, 2, 4, 5, 6] 。

示例 1：

输入：
["FrontMiddleBackQueue", "pushFront", "pushBack", "pushMiddle", "pushMiddle", "popFront", "popMiddle", "popMiddle", "popBack", "popFront"]
[[], [1], [2], [3], [4], [], [], [], [], []]
输出：
[null, null, null, null, null, 1, 3, 4, 2, -1]

解释：
FrontMiddleBackQueue q = new FrontMiddleBackQueue();
q.pushFront(1);   // [1]
q.pushBack(2);    // [1, 2]
q.pushMiddle(3);  // [1, 3, 2]
q.pushMiddle(4);  // [1, 4, 3, 2]
q.popFront();     // 返回 1 -> [4, 3, 2]
q.popMiddle();    // 返回 3 -> [4, 2]
q.popMiddle();    // 返回 4 -> [2]
q.popBack();      // 返回 2 -> []
q.popFront();     // 返回 -1 -> [] （队列为空）

提示：

• 1 <= val <= 10^9
• 最多调用 1000 次 pushFront, pushMiddle, pushBack, popFront, popMiddle 和 popBack 。

---

提示 1

The constraints are low enough for a brute force, single array approach.

---

提示 2

For an O(1) per method approach, use 2 double-ended queues: one for the first half and one for the second half.

解法1：队列

解题思路

设计一个队列支持在前、中、后三个位置的 push 和 pop 操作，这个问题可以通过使用两个双端队列（Deque）来解决。双端队列允许我们在两端进行 push 和 pop 操作，这为我们提供了在队列两端快速操作的能力。

使用两个双端队列的目的是为了实现快速的中间位置的 push 和 pop 操作。通过 balance 方法，我们可以确保在执行中间位置的操作时，队列的两个部分尽量保持平衡，这样无论中间位置是在 front 还是 back，我们都能够快速地定位并执行操作。这种方法的优势在于它不需要额外的存储空间，并且能够保持操作的高效性。

算法实现步骤

1. 初始化队列：创建 FrontMiddleBackQueue 类的实例时，初始化两个空的双端队列 front 和 back，以及一个计数器 size。
2. 添加元素：
   • pushFront：将元素添加到 front 的前端。
   • pushBack：将元素添加到 back 的后端。
   • pushMiddle：调用 balance 方法后，将元素添加到 front。
3. 移除元素：
   • popFront：检查 front 是否为空，如果不为空，从 front 移除元素；否则从 back 的前端移除元素。
   • popMiddle：调用 balance 方法，然后根据 front 和 back 的大小，从适当的队列中移除元素。
   • popBack：检查 back 是否为空，如果不为空，从 back 移除元素；否则从 front 的后端移除元素。
4. 平衡队列：balance 方法确保 front 和 back 的大小差不超过 1，以便于快速访问中间元素。

Java版：

class FrontMiddleBackQueue {
    Deque<Integer> front;
    Deque<Integer> back;
    int size;

    public FrontMiddleBackQueue() {
        front = new ArrayDeque<>();
        back = new ArrayDeque<>();
        size = 0;
    }
    
    public void pushFront(int val) {
        front.offerFirst(val);
        size++;
    }
    
    public void pushMiddle(int val) {
        balance();
        front.offer(val);
        size++;
    }
    
    public void pushBack(int val) {
        back.offerLast(val);
        size++;
    }
    
    public int popFront() {
        if (size == 0) {
            return -1;
        }
        size--;
        return !front.isEmpty() ? front.poll() : back.poll();
    }
    
    public int popMiddle() {
        if (size == 0) {
            return -1;
        }
        balance();
        size--;
        return front.size() == back.size() ? front.pollLast() : back.poll();
    }
    
    public int popBack() {
        if (size == 0) {
            return -1;
        }
        size--;
        return !back.isEmpty() ? back.pollLast() : front.pollLast();
    }

    public void balance() {
        while (front.size() > back.size()) {
            back.offerFirst(front.pollLast());
        }
        while (front.size() < back.size() && back.size() - front.size() > 1) {
            front.offerLast(back.pollFirst());
        }
    }
}

/**
 * Your FrontMiddleBackQueue object will be instantiated and called as such:
 * FrontMiddleBackQueue obj = new FrontMiddleBackQueue();
 * obj.pushFront(val);
 * obj.pushMiddle(val);
 * obj.pushBack(val);
 * int param_4 = obj.popFront();
 * int param_5 = obj.popMiddle();
 * int param_6 = obj.popBack();
 */

Python3版：

class FrontMiddleBackQueue:

    def __init__(self):
        self.front = deque()
        self.back = deque()
        self.size = 0

    def pushFront(self, val: int) -> None:
        self.front.appendleft(val)
        self.size += 1

    def pushMiddle(self, val: int) -> None:
        self.balance()
        self.front.append(val)
        self.size += 1

    def pushBack(self, val: int) -> None:
        self.back.append(val)
        self.size += 1

    def popFront(self) -> int:
        if self.size == 0:
            return -1
        self.size -= 1
        return self.front.popleft() if self.front else self.back.popleft()

    def popMiddle(self) -> int:
        if self.size == 0:
            return -1
        self.balance()
        self.size -= 1
        return self.front.pop() if len(self.front) == len(self.back) else self.back.popleft()

    def popBack(self) -> int:
        if self.size == 0:
            return -1
        self.size -= 1
        return self.back.pop() if self.back else self.front.pop()

    def balance(self) -> None:
        while len(self.front) > len(self.back):
            self.back.appendleft(self.front.pop())
        while len(self.back) - len(self.front) > 1:
            self.front.append(self.back.popleft())

# Your FrontMiddleBackQueue object will be instantiated and called as such:
# obj = FrontMiddleBackQueue()
# obj.pushFront(val)
# obj.pushMiddle(val)
# obj.pushBack(val)
# param_4 = obj.popFront()
# param_5 = obj.popMiddle()
# param_6 = obj.popBack()

复杂度分析

• 时间复杂度：O(n)，其中 n 是操作次数。由于在双端队列头部和尾部进行插入或者删除的时间复杂度为 O(1)，因此总体时间复杂度为 O(n)。
• 空间复杂度：O(n)。