题目
（1）请你设计一个队列，支持在前，中，后三个位置的 push 和 pop 操作。
（2）请你完成 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 。
（3）请注意当有两个中间位置的时候，选择靠前面的位置进行操作。比方说：
- 将 6 添加到 [1, 2, 3, 4, 5] 的中间位置，结果数组为 [1, 2, 6, 3, 4, 5] 。
- 从 [1, 2, 3, 4, 5, 6] 的中间位置弹出元素，返回 3 ，数组变为 [1, 2, 4, 5, 6] 。
（4）示例如下：
输入：[“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 -> [] （队列为空）
解决思路
- 用两个双端队列q1、q2实现前中后队列q（用链表实现双端队列q1和q2，q1和q2首尾相连实现前中后队列）。
- 注意：每次操作（删除、插入）后都要对q1和q2中的元素个数进行调整。
- 设q1中的元素的个数为cnt1，q2中的元素的个数为cnt2，每次操作后都要调整q1和q2的中的元素个数，使cnt2 <= cnt1 <= cnt2 + 1。
- 从q的头部插入元素时，即从q1的头部插入元素。从q的尾部插入元素时，即从q2的尾部插入元素。
- 从q的头部取出元素时，即从q1的头部取出元素。从q的尾部取出元素时，即从q2的尾部取出元素。
- 从q的中间插入元素时，先调整q1和q2的元素个数，使 cnt1 <= cnt2，这样每次都只需要从 q1的尾部插入元素即可。
- 从q的中间取出元素时，每次都从q1的尾部取出元素（因为每次操作后都对q1和q2的元素个数进行了调整，使得cnt2 <= cnt1 <= cnt2 + 1）。
- 两个双端队列q1和q2首尾相连，如下所示：
- 细节：
- 在链表的节点类中，实现在某个节点的 前/后 面插入一个节点的方法；实现删除某节点的 前/后 面一个节点的方法。
- 在双端队列的类中，实现从 对首/对尾 插入/删除 节点的方法；查看头节点/尾节点的值的方法；判断链表是否为空的方法；获取链表的元素个数的方法。
- 在前中后队列中，实现从 对首/对尾 插入/删除 节点的方法；查看头节点/尾节点的值的方法；调整q1和q2的元素个数的方法；判断链表是否为空的方法。
代码
- C++代码
# include <stdio.h>
// 链表的节点
class Node {
public:
int val;
Node *pre; // 指向上一个节点的指针
Node *next; // 指向下一个节点的指针
// 构造函数
Node(int val=0, Node *pre=nullptr, Node *next=nullptr): val(val), pre(pre), next(next) {}
// 在当前节点前面插入一个节点
void insert_pre(Node *q) {
q->pre = this->pre;
q->next = this;
if (this->pre) {
this->pre->next = q;
}
this->pre = q;
return;
}
// 在当前节点后面插入一个节点
void insert_next(Node *q) {
q->pre = this;
q->next = this->next;
if (this->next) {
this->next->pre = q;
}
this->next = q;
return;
}
// 删除当前节点的前一个节点
void delete_pre() {
if (nullptr == this->pre) {
return;
}
Node *q = this->pre;
if (q) {
this->pre = q->pre;
}
if (q->pre) {
q->pre->next = this;
}
delete q;
q = nullptr; // 防止内存泄漏
return;
}
// 删除当前节点的后一个节点
void delete_next() {
if (nullptr == this->next) {
return;
}
Node *q = this->next;
if (q) {
this->next = q->next;
}
if (q->next) {
q->next->pre = this;
}
delete q;
q = nullptr; // 防止内存泄漏
return;
}
};
// 创建双端队列
class DeQueue {
public:
Node head; // 创建虚拟头节点
Node tail; // 创建虚拟尾结点
int cnt; // 记录队列中节点的数量
// 构造函数
// 初始时刻，让虚拟头节点指向虚拟尾节点
DeQueue(): cnt(0) {
head.pre = nullptr;
head.next = &tail;
tail.pre = &head;
tail.next = nullptr;
}
// 从队列的头部插入一个节点
void push_front(int value) {
head.insert_next(new Node(value));
cnt += 1;
return;
}
// 从队列尾部插入一个节点
void push_back(int value) {
tail.insert_pre(new Node(value));
cnt += 1;
return;
}
// 从队列的头部删除一个节点
int pop_front() {
if (isEmpty()) {
return -1;
}
int ret = head.next->val;
head.delete_next();
cnt -= 1;
return ret;
}
// 从队列的尾部删除一个节点
int pop_back() {
if (isEmpty()) {
return -1;
}
int ret = tail.pre->val;
tail.delete_pre();
cnt -= 1;
return ret;
}
// 查看队列的头节点的值
int front() {
return head.next->val;
}
// 查看队列的尾结点的值
int back() {
return tail.pre->val;
}
// 获取队列的元素个数
int size() {
return cnt;
}
// 判断队列是否为空
bool isEmpty() {
return 0 == cnt;
}
};
// 创建两个双端队列q1和q2，q1存前一半元素，q2存后一半元素, 当前中后队列的节点个数为偶数个时，使q1和q2中的节点数相等。
// 当为奇数时，让q1中的节点数比q2中的节点数多1个。
class FrontMiddleBackQueu {
public:
// 创建两个双端队列
DeQueue q1;
DeQueue q2;
FrontMiddleBackQueu(){}
void pushFront(int value) {
q1.push_front(value);
update_size();
return;
}
void pushMiddle(int value) {
// 先调整q1和q2中的元素个数，使q1种的元素个数不大于q2种的元素个数，则不论队列节点个数是奇数还是偶数，从中间插入节点时都会插入到q1的尾部
while (q1.size() > q2.size()) {
q2.push_front(q1.back()); // 先将q1的尾节点插入到q2的头部
q1.pop_back();
}
q1.push_back(value);
update_size();
return;
}
void pushBack(int value) {
q2.push_back(value);
update_size();
return;
}
int popFront() {
if (isEmpty()) {
return -1;
}
int ret = q1.pop_front();
update_size();
return ret;
}
int popMiddle() {
if (isEmpty()) {
return -1;
}
int ret = q1.pop_back();
update_size();
return ret;
}
int popBack() {
if (isEmpty()) {
return -1;
}
int ret;
if (q2.isEmpty()) {
ret = q1.pop_back();
} else {
ret = q2.pop_back();
}
update_size();
return ret;
}
// 调整q1和q2队列中的元素个数，设q1和q2中的元素个数分别为cnt1和cnt2，使得cnt2 <= cnt1 <= cnt2 + 1
void update_size() {
while (q1.size() < q2.size()) {
q1.push_back(q2.front());
q2.pop_front();
}
while (q1.size() >= q2.size() + 2) {
q2.push_front(q1.back());
q1.pop_back();
}
return;
}
bool isEmpty() {
return 0 == q1.size() + q2.size();
}
};
int main() {
FrontMiddleBackQueu *ret = new FrontMiddleBackQueu();
ret->pushFront(1);
ret->pushBack(2);
ret->pushMiddle(3);
ret->pushMiddle(4);
printf("%d\n", ret->popFront());
printf("%d\n", ret->popMiddle());
printf("%d\n", ret->popMiddle());
printf("%d\n", ret->popBack());
printf("%d\n", ret->popFront());
return 0;
}
- Python代码
# -*- coding: utf-8 -*-
# 链表的节点
class Node:
def __init__(self, val=0, pre=None, next=None):
self.val = val
self.pre = pre # 指向上一个节点
self.next = next # 指向下一个节点
# 在当前节点前面插入一个节点
def insert_pre(self, q):
q.pre = self.pre
q.next = self
if self.pre:
self.pre.next = q
self.pre = q
return
# 在当前节点后面插入一个节点
def insert_next(self, q):
q.pre = self
q.next = self.next
if self.next:
self.next.pre = q
self.next = q
return
# 删除当前节点的前一个节点
def delete_pre(self):
if None == self.pre:
return
q = self.pre
if q:
self.pre = q.pre
if q.pre:
q.pre.next = self
del q
return
# 删除当前节点的后一个节点
def delete_next(self):
if None == self.next:
return
q = self.next
if q:
self.next = q.next
if q.next:
q.next.pre = self
del q
return
# 创建双端队列
class DeQueue:
def __init__(self):
self.head = Node() # 创建虚拟头节点
self.tail = Node() # 创建虚拟尾结点
# 初始时刻，让虚拟头节点指向虚拟尾节点
self.head.pre = None
self.head.next = self.tail
self.tail.pre = self.head
self.tail.next = None
self.cnt = 0 # 记录队列中节点的数量
# 从队列的头部插入一个节点
def push_front(self, value):
self.head.insert_next(Node(value))
self.cnt += 1
return
# 从队列尾部插入一个节点
def push_back(self, value):
self.tail.insert_pre(Node(value))
self.cnt += 1
return
# 从队列的头部删除一个节点
def pop_front(self):
if self.isEmpty():
return -1
ret = self.head.next.val
self.head.delete_next()
self.cnt -= 1
return ret
# 从队列的尾部删除一个节点
def pop_back(self):
if self.isEmpty():
return -1
ret = self.tail.pre.val
self.tail.delete_pre()
self.cnt -= 1
return ret
# 查看队列的头节点的值
def front(self):
return self.head.next.val
# 查看队列的尾结点的值
def back(self):
return self.tail.pre.val
# 获取队列的元素个数
def size(self):
return self.cnt
# 判断队列是否为空
def isEmpty(self):
return 0 == self.cnt
# 创建两个双端队列q1和q2，q1存前一半元素，q2存后一半元素, 当前中后队列的节点个数为偶数个时，使q1和q2中的节点数相等。
# 当为奇数时，让q1中的节点数比q2中的节点数多1个。
class FrontMiddleBackQueue:
def __init__(self):
self.q1 = DeQueue() # 创建两个双端队列
self.q2 = DeQueue()
def pushFront(self, val: int) -> None:
self.q1.push_front(val)
self.update_size()
return
def pushMiddle(self, val: int) -> None:
# 先调整q1和q2中的元素个数，使q1种的元素个数不大于q2种的元素个数，则不论队列节点个数是奇数还是偶数，从中间插入节点时都会插入到q1的尾部
while self.q1.size() > self.q2.size():
self.q2.push_front(self.q1.back()) # 先将q1的尾节点插入到q2的头部
self.q1.pop_back()
self.q1.push_back(val)
self.update_size()
return
def pushBack(self, val: int) -> None:
self.q2.push_back(val)
self.update_size()
return
def popFront(self) -> int:
if self.isEmpty():
return -1
ret = self.q1.pop_front()
self.update_size()
return ret
def popMiddle(self) -> int:
if self.isEmpty():
return -1
ret = self.q1.pop_back()
self.update_size()
return ret
def popBack(self) -> int:
if self.isEmpty():
return -1
if self.q2.isEmpty():
ret = self.q1.pop_back()
else:
ret = self.q2.pop_back()
self.update_size()
return ret
# 调整q1和q2队列中的元素个数，设q1和q2中的元素个数分别为cnt1和cnt2，使得cnt2 <= cnt1 <= cnt2 + 1
def update_size(self):
while self.q1.size() < self.q2.size():
self.q1.push_back(self.q2.front())
self.q2.pop_front()
while self.q1.size() >= self.q2.size() + 2:
self.q2.push_front(self.q1.back())
self.q1.pop_back()
return
def isEmpty(self):
return 0 == self.q1.size() + self.q2.size()
def main():
ret: FrontMiddleBackQueue = FrontMiddleBackQueue()
ret.pushFront(1)
ret.pushBack(2)
ret.pushMiddle(3)
ret.pushMiddle(4)
print(ret.popFront())
print(ret.popMiddle())
print(ret.popMiddle())
print(ret.popBack())
print(ret.popFront())
if __name__ == "__main__":
main()
说明
- 对应LeetCode第1670题。
- 链接：https://leetcode-cn.com/problems/design-front-middle-back-queue/
扫一扫
2898
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
