数据结构 - 循环队列

weixin_52952392

于 2023-10-29 11:12:47 发布

阅读量308

点赞数

文章标签：数据结构

本文链接：https://blog.csdn.net/weixin_52952392/article/details/134100158

版权

一. 什么是循环队列

循环队列（Circular Queue），也被称为环形队列，是一种特殊的队列数据结构，其特点在于它的队列元素排列呈环形，队列的头部和尾部相连，形成一个闭环。这种数据结构具有一定的固定大小，一旦队列的尾部追上队列的头部，就会发生循环，即新元素会覆盖队列中最早添加的元素，从而实现了循环利用内存空间的效果。

它的定义通常包括以下几个重要元素：

队列容量（Capacity）： 循环队列有一个固定的容量，这个容量在初始化时确定，表示队列可以存储的元素数量的上限。
队列头部指针（Front）： 这是一个指向队列的第一个元素的指针。初始状态下，它通常指向队列的第一个位置。
队列尾部指针（Rear）： 这是一个指向队列的最后一个元素的指针。初始状态下，它通常指向队列的最后一个位置。
循环特性： 循环队列的关键特点是当队列的尾部追上队列的头部时，元素将开始循环覆盖存储，确保队列在固定的内存空间中高效运作。

二. 循环队列的原理及特点

循环队列的核心原理在于环形排列数据元素。它使用两个指针，一个指向队列的头部，另一个指向队列的尾部。这两个指针可以在循环队列中不断前进，形成一个环。

主要的特点包括以下几个方面：

环状排列： 循循环队列中的元素排列呈环形，即队列的头部和尾部相连，形成一个闭环。这使得队列具有循环特性，新元素在队列尾部追上队列头部后，会循环覆盖存储，以充分利用有限的内存空间。
固定容量： 循环队列具有固定的容量，这意味着在初始化时需要指定队列的最大长度。队列的容量不能随意扩展或缩小，这与普通线性队列（非循环队列）不同。
高效入队和出队操作： 由于循环队列的特殊结构，入队和出队操作通常非常高效。入队操作只需要考虑队列是否已满，而出队操作只需要考虑队列是否为空，这使得操作的时间复杂度通常为O(1)。
适用于循环缓冲区： 循环队列常用于循环缓冲区的管理，如在媒体流媒体播放中，音频和视频数据的缓冲区管理，以及网络数据包的传输和接收等。这是因为循环队列能够持续接收和处理数据，确保数据不会丢失，同时保持固定内存使用。
优化内存利用： 循环队列充分利用了内存空间，避免了不必要的内存浪费。这使得它在资源有限的嵌入式系统、嵌入式设备、实时系统和其他内存受限的应用中特别有用。
适用于环形任务调度： 循环队列常用于操作系统中的任务调度算法，以管理待执行的任务队列。任务队列中的任务可以按照固定的优先级循环执行，确保公平性和高效性。

总的来说，循环队列是一种高效利用内存空间的数据结构，特别适用于需要连续处理数据、管理缓冲区或实现任务调度等场景。其固定容量和循环特性使其在一些实际应用中表现出色。

三. 循环队列的实现

（1）定义接口

#define MAXSIZE 100

typedef int DataType;

typedef struct
{
	DataType data[MAXSIZE];
	int front;
	int rear;
}CirclesQueue;

/*循环队列初始化*/
int init(CirclesQueue *Q);

/*入队*/
int enqueue(CirclesQueue *Q, DataType x);

/*队满？*/
int isfull(CirclesQueue *Q);

/*出队*/
int dequeue(CirclesQueue *Q, DataType *);

/*队空*/
int isempty(CirclesQueue *Q);

/*队列长度*/
int getLength(CirclesQueue *Q, DataType *length);

/*取队首元素*/
int getHead(CirclesQueue *Q, DataType *x);

/*输出队列元素*/
void printQueue(CirclesQueue *Q);

（2）初始化队列

/*循环队列初始化*/
int init(CirclesQueue *Q) {
    Q->front = Q->rear = 0;
    return 0;
}

运行结果：

（3）循环队列入队

/*入队*/
int enqueue(CirclesQueue *Q, DataType x) {
    if (isfull(Q)) {
        printf("队列已满！100001\n");
        return 100001;
    }

    Q->rear = (Q->rear + 1) % MAXSIZE;
    Q->data[Q->rear] = x;
    return 0;
}

运行结果：

（4）循环队列出队

/*出队*/
int dequeue(CirclesQueue *Q, DataType *x) {
    if (isempty(Q)) {
        printf("队列为空！100002\n");
        return 100002;
    }
    Q->front = (Q->front + 1) % MAXSIZE;
    *x = Q->data[Q->front];
    return 0;
}

运行结果：

（5）判断循环队列是否为空

/*队空*/
int isempty(CirclesQueue *Q) {
    return (Q->front == Q->rear) ? 1 : 0;
}

运行结果：

（6）判断循环队列是否为满

/*队满？*/
int isfull(CirclesQueue *Q) {
    return (Q->rear + 1) % MAXSIZE == Q->front ? 1 : 0;
}

运行结果：

（7）循环队列的长度

/*队列长度*/
int getLength(CirclesQueue *Q, DataType *length) {
    *length = (Q->rear - Q->front + MAXSIZE) % MAXSIZE;
    return 0;
}

运行结果：

（8）取循环队列首长度

/*取队首元素*/
int getHead(CirclesQueue *Q, DataType *x) {
    if (isempty(Q)) {
        printf("队列为空！100002\n");
        return 100002;
    }
    *x = Q->data[(Q->front + 1) % MAXSIZE];
    return 0;
}

运行结果：

（9）输出循环队列元素


/*输出队列元素*/
void printQueue(CirclesQueue *Q) {
    if (isempty(Q)) {
        printf("队列为空！\n");
        return;
    }
    int front = (Q->front + 1) % MAXSIZE;
    while (front != (Q->rear + 1) % MAXSIZE) {
        printf("%d ", Q->data[front]);
        front = (front + 1) % MAXSIZE;
    }
}

运行结果：

四. 完整的代码实例

1. main.c

#include <stdio.h>
#include "CirclesQueue.c"


int main(int argc, char *argv[]) {
    CirclesQueue Q;
    DataType x, length;
    int cmd;
    char yn;


    do {
        printf("-----------循环队列演示-----------\n");
        printf(" 1. 初始化\n");
        printf(" 2. 入队\n");
        printf(" 3. 出队\n");
        printf(" 4. 队空\n");
        printf(" 5. 队满\n");
        printf(" 6. 队列长度\n");
        printf(" 7. 取队首长度\n");
        printf(" 8. 输出队列元素\n");
        printf(" 0. 退出\n");
        printf(" 请选择（0~6）：");
        scanf("%d", &cmd);
        switch (cmd) {
            case 1:
                init(&Q);
                printf("队列已初始化！\n");
                break;
            case 2:
                printf("请输入要入队的元素x=");
                scanf("%d", &x);
                if (!enqueue(&Q, x)) {
                    printf("元素x=%d已入队\n", x);
                }
                break;
            case 3:
                printf("确定要出队（出队会将删除对首元素, y or n, n）？");
                fflush(stdin);
                scanf("%c", &yn);

                if (yn == 'y' || yn == 'Y') {
                    if (!dequeue(&Q, &x)) {
                        printf("队首元素【%d】已出队！\n", x);
                    }
                }
                break;
            case 4:
                if (isempty(&Q)) {
                    printf("%s\n", "队列为空！");
                } else {
                    printf("%s\n", "队列不为空！");
                }
                break;
            case 5:
                if (isfull(&Q)) {
                    printf("%s\n", "队列已满！");
                } else {
                    printf("%s\n", "队列未满！");
                }
                break;
            case 6:
                if (!getLength(&Q, &length)) {
                    printf("%d\n", length);
                }
                break;
            case 7:
                if (!getHead(&Q, &x)) {
                    printf("%d\n", x);
                }
                break;
            case 8:
                printQueue(&Q);
                printf("\n");
                break;
        }

    } while (cmd != 0);


    return 0;
}

2. CirclesQueue.c

/*
	CirclesQueue.c
*/
#include "CirclesQueue.h"
#include <stdio.h>

/*循环队列初始化*/
int init(CirclesQueue *Q) {
    Q->front = Q->rear = 0;
    return 0;
}


/*入队*/
int enqueue(CirclesQueue *Q, DataType x) {
    if (isfull(Q)) {
        printf("队列已满！100001\n");
        return 100001;
    }

    Q->rear = (Q->rear + 1) % MAXSIZE;
    Q->data[Q->rear] = x;
    return 0;
}

/*队满？*/
int isfull(CirclesQueue *Q) {
    return (Q->rear + 1) % MAXSIZE == Q->front ? 1 : 0;
}


/*出队*/
int dequeue(CirclesQueue *Q, DataType *x) {
    if (isempty(Q)) {
        printf("队列为空！100002\n");
        return 100002;
    }
    Q->front = (Q->front + 1) % MAXSIZE;
    *x = Q->data[Q->front];
    return 0;
}

/*队空*/
int isempty(CirclesQueue *Q) {
    return (Q->front == Q->rear) ? 1 : 0;
}

/*队列长度*/
int getLength(CirclesQueue *Q, DataType *length) {
    *length = (Q->rear - Q->front + MAXSIZE) % MAXSIZE;
    return 0;
}

/*取队首元素*/
int getHead(CirclesQueue *Q, DataType *x) {
    if (isempty(Q)) {
        printf("队列为空！100002\n");
        return 100002;
    }
    *x = Q->data[(Q->front + 1) % MAXSIZE];
    return 0;
}

/*输出队列元素*/
void printQueue(CirclesQueue *Q) {
    if (isempty(Q)) {
        printf("队列为空！\n");
        return;
    }
    int front = (Q->front + 1) % MAXSIZE;
    while (front != (Q->rear + 1) % MAXSIZE) {
        printf("%d ", Q->data[front]);
        front = (front + 1) % MAXSIZE;
    }
}

3. CirclesQueue.h

/*
	CirclesQueue.h
	循环队列
*/

#define MAXSIZE 100

typedef int DataType;

typedef struct
{
	DataType data[MAXSIZE];
	int front;
	int rear;
}CirclesQueue;

/*循环队列初始化*/
int init(CirclesQueue *Q);

/*入队*/
int enqueue(CirclesQueue *Q, DataType x);

/*队满？*/
int isfull(CirclesQueue *Q);

/*出队*/
int dequeue(CirclesQueue *Q, DataType *);

/*队空*/
int isempty(CirclesQueue *Q);

/*队列长度*/
int getLength(CirclesQueue *Q, DataType *length);

/*取队首元素*/
int getHead(CirclesQueue *Q, DataType *x);

/*输出队列元素*/
void printQueue(CirclesQueue *Q);

五. 总结

通过本文，我们深入了解了循环队列的定义、原理、实现。循环队列是一种非常有用的数据结构，特别适用于需要高效使用内存的应用场景。了解循环队列的基本原理和操作将有助于您更好地理解和利用这一数据结构。

参考文献

1.百度一下

2.C语言数据结构

weixin_52952392

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
1
评论
数据结构 - 循环队列

循环队列（Circular Queue），也被称为环形队列，是一种特殊的队列数据结构，其特点在于它的队列元素排列呈环形，队列的头部和尾部相连，形成一个闭环。这种数据结构具有一定的固定大小，一旦队列的尾部追上队列的头部，就会发生循环，即新元素会覆盖队列中最早添加的元素，从而实现了循环利用内存空间的效果。
复制链接

扫一扫