【C++】队列 理解与实现（queue）

定义

队列是一种只允许在一段进行插入，在另一端进行删除的先进先出线性表，插入端为队尾，删除端为队头。

 从上图我们可以看到，如果使用数组进行实现，当队头出队后，队头++，造成了原来地方的空间浪费，对此我们可以让front或者back到达数组末端的时候回到数组头即可。

这种队列我们称之为循环队列。

对于循环队列，我们要对判满做出调整，如果队头指针和队尾指针指向了同一块地址，这就可能是队空或者队满，需要额外添加一个flag变量，当flag==1&&rear==front时队满，否则队空。

还有一种判断方法是，保存一块内存空间，当front和rear处于如下图的两种状态，我们认为队满。

 当他们相差一个位置且空余一块内存空间的情况下就是队满，但他们之间可能紧挨着【右图】或者相差一圈【左图】，所以我们假定队列的最大长度为maxsize，随后将rear+1，这样，无论他们相差一圈或一个位置，对maxsize取模后rear都将==front。

所以，队满的判断条件为：（rear+1）%maxsize==front

那么，我们如何求得队列的真实长度呢？

如上图左方，队列的长度就是rear-front，而对于右方，队列长度被分割成了两块，这个队列左边的长度就是rear，右边的长度则是最大长度减去front，也就是rear-front+maxsize。

我们发现，在左方的队列中，maxsize-front刚好等于maxsize，所以我们只要对最后的结果进行对maxsize的取模，就可以得到真实的队列长度，而我们刚才总结的右方的队列长度公式对maxsize取模没有影响，所以这样我们就可以让左右公式在形式上取得一致。

所以，通用队列长度公式为：（rear-front+maxsize）%maxsize

通过以上两个总结公式，我们就可以简单的完成循环队列的实现

下为代码实现：数组实现

#include <iostream>
using namespace std;
#define MAX_SIZE 5
 //测试案例，maxsize只取到5，如有需要自行调整
typedef struct queue{
    int count;
    int front;
    int rear;
    int data[MAX_SIZE];
}Queue;
 
void Init(Queue* ptr) { //初始化队列
    ptr->count = 0;
    ptr->front = 0;
    ptr->rear = -1;
}
 
bool QueueFull(Queue* ptr) {  //判断队列是否满 
    return ptr->count >= MAX_SIZE;
}
 
bool QueueEmpty(Queue* ptr) {   //判断队列是否为空
    return ptr->count <= 0;
}
 
void Append (Queue* ptr, int item) {    //入队
    if (QueueFull(ptr)) {
        cerr << "队列满了!" << endl;
        return;
    }else {
        ptr->count ++;
        ptr->rear = (ptr->rear + 1) % MAX_SIZE;
        ptr->data[ptr->rear] = item;
    }
}
 
void Pop(Queue* ptr) {  //出队
    if (QueueEmpty(ptr)) {
        cerr << "队列为空!" << endl;
        return;
    }else {
        ptr->count --;
        ptr->front = (ptr->front + 1) % MAX_SIZE;
    }
}
 
int QueueSize (Queue* ptr) {    //返回队列长度
    return ptr->count;
}
 
void Show(Queue* ptr) { //遍历队列
    if(QueueEmpty(ptr)) {
        cout << "队列为空!" << endl;
        return;
    }else {
        cout << "队列遍历: ";
        int i = ptr->front;
        while (i != ptr->rear) {
            cout << ptr->data[i] << " ";
            i ++;
            i = i % MAX_SIZE;
        }
        cout << ptr->data[ptr->rear] << " ";
    }
    cout << endl;
} 
 
 
int main() {
    Queue* dummy = (Queue *)malloc(sizeof(Queue));  //申请结点空间
    Init(dummy);
 
    Append(dummy, 11);
    Append(dummy, 5);
    Append(dummy, 23);
    Append(dummy, 18);
    Pop(dummy);
    Show(dummy);
    
    Append(dummy, 33);
    Pop(dummy);
    Show(dummy);
    
    Append(dummy, 77);
    Show(dummy);
 
    return 0;
}
 

链表实现：【难度较低，没有新知识点，不再进行分析讨论】

#include<iostream>
using namespace std;
class MyCircularQueue {
private:
    struct ListNode {
        int val;
        ListNode *next;
    };

    ListNode *front;
    ListNode *rear;
    bool empty;

public:
    MyCircularQueue(int k) {
        front = new ListNode;
        rear = front;
        for (int i = 0; i < k - 1; i++) {
            ListNode *node = new ListNode;
            rear->next = node;
            rear = node;
        }
        rear->next = front;
        rear = front;
        empty = true;
    }

    ~MyCircularQueue() {
        ListNode* node = this->rear;
        node->next = nullptr;
        node = this->front;
        while (node) {
            ListNode* next = node->next;
            delete node;
            node = next;
        }
    }

    bool enQueue(int value) {
        if (isFull()) {
            return false;
        }
        if (isEmpty()) {
            empty = false;
        } else {
            rear = rear->next;
        }
        rear->val = value;
        return true;
    }

    bool deQueue() {
        if (isEmpty()) {
            return false;
        }
        if (front == rear) {
            empty = true;
            return true;
        }
        front = front->next;
        return true;
    }

    int Front() {
        if (isEmpty()) {
            return -1;
        }
        return front->val;
    }

    int Rear() {
        if (isEmpty()) {
            return -1;
        }
        return rear->val;
    }

    bool isEmpty() {
        return empty;
    }

    bool isFull() {
        return !empty && rear->next == front;
    }
};
int main(){
return 0;}