C++队列

队列（Queue）是一种常见的线性数据结构，其特点是遵循 先进先出（FIFO, First In First Out） 的原则，即最先插入的元素最先被删除。队列在计算机科学中的应用非常广泛，比如在操作系统中的任务调度、网络数据包的传输等。

在 C++ 中，队列可以通过 数组 或 链表 来实现，但标准库提供了一个实现了队列功能的容器：std::queue。这里我们将讲解如何使用标准库中的队列以及如何手动实现队列。

一、队列的基本操作

队列的基本操作有以下几种：

1. 入队（enqueue）：将一个元素插入队列的尾部。
2. 出队（dequeue）：移除队列头部的元素。
3. 访问队列头部元素：获取队列头部的元素，但不删除。
4. 检查队列是否为空：检查队列是否包含任何元素。
5. 获取队列的大小：返回队列中元素的数量。

二、使用标准库中的 std::queue

C++ 标准库提供了 std::queue，它封装了队列的基本操作。我们可以直接使用它，而不需要自己实现。

1. 包含头文件

要使用 std::queue，首先需要包含头文件：

#include <iostream>
#include <queue>  // 包含队列的定义
using namespace std;

2. 创建队列

创建一个队列很简单，std::queue 是一个模板类，可以存储任意类型的数据：

queue<int> q;  // 创建一个存储整数的队列

3. 入队操作

使用 push() 方法将元素插入队列的尾部：

q.push(10);  // 将元素 10 入队
q.push(20);  // 将元素 20 入队
q.push(30);  // 将元素 30 入队

4. 出队操作

使用 pop() 方法将队列头部的元素移除：

q.pop();  // 移除队列头部的元素

注意，pop() 方法仅仅是移除元素，并不会返回该元素。如果你需要访问队列头部的元素，可以使用 front() 方法。

5. 访问队列头部元素

使用 front() 方法访问队列头部的元素：

cout << "队列头部的元素是：" << q.front() << endl;  // 访问队列头部元素

6. 检查队列是否为空

使用 empty() 方法检查队列是否为空：

if (q.empty()) {
    cout << "队列为空" << endl;
} else {
    cout << "队列不为空" << endl;
}

7. 获取队列的大小

使用 size() 方法获取队列中元素的个数：

cout << "队列中元素的个数是：" << q.size() << endl;

 8. 示例代码

#include <iostream>
#include <queue>
using namespace std;

int main() {
    // 创建一个存储整数的队列
    queue<int> q;

    // 入队操作
    q.push(10);
    q.push(20);
    q.push(30);

    // 访问队列头部元素
    cout << "队列头部的元素是：" << q.front() << endl;  // 输出 10

    // 出队操作
    q.pop();
    cout << "出队后队列头部的元素是：" << q.front() << endl;  // 输出 20

    // 检查队列是否为空
    if (q.empty()) {
        cout << "队列为空" << endl;
    } else {
        cout << "队列不为空" << endl;  // 输出 队列不为空
    }

    // 获取队列的大小
    cout << "队列中元素的个数是：" << q.size() << endl;  // 输出 2

    return 0;
}

输出： 

队列头部的元素是：10
出队后队列头部的元素是：20
队列不为空
队列中元素的个数是：2

三、手动实现队列

除了使用 std::queue 之外，你也可以手动实现一个队列。我们可以通过数组或链表来实现。这里我们使用 链表 来实现队列，因为链表更灵活，不需要事先分配固定大小的空间。

1. 定义链表节点

首先定义链表节点结构体，每个节点包含数据和指向下一个节点的指针：

struct Node {
    int data;
    Node* next;
    Node(int val) : data(val), next(nullptr) {}
};

2. 实现队列类

我们实现一个队列类，包含头指针（front）和尾指针（rear），以及入队、出队等基本操作：

class Queue {
private:
    Node* front;
    Node* rear;
    
public:
    Queue() : front(nullptr), rear(nullptr) {}
    
    // 入队操作
    void enqueue(int value) {
        Node* newNode = new Node(value);
        if (rear == nullptr) {  // 如果队列为空
            front = rear = newNode;
        } else {
            rear->next = newNode;
            rear = newNode;
        }
    }
    
    // 出队操作
    void dequeue() {
        if (front == nullptr) {
            cout << "队列为空，无法出队" << endl;
            return;
        }
        Node* temp = front;
        front = front->next;
        delete temp;  // 释放内存
        if (front == nullptr) {  // 如果队列为空，尾指针也需要置为nullptr
            rear = nullptr;
        }
    }
    
    // 访问队列头部元素
    int peek() {
        if (front == nullptr) {
            cout << "队列为空" << endl;
            return -1;  // 表示队列为空
        }
        return front->data;
    }
    
    // 检查队列是否为空
    bool isEmpty() {
        return front == nullptr;
    }
    
    // 获取队列的大小
    int size() {
        int count = 0;
        Node* temp = front;
        while (temp != nullptr) {
            count++;
            temp = temp->next;
        }
        return count;
    }
    
    ~Queue() {
        while (front != nullptr) {
            dequeue();
        }
    }
};

 3. 使用队列类

int main() {
    Queue q;
    
    q.enqueue(10);
    q.enqueue(20);
    q.enqueue(30);
    
    cout << "队列头部元素：" << q.peek() << endl;  // 输出 10
    q.dequeue();
    cout << "队列头部元素：" << q.peek() << endl;  // 输出 20
    
    cout << "队列是否为空：" << (q.isEmpty() ? "是" : "否") << endl;  // 输出 否
    cout << "队列的大小：" << q.size() << endl;  // 输出 2
    
    return 0;
}

输出： 

队列头部元素：10
队列头部元素：20
队列是否为空：否
队列的大小：2

四、总结

在 C++ 中，队列是遵循先进先出（FIFO）原则的线性数据结构。我们可以使用标准库中的 std::queue 来简化实现，它提供了基本的队列操作，如入队、出队、访问头部元素等。除了标准库实现外，还可以通过链表或数组来手动实现队列。手动实现时，链表通常更灵活，因为它不需要预分配固定大小的内存空间。

希望这些内容对你理解 C++ 中的队列有所帮助！如果你有任何问题，或者需要进一步了解某个细节，随时告诉我！