leetcode【数据结构简介】《队列&栈》卡片——队列：先入先出的数据结构

Author: Authur Whywait， 一个努力学习知识的孩子 \ (0^ ◇^0)/
想看博主的其他所有leetcode卡片学习笔记链接？传送门点这儿

先入先出的数据结构

在 FIFO 数据结构中，将首先处理添加到队列中的第一个元素。

如上图所示，队列是典型的 FIFO 数据结构。插入（insert）操作也称作入队（enqueue），新元素始终被添加在队列的末尾。 删除（delete）操作也被称为出队（dequeue)。 你只能移除第一个元素。

队列 - 实现

为了实现队列，我们可以使用动态数组和指向队列头部的索引。

如上所述，队列应支持两种操作：入队和出队。入队会向队列追加一个新元素，而出队会删除第一个元素。 所以我们需要一个索引来指出起点。

缺点
上面的实现很简单，但在某些情况下效率很低。 随着起始指针的移动，浪费了越来越多的空间。 当我们有空间限制时，这将是难以接受的。

让我们考虑一种情况，即我们只能分配一个最大长度为 5 的数组。当我们只添加少于 5 个元素时，我们的解决方案很有效。 例如，如果我们只调用入队函数四次后还想要将元素 10 入队，那么我们可以成功。

但是我们不能接受更多的入队请求，这是合理的，因为现在队列已经满了。但是如果我们将一个元素出队呢？

实际上，在这种情况下，我们应该能够再接受一个元素。

于是，接下来我们将介绍循环队列。

循环队列

此前，我们提供了一种简单但低效的队列实现。

更有效的方法是使用循环队列。 具体来说，我们可以使用固定大小的数组和两个指针来指示起始位置和结束位置。 目的是重用我们之前提到的被浪费的存储。

让我们通过一个示例来查看循环队列的工作原理。 你应该注意我们入队或出队元素时使用的策略。

















看了上面17张图，你是否注意到了我们用来检查队列是空还是满的策略？

下面将给出一个程序练习——设计循环队列

程序练习 - 设计循环队列

设计你的循环队列实现。 循环队列是一种线性数据结构，其操作表现基于 FIFO（先进先出）原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。

循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通队列里，一旦一个队列满了，我们就不能插入下一个元素，即使在队列前面仍有空间。但是使用循环队列，我们能使用这些空间去存储新的值。

你的实现应该支持如下操作：

• MyCircularQueue(k): 构造器，设置队列长度为 k 。
• Front: 从队首获取元素。如果队列为空，返回 -1 。
• Rear: 获取队尾元素。如果队列为空，返回 -1 。
• enQueue(value): 向循环队列插入一个元素。如果成功插入则返回真。
• deQueue(): 从循环队列中删除一个元素。如果成功删除则返回真。
• isEmpty(): 检查循环队列是否为空。
• isFull(): 检查循环队列是否已满。

注意一: 关于释放链表操作

释放队列的时候，注意释放的顺序：先释放obj->quene，再释放obj.

void myCircularQueueFree(MyCircularQueue* obj) {
    free(obj->quene);
    free(obj);
}

注意二：关于删除操作

关于myCircularQueueDeQueue(MyCircularQueue* obj)函数。
仔细观察上文的17张图中的这三张图，两个删除过程：


我们可以发现，
当队列元素不止一个的时候，删除一个元素的操作为：将头指针所在位置的元素值设为-1(本程序中-1表示null)，然后head右移；
但是当队列元素仅剩一个的时候，删除一个元素的操作为：将头指针所在位置的元素设为-1，然后head不需要右移。这就是为什么if(obj->head!=obj->tail) obj->head++;的原因。

bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj)) return false;
    (obj->quene)[obj->head] = -1;
    if(obj->head!=obj->tail) obj->head++;
    return true;
}

所有操作的代码实现

typedef struct myQuene{
    int* quene;
    int head;
    int tail;
    int size;
} MyCircularQueue;

/** Initialize your data structure here. Set the size of the queue to be k. */

MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue* obj=(MyCircularQueue *)malloc(sizeof(MyCircularQueue));
    obj->quene = (int *)malloc(sizeof(int)*k);
    obj->head = 0;
    obj->tail = 0;
    obj->size = k;
    while(k) obj->quene[--k] = -1;
    return obj;
}

/** Checks whether the circular queue is empty or not. */
bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    return ((obj->quene)[obj->head]==-1) && (obj->head==obj->tail);
}

/** Checks whether the circular queue is full or not. */
bool myCircularQueueIsFull(MyCircularQueue* obj) {
    return (!myCircularQueueIsEmpty(obj)) && ((obj->head==obj->tail+1) || (!obj->head && obj->tail==obj->size-1));
}

/** Insert an element into the circular queue. Return true if the operation is successful. */
bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    if(myCircularQueueIsFull(obj)) return false;
    if(myCircularQueueIsEmpty(obj)){
        (obj->quene)[obj->head] = value;
        return true;
    }
    obj->tail++;
    if(obj->tail==obj->size) obj->tail -= obj->size;
    if(obj->tail==obj->head) return false;
    (obj->quene)[obj->tail] = value;
    return true;
}

/** Delete an element from the circular queue. Return true if the operation is successful. */
bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj)) return false;
    (obj->quene)[obj->head] = -1;
    if(obj->head!=obj->tail) obj->head++;
    return true;
}

/** Get the front item from the queue. */
int myCircularQueueFront(MyCircularQueue* obj) {
    return (obj->quene)[obj->head];
}

/** Get the last item from the queue. */
int myCircularQueueRear(MyCircularQueue* obj) {
    return (obj->quene)[obj->tail];
}



void myCircularQueueFree(MyCircularQueue* obj) {
    free(obj->quene);
    free(obj);
}

/**
 * Your MyCircularQueue struct will be instantiated and called as such:
 * MyCircularQueue* obj = myCircularQueueCreate(k);
 * bool param_1 = myCircularQueueEnQueue(obj, value);
 
 * bool param_2 = myCircularQueueDeQueue(obj);
 
 * int param_3 = myCircularQueueFront(obj);
 
 * int param_4 = myCircularQueueRear(obj);
 
 * bool param_5 = myCircularQueueIsEmpty(obj);
 
 * bool param_6 = myCircularQueueIsFull(obj);
 
 * myCircularQueueFree(obj);
*/

队列 - 用法

大多数流行语言都提供内置的队列库，因此您无需重新发明轮子。

重新发明轮子：重造轮子是重新创造一个已有的或是已被其他人优化的基本方法。

如前所述，队列有两个重要的操作，入队 enqueue 和出队 dequeue。 此外，我们应该能够获得队列中的第一个元素，因为应该首先处理它。
C++内置队列库及其常见操作的一些事例

#include <iostream>

int main() {
    // 1. Initialize a queue.
    queue<int> q;
    // 2. Push new element.
    q.push(5);
    q.push(13);
    q.push(8);
    q.push(6);
    // 3. Check if queue is empty.
    if (q.empty()) {
        cout << "Queue is empty!" << endl;
        return 0;
    }
    // 4. Pop an element.
    q.pop();
    // 5. Get the first element.
    cout << "The first element is: " << q.front() << endl;
    // 6. Get the last element.
    cout << "The last element is: " << q.back() << endl;
    // 7. Get the size of the queue.
    cout << "The size is: " << q.size() << endl;
}

C语言并没有自带的内置队列库，需要先自己实现或者使用第三方库。而C++自带内置队列库。

都看到这里了，确定不点个赞再走？ (╯‵□′)╯︵┻━┻