循环队列是一种队列的实现方式,它可以在固定大小的数组上实现队列的循环使用。当队列尾部达到数组的末尾时,如果数组前面还有空闲位置,尾部就会回到数组的开头,形成一个循环。
#include <stdio.h>
#include <stdlib.h>
#define MAX_SIZE 5
// 定义循环队列结构体
typedef struct {
int items[MAX_SIZE];
int front, rear;
} Queue;
// 初始化队列
void initQueue(Queue *q) {
q->front = -1;
q->rear = -1;
}
// 检查队列是否为空
int isEmpty(Queue *q) { return (q->front == -1 && q->rear == -1); }
// 检查队列是否已满
int isFull(Queue *q) { return ((q->rear + 1) % MAX_SIZE == q->front); }
// 入队
void enqueue(Queue *q, int value) {
if (isFull(q)) {
printf("Queue is full. Cannot enqueue.\n");
return;
}
if (isEmpty(q)) {
q->front = 0;
q->rear = 0;
} else {
q->rear = (q->rear + 1) % MAX_SIZE;
}
q->items[q->rear] = value;
}
// 出队
int dequeue(Queue *q) {
int removedItem;
if (isEmpty(q)) {
printf("Queue is empty. Cannot dequeue.\n");
return -1;
} else if (q->front == q->rear) {
removedItem = q->items[q->front];
q->front = -1;
q->rear = -1;
} else {
removedItem = q->items[q->front];
q->front = (q->front + 1) % MAX_SIZE;
}
return removedItem;
}
// 获取队首元素
int peek(Queue *q) {
if (isEmpty(q)) {
printf("Queue is empty.\n");
return -1;
}
return q->items[q->front];
}
// 打印队列中的元素
void display(Queue *q) {
if (isEmpty(q)) {
printf("Queue is empty.\n");
return;
}
int i = q->front;
printf("Queue elements: ");
do {
printf("%d ", q->items[i]);
i = (i + 1) % MAX_SIZE;
} while (i != (q->rear + 1) % MAX_SIZE);
printf("\n");
}
int main() {
Queue q;
initQueue(&q);
enqueue(&q, 1);
enqueue(&q, 2);
enqueue(&q, 3);
enqueue(&q, 4);
enqueue(&q, 5); // 队列已满
// enqueue(&q, 6); // 不能再插入
display(&q);
dequeue(&q);
dequeue(&q);
display(&q);
enqueue(&q, 6);
display(&q);
enqueue(&q, 7); // 队列已满
display(&q);
enqueue(&q, 8); // 不能再插入
display(&q);
printf("Front: %d Rear: %d\n", q.front, q.rear);
return 0;
}
C++中把循环队列包装到类
#include <iostream>
#define MAX_SIZE 5
class Queue {
private:
int items[MAX_SIZE];
int front, rear;
public:
Queue() {
front = -1;
rear = -1;
}
bool isEmpty() {
return (front == -1 && rear == -1);
}
bool isFull() {
return ((rear + 1) % MAX_SIZE == front);
}
void enqueue(int value) {
if (isFull()) {
std::cout << "Queue is full. Cannot enqueue.\n";
return;
}
if (isEmpty()) {
front = 0;
rear = 0;
} else {
rear = (rear + 1) % MAX_SIZE;
}
items[rear] = value;
}
int dequeue() {
int removedItem;
if (isEmpty()) {
std::cout << "Queue is empty. Cannot dequeue.\n";
return -1;
} else if (front == rear) {
removedItem = items[front];
front = -1;
rear = -1;
} else {
removedItem = items[front];
front = (front + 1) % MAX_SIZE;
}
return removedItem;
}
int peek() {
if (isEmpty()) {
std::cout << "Queue is empty.\n";
return -1;
}
return items[front];
}
void display() {
if (isEmpty()) {
std::cout << "Queue is empty.\n";
return;
}
int i = front;
std::cout << "Queue elements: ";
do {
std::cout << items[i] << " ";
i = (i + 1) % MAX_SIZE;
} while (i != (rear + 1) % MAX_SIZE);
std::cout << "\n";
}
};
int main() {
Queue q;
q.enqueue(1);
q.enqueue(2);
q.enqueue(3);
q.display();
q.dequeue();
q.display();
q.enqueue(4);
q.display();
std::cout << "Front element: " << q.peek() << "\n";
return 0;
}
在 C++ 中,数组的大小必须在编译时确定,不能在运行时指定。因此,在构造函数中动态指定数组大小是不可能的。如果你希望数组的大小在运行时可以动态改变,你可以使用 std::vector,它是 C++ 标准库中的容器,可以动态调整大小。
#include <iostream>
#include <vector>
class Queue {
private:
std::vector<int> items; // 使用 std::vector 代替原来的数组
int front, rear;
public:
Queue(int size) : items(size), front(-1), rear(-1) {
// 构造函数中初始化 items 容器,并指定大小为 size
}
// 其他成员函数的实现与之前相同
};
int main() {
Queue q(5); // 在构造函数中指定队列大小为 5
// 其他代码不变
}
循环队列和直接读取数组的性能比较
从性能的角度来看,读取循环队列和读取数组的性能可能是不同的。
-
读取循环队列:在循环队列中,元素的存储不一定是连续的,因此读取元素时需要考虑队首和队尾的位置,并使用循环索引来访问队列的元素。这种情况下,读取元素的时间复杂度是O(1),因为只需通过索引访问即可。
-
读取数组:数组中的元素是连续存储的,因此直接通过索引即可访问元素。读取数组的时间复杂度同样是O(1),因为访问数组的任何位置都是常数时间操作。
因此,就读取单个元素而言,循环队列和数组的性能是相似的,都是O(1)。然而,在实际使用中,如果涉及到连续读取多个元素,循环队列可能会因为需要考虑环形结构而产生一些额外的开销,因此在特定情况下数组可能会稍微快一些。
包装到C++头文件
// Queue.h
#ifndef QUEUE_H
#define QUEUE_H
#include <iostream>
class Queue {
private:
static constexpr int MAX_SIZE = 100000;
int items[MAX_SIZE];
int front, rear;
public:
Queue() {
front = -1;
rear = -1;
}
bool isEmpty() { return (front == -1 && rear == -1); }
bool isFull() { return ((rear + 1) % MAX_SIZE == front); }
void enqueue(int value) {
if (isFull()) {
std::cout << "Queue is full. Cannot enqueue.\n";
return;
}
if (isEmpty()) {
front = 0;
rear = 0;
} else {
rear = (rear + 1) % MAX_SIZE;
}
items[rear] = value;
}
int dequeue() {
int removedItem;
if (isEmpty()) {
std::cout << "Queue is empty. Cannot dequeue.\n";
return -1;
} else if (front == rear) {
removedItem = items[front];
front = -1;
rear = -1;
} else {
removedItem = items[front];
front = (front + 1) % MAX_SIZE;
}
return removedItem;
}
int peek() {
if (isEmpty()) {
std::cout << "Queue is empty.\n";
return -1;
}
return items[front];
}
void display() {
if (isEmpty()) {
std::cout << "Queue is empty.\n";
return;
}
int i = front;
std::cout << "Queue elements: ";
do {
std::cout << items[i] << " ";
i = (i + 1) % MAX_SIZE;
} while (i != (rear + 1) % MAX_SIZE);
std::cout << "\n";
}
};
#endif
调用
// main.cpp
#include "Queue.h"
int main() {
Queue q;
q.enqueue(10);
q.enqueue(20);
q.enqueue(30);
q.enqueue(40);
q.enqueue(50);
q.display();
std::cout << "Dequeued: " << q.dequeue() << std::endl;
q.display();
q.enqueue(60);
q.display();
std::cout << "Front item: " << q.peek() << std::endl;
return 0;
}
补充,检查队列是否已满或已空可以合并到插入和删除里
#include <iostream>
#include <vector>
class CircularQueue {
public:
CircularQueue(int size) : maxSize(size), front(-1), rear(-1) {
queue.resize(size);
}
bool enqueue(int value) {
if ((rear + 1) % maxSize == front) {
std::cout << "Queue is full" << std::endl;
return false;
}
if (front == -1) {
front = rear = 0;
} else {
rear = (rear + 1) % maxSize;
}
queue[rear] = value;
return true;
}
bool dequeue() {
if (front == -1) {
std::cout << "Queue is empty" << std::endl;
return false;
}
if (front == rear) {
front = rear = -1;
} else {
front = (front + 1) % maxSize;
}
return true;
}
void display() {
if (front == -1) {
std::cout << "Queue is empty" << std::endl;
return;
}
int i = front;
while (true) {
std::cout << queue[i] << " ";
if (i == rear) break;
i = (i + 1) % maxSize;
}
std::cout << std::endl;
}
private:
std::vector<int> queue;
int maxSize;
int front;
int rear;
};
int main() {
CircularQueue q(3);
q.enqueue(1);
q.enqueue(2);
q.enqueue(3); // Queue is full
q.display(); // 输出: 1 2
q.dequeue();
q.enqueue(3);
q.display(); // 输出: 2 3
return 0;
}