C语言循环队列

已于 2024-06-09 12:47:51 修改
阅读量233 收藏
点赞数 3
分类专栏： # 数组操作 文章标签： c语言 算法 开发语言
于 2024-05-14 02:15:17 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_57097753/article/details/138828284
版权

循环队列是一种队列的实现方式，它可以在固定大小的数组上实现队列的循环使用。当队列尾部达到数组的末尾时，如果数组前面还有空闲位置，尾部就会回到数组的开头，形成一个循环。

#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

    // 其他代码不变
}

循环队列和直接读取数组的性能比较

从性能的角度来看，读取循环队列和读取数组的性能可能是不同的。

  1. 读取循环队列：在循环队列中，元素的存储不一定是连续的，因此读取元素时需要考虑队首和队尾的位置，并使用循环索引来访问队列的元素。这种情况下，读取元素的时间复杂度是O(1)，因为只需通过索引访问即可。

  2. 读取数组：数组中的元素是连续存储的，因此直接通过索引即可访问元素。读取数组的时间复杂度同样是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;
}
C or Cpp
关注
  • 3
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
循环队列（C语言）
qq_48757526的博客
05-18 2587
循环队列里需要注意的是每次头指针和尾指针的位置，因为是循环队列，所以每次入队，头指针和尾指针都会+1，但是每次出队，只有尾指针-1，当头指针与尾指针相遇的时候，表示这个队列已经是空的了，我们可以利用这个来判空。 头文件函数声明 #define MAX_SIZE 100 typedef int ELEM_TYPE; typedef struct Queue { ELEM_TYPE* base;//接受malloc 申请的空间 int front;//表头指针 int rear;//表尾指针 //
循环队列（c语言）
m0_69023444的博客
08-31 1075
这里（back+1）% n是控制back如果到达空间尾时，back回到0位置.(如图，此时back==4,back+1==5就会越界，当（back+1）%n就等于0，（n==K+1==5) , 会回到0位置，实现循环).2.开头创建的数组长度为k+1,能有效存储的数据个数为k,当back+1==front时为满，back==front为 空。代入0来看，（0-1+5）% 5 == 4. （k=4,n=k+1) 没问题。如上图(队列为空），front == baack;......
循环队列-C语言
qq_42811420的博客
04-25 172
循环队列-C语言 具体代码 #include<stdio.h> #include<stdlib.h> #define MAXSIZE 10 typedef struct Queue{ int head; int rear; int data[MAXSIZE]; int size; }Queue; void Init(Queue *Q){ Q->hea...
C语言循环队列的表示与实现实例详解
01-01
循环队列可以更简单的防止伪溢出的发生，但是队列大小是固定的。 2.实例代码： /* 队列的顺序存储结构(循环队列) */ #define MAX_QSIZE 5 /* 最大队列长度+1 */ typedef struct { QElemType *base; /* 初始化的...
c语言 循环队列
07-11
在C语言中实现循环队列，我们需要定义一个数组来存储元素，同时维护两个指针——front（队首）和rear（队尾）。front指向队列中的第一个元素，而rear指向下一个要加入元素的位置。当rear追上front时，队列满了；当...
C语言循环队列的代码实现
06-17
在C语言中，我们可以用结构体来定义一个循环队列，包括队列的容量、当前头指针和尾指针以及存储元素的数组。 `SeqQueue.c` 文件通常会包含循环队列的初始化、入队、出队、判断队列是否为空和满等操作的函数实现。...
循环队列（c语言版）
qq_40596811的博客
09-23 325
C语言版循环队列 #ifndef QUEUE #define QUEUE #define maxsize 4 typedef struct { int data[maxsize]; int front; int rear; }*Queue, Node; #endif #include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; #include&l...
c 语言 循环队列,循环队列C语言
weixin_40008920的博客
05-22 164
#include#include#include //各个头文件#define MAXQSIZE 100//最大队列长度#define OK 1#define ERROR 0#define OVERFLOW -2//定义宏参int N;typedef int Status;typedef int QElemType;//引用整型数据类型别名typedef struct{QElemType *bas...
C语言 队列（循环队列）
qq_42605411的博客
12-30 1351
队列（循环队列） 队列是只允许在一端进行插入操作，在另一端进行删除操作的线性表。允许插入的一端称为队尾，允许删除的一端称为队头。 特性：先进先出。 循环队列 队空：front==rear 队满：rear+1==front 所以需要浪费一个数组空间，例如：6个数组长度的队列，只能存放5个元素。 入队示意图 出队示意图 代码： #include "stdafx.h" const int QUEUESIZE = 6; typedef int ElemType; ElemType data[QUEUESIZE]
数据结构—循环队列（C语言）
chenshengnanii的博客
05-16 2278
一、头文件 二、循环结点 三、初始化 四、插入 五、删除 六、打印 七、测试代码 八、主函数 九、全部代码 十、测试结果 十一、总结 一、头文件 #include <stdio.h> #include <malloc.h> #define MAXSIZE 5 二、循环结点 typedef struct CircleIntQueue { int data[MAXSIZE]; int head; int tail; }*CircleIntQueue
c语言-循环队列
Xiaoweidumpb
11-29 116
#include"SeqQueue.h" void IniQueue(Queue *Q){ Q->base=(ElemType *)malloc(sizeof(ElemType) * MAXSIZE); assert(Q->base!=NULL); Q->front=Q->rear=0; } void EnQueue(Queue *Q,ElemType x){ if(((Q->rear+1)%MAXSIZE)==Q->front
循环队列（C语言版）
技术宅--火狼的专栏
04-21 2802
#include using namespace std; #define MAXSIZE 50 typedef int QueueElementType; typedef struct { QueueElementType elem[MAXSIZE]; int front; //指向当前队头元素 int rear; //指向队尾元素的下一个位置 }
C语言——循环队列
热门推荐
weixin_43807553的博客
12-26 1万+
循环队列 遵循先进先出（FIFO） 浪费一个空间，让循环队列更好的判断满/空，更好运用循环队列 黑色代表空时状态，红色代表满时状态 下面代码： #include &amp;amp;amp;lt;stdio.h&amp;amp;amp;gt; #define M_S 20 //定义数组长度，限制元素个数 //定义结构体 struct Quene { int a[M_S]; int front; //前指针，...
循环队列(C语言版)
u010571660的专栏
10-10 1217
线性结构的主要操作就是插入和删除，我 们前面讲过的顺序线性表、单链表、双链表都没有限制插入和删除操作的位置。如果我们限定插入和删除操作在线性表的同一端进行那么这种结构就是栈；如果限定 插入在一端而删除在另一端，这种结构就是对列；栈的特点是先进后出(FILO)而对列是先进先出(FIFO)。进行插入的一端叫队尾，删除的一端叫队头。 　 　 队列的实现可以用顺序线性表也可以用链表。在实际使用中有一种更
c语言循环队列
最新发布
05-24
下面是一个基于数组实现的循环队列的C语言代码： ```c #define MAXSIZE 100 typedef struct { int data[MAXSIZE]; int front; // 队头指针，指向队头元素 int rear; // 队尾指针，指向队尾元素的下一个位置 } ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值