八月集训：队列

腥月劫

已于 2022-08-16 15:28:24 修改

阅读量144

点赞数

文章标签：算法 leetcode 数据结构 c++

于 2022-08-16 15:27:05 首次发布

本文链接：https://blog.csdn.net/weixin_51269297/article/details/126365956

版权

八月集训：队列

今天题目（补五月的没写的集训题）
结尾

今天题目（补五月的没写的集训题）

今天的题目比较简单，好久没有靠自己做出来的并且一次性过的题啦！！！！！！！虽然后两道题还是得看思路和代码，但是比之前不一样的是很快就能看懂嘻嘻（主要还是第二道和第三道思路差不多）。

2073. 买票需要的时间

链接: 2073. 买票需要的时间

有 n 个人前来排队买票，其中第 0 人站在队伍 最前方 ，第 (n - 1) 人站在队伍 最后方 。

给你一个下标从 0 开始的整数数组 tickets ，数组长度为 n ，其中第 i 人想要购买的票数为 tickets[i] 。

每个人买票都需要用掉 恰好 1 秒 。一个人一次只能买一张票，如果需要购买更多票，他必须走到队尾重新排队（瞬间发生，不计时间）。如果一个人没有剩下需要买的票，那他将会离开队伍。

返回位于位置 k（下标从 0 开始）的人完成买票需要的时间（以秒为单位）。

示例 1：

输入：tickets = [2,3,2], k = 2
输出：6
解释：

第一轮，队伍中的每个人都买到一张票，队伍变为 [1, 2, 1] 。
第二轮，队伍中的每个都又都买到一张票，队伍变为 [0, 1, 0] 。
位置 2 的人成功买到 2 张票，用掉 3 + 3 = 6 秒。

示例 2：

输入：tickets = [5,1,1,1], k = 0
输出：8
解释：

第一轮，队伍中的每个人都买到一张票，队伍变为 [4, 0, 0, 0] 。
接下来的 4 轮，只有位置 0 的人在买票。
位置 0 的人成功买到 5 张票，用掉 4 + 1 + 1 + 1 + 1 = 8 秒。

提示：
n == tickets.length
1 <= n <= 100
1 <= tickets[i] <= 100
0 <= k < n

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/time-needed-to-buy-tickets
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路：先记录是要看哪个人的买票时间，然后进行while循环，在循环中进行整个数组的for循环，一次进行累减，并且要记录次数（即秒数），然后判断是否是第k个人票数为0就行。`

class Solution {
public:
    int timeRequiredToBuy(vector<int>& tickets, int k) {
        int m = tickets[k];
        int ans = 0;
        while(tickets[k])
        {
            for(int i = 0;i < tickets.size();i++)
            {
                if(tickets[i] == 0 && i != k)
                {
                    continue;
                }
                if(tickets[k] == 0)
                {
                    break;
                }
                tickets[i]--;
                ans++;
            }
        }
        return ans;
    }
};

641. 设计循环双端队列

链接: 641. 设计循环双端队列

设计实现双端队列。

实现 MyCircularDeque 类:

MyCircularDeque(int k) ：构造函数,双端队列最大为 k 。
boolean insertFront()：将一个元素添加到双端队列头部。
如果操作成功返回 true ，否则返回 false 。
boolean insertLast() ：将一个元素添加到双端队列尾部。
如果操作成功返回 true ，否则返回 false 。
boolean deleteFront() ：从双端队列头部删除一个元素。
如果操作成功返回 true ，否则返回 false 。
boolean deleteLast() ：从双端队列尾部删除一个元素。
如果操作成功返回 true ，否则返回 false 。
int getFront() )：从双端队列头部获得一个元素。
如果双端队列为空，返回 -1 。
int getRear() ：获得双端队列的最后一个元素。
如果双端队列为空，返回 -1 。
boolean isEmpty() ：若双端队列为空，则返回 true ，否则返回 false 。
boolean isFull() ：若双端队列满了，则返回 true ，否则返回 false 。

示例 1：

输入
[“MyCircularDeque”, “insertLast”, “insertLast”, “insertFront”, “insertFront”, “getRear”, “isFull”, “deleteLast”, “insertFront”, “getFront”]
[[3], [1], [2], [3], [4], [], [], [], [4], []]
输出
[null, true, true, true, false, 2, true, true, true, 4]

解释
MyCircularDeque circularDeque = new MycircularDeque(3);
// 设置容量大小为3
circularDeque.insertLast(1); // 返回 true
circularDeque.insertLast(2); // 返回 true
circularDeque.insertFront(3); // 返回 true
circularDeque.insertFront(4); // 已经满了，返回 false
circularDeque.getRear(); // 返回 2
circularDeque.isFull(); // 返回 true
circularDeque.deleteLast(); // 返回 true
circularDeque.insertFront(4); // 返回 true
circularDeque.getFront(); // 返回 4

提示：
1 <= k <= 1000
0 <= value <= 1000
insertFront, insertLast, deleteFront, deleteLast, getFront, getRear, isEmpty, isFull 调用次数不大于 2000 次

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/design-circular-deque
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路：这道题因为调用次数不大于2000次，而且长度也只在1000左右，所以直接写个大一点的数组，然后把队列放在中间即可，初始化设置front为中心Mid,因为一开始队列为空，当front和rear队列错开一个位置时即可判断为空，那么rear = front - 1。然后可以通过rear - front + 1来判断队列个数。

class MyCircularDeque {
    #define Mid 2000;
    int data[4000];
    int front,rear;
    int len;
public:
    MyCircularDeque(int k) {
        len = k;
        front = Mid;
        rear = front - 1;
    }
    
    bool insertFront(int value) {
        if(isFull())
        {
            return false;
        }    
        data[--front] = value;
        return true;
    }
    
    bool insertLast(int value) {
        if(isFull())
        {
            return false;
        }
        data[++rear] = value;
        return true;
    }
    
    bool deleteFront() {
        if(isEmpty())
        {
            return false;
        }
        front++;
        return true;
    }
    
    bool deleteLast() {
        if(isEmpty())
        {
            return false;
        }
        rear--;
        return true;
    }
    
    int getFront() {
        if(isEmpty())
        {
            return -1;
        }
        return data[front];
    }
    
    int getRear() {
        if(isEmpty())
        {
            return -1;
        }
        return data[rear];
    }
    
    int getCount() 
    {
        return rear - front + 1;
    }

    bool isEmpty() {
        if(getCount() == 0)
        {
            return true;
        }
        return false;
    }
    
    bool isFull() {
        if(getCount() == len)
        {
            return true;
        }
        return false;
    }
};

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 <= 109
最多调用 1000 次 pushFront， pushMiddle， pushBack， popFront， popMiddle 和 popBack 。

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/design-front-middle-back-queue
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路：这道题跟第二道题有异曲同工之妙，除了插入和删除中间位置让我不得不去看思路代码之外还是跟第二道大差不差的。这里插入和删除可以先自己举例写写插入到什么位置以及要删除时，中间位置在哪里？
这里采用“英雄哪里出来”，也就是英雄哥的思路。
插入时:找可以插入的位置，以下前面数字是当要插入时队列中元素个数
1 X front
2 XX front + 1
3 XXX front + 1
4 XXXX front + 2
5 XXXXX front + 2
6 XXXXXX front + 3
7 XXXXXXX front + 3
可以发现插入时除了个数1个之外，其他的都是front + 个数/2（向下取整）

删除时：找删除的中间位置
1 X front
2 XX front
3 XXX front + 1
4 XXXX front + 1
5 XXXXX front + 2
6 XXXXXX front + 2
7 XXXXXXX front + 3
8 XXXXXXXX front + 3
可以发现要删除的都是front + （个数-1）/2（同样向下取整）

class FrontMiddleBackQueue {
    #define MidLength 1000
    int data[2000];
    int front,rear;
public:
    FrontMiddleBackQueue() {
        front = MidLength;
        rear = front - 1;
    }
    
    void pushFront(int val) {
        data[--front] = val;
    }
    
    void pushMiddle(int val) {
        if(getCount() == 1)
        {
            pushFront(val);
            return;
        }
        int x = getCount();
        int y = front + x/2;
        for(int i = rear + 1;i > y;i--)
        {
            data[i] = data[i-1];
        }
        data[y] = val;
        rear++;
    }
    
    void pushBack(int val) {
        data[++rear] = val;
    }
    
    int popFront() {
        if(getCount() == 0)
        {
            return -1;
        }
        return data[front++];
    }
    
    int popMiddle() {
        if(getCount() == 0)
        {
            return -1;
        }
        int x = getCount();
        int y = front + (x-1)/2;
        int z = data[y];
        for(int i = y;i < rear;i++)
        {
            data[i] = data[i+1];
        }
        rear--;
        return z;
    }
    
    int popBack() {
        if(getCount() == 0)
        {
            return -1;
        }
        return data[rear--];
    }

    int getCount()
    {
        return rear - front + 1;
    }
};