数据结构——队列的循环顺序存储（优缺点及代码实现:C语言）

于 2024-04-26 16:19:58 发布
阅读量425 收藏 10
点赞数 4
分类专栏： 数据结构 文章标签： 数据结构 c语言 考研
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fuckfunk/article/details/138193991
版权

目录

队列

队列是运算受限的线性表，和线性表一样也是线性结构，只不过插入只能在队尾插入称为入队，删除只能在队头删除称为出队，和日常生活中的排队顺序一样，是先进先出（FIFO）的线性表。队列存储结构分为顺序存储和链式存储，本文主要介绍最常用的 循环顺序存储队列.

溢出现象

当队空的时候出队 就会产生下溢；
上溢分为真上溢和假上溢，真上溢：当队满的时候入队会产生真上溢。
假上溢主要发生在当入队和出队操作，头指针指增加不减少，致使被删除元素的空间永远无法被利用，当队列中实际元素个数远远小于向量空间的规模时，也有可能超越向量空间的上界而不能做入队操作，那么这种现象就称之为“假上溢”现象.
为了解决假上溢现象，引入循环队列（放弃一个结点空间，当rear+1达到 MAXSIZE时，将rear重新指向 “队头” 已出队那一端）
优点：
节省存储空间：循环顺序存储结构可以利用数组来存储队列元素，不需要额外的指针空间，节省了存储空间。
操作简单高效：循环顺序存储结构可以通过数组的下标来直接访问队列元素，操作简单高效，插入和删除操作的时间复杂度为O(1)。
缺点：
需要预先确定队列的最大长度：循环顺序存储结构需要预先确定队列的最大长度，如果队列长度超出预设长度，需要进行扩容操作，可能会导致元素搬移，影响性能。
需要处理循环队列的溢出问题：循环顺序存储结构需要处理循环队列的溢出问题，即队列头尾指针相遇时的处理，可能会增加代码的复杂度。

代码实现（C语言）

定义

#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>

#define MAXSIZE 100
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2

typedef int Status;
typedef  int DataType;

typedef struct{
	DataType *data;  
	int front;   //队头
	int rear;   //队尾
}SeqQueue;

初始化

Status InitQueue(SeqQueue *Q)
{
	Q->data = (DataType *)malloc(sizeof(DataType) * MAXSIZE);//申请内存结点
	if(!Q->data)  //如果申请失败
		exit(OVERFLOW);
	Q->front = Q->rear = 0;   
	return OK;
}

判队空

Status IsEmpty(SeqQueue *Q)
{
	return Q->front == Q->rear;  //头指针和尾指针相等时 队空
}

判队满

Status IsFull(SeqQueue *Q)
{
	return (Q->rear+1) % MAXSIZE == Q-> front; //队满条件 （有一个结点空间没有使用，另外一种方法是设置一个计数器，入队计数器+1，判队满就是看计数器和MAXSIZE相不相等）
}

求队列长度

int GetLength(SeqQueue *Q)
{
	return (Q->rear - Q->front + MAXSIZE) % MAXSIZE;
}

入队

时间复杂度O（1）

Status EnQueue(SeqQueue *Q,DataType x)
{
	if(IsFull(Q)) //队满返回 TRUE 1
	{
		printf("队满,不能入队！")
		return ERROR;
	}
	Q->data[Q->rear] = x;    //入队元素赋值
	Q->rear = (Q->rear +1) % MAXSIZE;  //队尾指针 + 1 
	return OK; 
}

出队

时间复杂度O（1）

Status DeQueue(SeqQueue *Q, DataType *x)
{
	if(IsEmpty(Q))
	{
		printf("队空不能出队！");
		return ERROR;
	}
	*x = Q->data[Q->front];  //队头指针的元素值取出来
	Q->front = (Q->front +1) % MAXSIZE;
	return OK;
}

取队头元素

DataType GetHead(SeqQueue *Q)
{
	if(IsEmpty(Q))
	{
		printf("队空不能取队头！");
		return ERROR;
	}
	return Q->data[Q->front];
}

显示队中所有元素

void ShowQueue(SeqQueue *Q)
{
	int p =Q->front;
	if(p == Q->rear)
		printf("队空，无元素！");
	else
	{
		printf("从队头起，队列中各元素为：");
		while(p != Q->rear)
		{
			printf("%5d",Q->data[p]);
			p++;
		}
	}
}

完整示例（C语言实现）

#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>

#define MAXSIZE 100
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2

typedef int Status;
typedef  int DataType;

typedef struct{
	DataType *data;
	int front;   //队头
	int rear;   //队尾
}SeqQueue;


//初始化队列
Status InitQueue(SeqQueue *Q)
{
	Q->data = (DataType *)malloc(sizeof(DataType) * MAXSIZE);
	if(!Q->data)
		exit(OVERFLOW);
	Q->front = Q->rear =0;
	return OK;
}


//判队空
Status IsEmpty(SeqQueue *Q)
{
	return Q->front == Q->rear;
}


//判队满
Status IsFull(SeqQueue *Q)
{
	return (Q->rear + 1) % MAXSIZE == Q->front; 
}


//求队列长度
int GetLength(SeqQueue *Q)
{
	return (Q->rear - Q->front + MAXSIZE) % MAXSIZE; 
}


//入队
Status EnQueue(SeqQueue *Q, DataType x)
{
	if(IsFull(Q))
	{
		printf("队满，不能入队元素!");
        return ERROR;
	}
	Q->data[Q->rear] = x;
	Q->rear = (Q->rear + 1) % MAXSIZE;
	return OK;
}

//出队
Status DeQueue(SeqQueue *Q, DataType *x)
{
	if(IsEmpty(Q))
	{
		printf("队空，不能出队元素!");
		return ERROR;
	}
	*x = Q->data[Q->front];
	Q->front = (Q->front+ 1) %MAXSIZE;
	return OK;
}

//取队头元素
DataType GetHead(SeqQueue *Q)
{
	if(IsEmpty(Q))
	{
		printf("队空，不能取队头元素!");
		return ERROR;
	}
	return Q->data[Q->front];
}

//显示队中所有元素

void ShowQueue(SeqQueue  *Q)
{
	int p =Q->front;
	if(p == Q->rear)
		printf("队列为空，无元素！\n");
	else
	{
		printf("从队头起，队列中各元素为：");
		while(p != Q->rear)
		{
			printf("%5d",Q->data[p]);
			p++;
		}
	}
}

// 显示菜单子函数
void  Menu()                                    
{  
	printf("\n                  顺序队列的各种操作");
    printf("\n =================================================");  
    printf("\n|               1——初始化队列                  |");
    printf("\n|               2——判队空                      |");
    printf("\n|               3——判队满                      |");
    printf("\n|               4——求队列长度                  |");
    printf("\n|               5——入队操作                    |");
    printf("\n|               6——出队操作                    |");
    printf("\n|               7——求队头元素                  |");
    printf("\n|               8——显示队中所有元素            |");
    printf("\n|               0——返回                        |");
    printf("\n ================================================="); 
    printf("\n请输入菜单号（0-8）:"); 	
}

int main() {
    int i, n, flag;
    SeqQueue Q;
    DataType x;
    char ch1, ch2, a;
    ch1 = 'y';

    while (ch1 == 'y' || ch1 == 'Y') {
        Menu();
        scanf("%c", &ch2);
        getchar();

        switch (ch2) {
            case '0':
                ch1 = 'n';
                break;
            case '1':
                InitQueue(&Q);
                printf("队列的初始化完成！\n");
                break;
            case '2':
                if (IsEmpty(&Q))
                    printf("队列为空！\n");
                else
                    printf("队列不为空！\n");
                break;
            case '3':
                if (IsFull(&Q))
                    printf("队列已满！\n");
                else
                    printf("队列未满！\n");
                break;
            case '4':
                printf("队列的长度为：%d\n", GetLength(&Q));
                break;
            case '5':
                printf("请输入要入队的元素个数：");
                scanf("%d", &n);
                printf("请输入%d个入队的整数：", n);
                for (i = 0; i < n; i++) {
                    scanf("%d", &x);
                    flag = EnQueue(&Q, x);
                }
                if (flag == 1)
                    printf("入队操作成功！\n");
                else
                    printf("入队操作失败！\n");
                break;
            case '6':
                printf("请输入要出队的元素个数：");
                scanf("%d", &n);
                printf("出队的元素顺序依次为：");
                for (i = 0; i < n; i++) {
                    flag = DeQueue(&Q, &x);
                    printf("%5d", x);
                }
                if (flag == 1)
                    printf("\n出队操作成功!\n");
                else
                    printf("\n出队操作失败!\n");
                break;
            case '7':
                x = GetHead(&Q);
                printf("当前的队头元素值为：%d\n", x);
                break;
            case '8':
                ShowQueue(&Q);
                break;
            default:
                printf("输入有误，请输入0-8进行选择！\n");
        }

        if (ch2 != '0') {
            printf("\n按回车键继续，按任意键返回主菜单！\n");
            a = getchar();
            if (a != '\n') {
                getchar();
                ch1 = 'n';
            }
        }
    }

    return 0;
}

结语

循环顺序队列：
空队列 Q->front ==Q->rear
满队列 (Q->rear+1)%MAXSIZE
队长 (Q->rear -Q->front +MAXSIZE) %MAXSIZE

敬请各位大佬批评指正 日后也会持续更新数据结构相关内容，互相学习😊😊
【数据结构与算法】循环队列和链队列的比较
付费专栏已不再维护，请勿购买
10-01 5317
循环队列和链队列的比较
数据结构（C语言版）——4.1、顺序队列实现
weixin_41600504的博客
10-06 1887
4.1、顺序队列实现 4.1.1、顺序队列说明 和顺序表类似。顺序队列即队列的顺序存储结构是利用一组地址连续的存储单元依次存放 自队头 到队尾 的数据元素，同时附设指针 front 指示队头元素在顺序队列中的位置，设指针 rear 指示队尾元素在顺序队列中的位置。 通常习惯做法，鉴于C语言中数组的下标约定从整数 0 开始，则为了方便，这里队头与队尾指针 front 与 rear 设为 int 变量。 初始状态，front = rear 表示队列为空，每当插入一个新的队列元素时，rear 增 1 （只能从队
循环队列和队列的性能比较
weixin_42913025的博客
03-05 316
循环队列 package com.company; public class LoopQueue<E> implements Queue<E>{ private E[] data; private int front, tail; private int size; public LoopQueue(int capacity){ ...
队列详解（C语言实现）
最新发布
m0_50655389的博客
11-26 1370
文章目录写在前面1 队列的定义2 队列的初始化3 数据入队列4 数据出队列5 获取队头元素6 获取队尾元素7 获取队列元素个数8 判断队列是否为空8 队列的销毁 写在前面 本片文章详细介绍了另外两种存储逻辑关系为 “一对一” 的数据结构——栈和队列中的队列，并使用C语言实现链队列。 队列C语言实现源码：队列源码 以队列在存储数据时具有特殊的顺序规则： 队列：使用队列存储数据，遵循 “先进先出” 的原则，即最先进队列的数据最先出队列。队列也可以分为顺序队列（基于数组实现）和链队列（基于链表实现）。 队列的实
c语言中循环队列的优点,循环队列的优点是什么？
weixin_30998047的博客
05-22 909
满意答案cowkinki2013.07.04采纳率：44%等级：12已帮助：7278人有个设了队头，队尾的，你参考下，入队的时候队尾指针变，出队的时候队头指针变int EnQueue(CirQueue *Q, DataType e)//入队{if (Q->quelen == QueueSize) //队满条件{printf("Queue is full! Cannot EnQueue...
【数据结构】顺序队列、循环队列、链队列的实现和相关操作
m0_72895175的博客
08-16 448
队列（queue）是只允许在一端进行插入操作，在另一端进行删除操作的线性表，队列的特点是允许插入的一端称为队尾（rear），允许删除的一端称为队头(front)。向队列中插入新的数据元素称为入队。从队列中删除队头元素称为出队。
数据结构（C语言版）——4.2、循环队列实现
weixin_41600504的博客
10-07 438
4.2、循环队列实现 4.2.1、循环队列说明 （1）循环队列的产生 在队列的顺序结构中，由于顺序队列尾进头出的特性，存在如下图所示的情况。 此状态不可再继续插入新的队尾元素，否则会造成数组越界；又不易像顺序栈那样进行存储再分配，扩大数组空间。 但实际上队列的可用空间并未占满 ，这样会造成空间的严重浪费。 一个巧妙的办法是，臆造一个环状的空间，即循环队列。进而解决了顺序单调队列由于 front 前移不可逆转的空间浪费的问题 （2）循环队列结构上的特殊之处 指针和队列元素之间的关系并
C语言中的队列（顺序队列与链式队列）——概念及其基本操作
qq_51308373的博客
03-21 1万+
前言 太久没更新了，早就说要写结果拖到现在。闲话说完，正式开始内容。 队列——顾名思义，其实在线性表中也是一种极其重要的结构。 与栈不同的是，栈对元素的插入和删除均在一端进行，而队列，从队头删除，队尾插入，正如日常生活中的排队一样，还是比较形象的。 本文将对队列的概念及操作函数进行简要介绍，并说明顺序队列（利用数组）和链式队列（利用链表）的一些基本算法。 一、队列的相关概念 1.队列及其操作 （先进先出） 1.1 相关概念 （1）队列：只允许在表的一端删除元素，在另一端插入元素的线性表 （2）空队列：不含元
《数据结构：c语言版》（严蔚敏）知识点整合
目标检测专栏持续更新中，改进YOLO系列通用，适用v5、v7、v8、所有博客均是团队原创博客，所有文章禁止转载，违者必究。
06-18 1万+
数据结构是相互之间存在一种或多种特定关系的数据元素的集合， 《数据结构》让读者认识到了各种数据结构在处理数据上的优缺点， 理解掌握相关数据结构的具体操作，在结构的基础上添加好的算法，就能够更好的处理和利用数据。 算法的时间空间复杂度： 线性表： 线性表的顺序存储结构 用一组连续的存储单元依次存储线性表的数据元素。 特点：线性表的顺序存储是一种随机存取的存储结构。 随机存取：即读写存储的消息的时间与存储的位置无关 相关操作： 2.插入： 3.查找 4.删除 1.初始化 2.单链表的插入 3.查找 4.
数据结构（C语言版）——绪论
m0_67929407的博客
12-19 309
程序=数据结构+算法 1.数据、数据元素、数据项和数据对象 2.数据结构 3.数据类型和抽象数据类型 4.算法及算法分析
队列的顺序存储结构
ana35287的博客
01-23 815
队列的顺序存储结构之循环队列 队列的定义：只允许在一端进行操作，在另一端进行删除操作的线性表。 队列是一种先进先出的线性表，简称FIFO，允许插入的一端称为队尾，允许删除的一端称为队头。 1、队列的顺序存储结构存在缺陷 原因： 　　　　假设一个队列有n个元素，则顺序存储的队列需要建立一个大于n的数组，并把队列的所有元素存储在数组的前n个单元，数组下标为0的一端即为对头。...
线性表之顺序队列
_ACME_的博客
01-24 1049
基本思想：利用数组，来模拟队列，先进先出。入队要从队尾进去，也就是数组的最后一个元素（rear所指向的才是最后一个元素）的后面。出队要从队头出去，也就是数组的第一个元素（不一定是a[0],而是front所指向的位置）。优点：顺序队列的优点就一个，那就是代码太简单，其它的没有。缺点：用数组来模拟队列，那缺点就比较严重，第一，不适合动态增长。第二，空间利用率太低（因为出队的时候队头不断的向后移，队尾也向
C语言循环队列使用与注意
suxiang198的博客
07-11 4080
问题描述：循环队列是一般队列的变种吧，就是将队列首尾相连了，貌似这样就不必考虑队列满而无法使用了，因为到了队列尾又会循环回到队列首。在嵌入式底层代码实现中，一些串行端口数据特别是串口，用到循环队列的情况还是蛮多的。当然，这只是一种数据结构，用在哪里都得看具体用途和是否能带来好处。为了更深一步的对这一结构的了解，进行了下整理和学习。 循环队列：将向量空间想象为一个首尾相接的圆环，并称这种向量
顺序存储结构和链式存储结构的优缺点
热门推荐
斜阳雨陌
07-13 7万+
（一）顺序存储结构和链式存储结构的优缺点比较，以及使用情况。 1 优缺点 ① 顺序存储时，相邻数据元素的存放地址也相邻（逻辑与物理统一）；要求内存中可用存储单元的地址必须是连续的。 优点：存储密度大（＝1），存储空间利用率高。缺点：插入或删除元素时不方便。 ②链式存储时，相邻数据元素可随意存放，但所占存储空间分两部分，一部分存放结点值，另一部分存放表示结点间关系的指针 优点：插入或删
数据结构教程 李春葆 第三章上机实验三
qq_48975137的博客
10-23 1308
数据结构教程 李春葆 第三章上机实验三 p118实验三 //顺序队基本运算算法 #include <stdio.h> #include <malloc.h> #define MaxSize 100 typedef char ElemType; typedef struct { ElemType data[MaxSize]; int front,rear; }SqQueue; void InitQueue(SqQueue *&q) //初始化 { q=(SqQueue *
2021-05-26
m0_56183532的博客
05-26 318
#include <stdio.h> #include <malloc.h> #define MaxSize 100 typedef char ElemType; typedef struct node { ElemType data; //数据元素 struct node *lchild; //指向左孩子 struct node *rchild; //指向右孩子 } BTNode; void CreateBTNode(BTNode *&b,char *str)
数据结构学习笔记——顺序存储结构实现循环队列
小宇y的博客
06-12 4579
所谓循环队列，也就是将顺序队列中的一维数组首尾相连成环，也就是在逻辑上视为一个环连接起来，其存储类型定义与顺序队列的存储类型定义是一样的，也是定义数组data[MaxSize]和两个指针，即队头指针front指向队头元素，队尾指针rear指向队尾元素，如下： 例如下图是个空循环队列，其中data[]数组中未存任何数据元素，指针front、rear都指向同一位置，此时队列为空： 循环队列的初始化与顺序队列的初始化代码一样，当时，表示循环队列的初始状态，此时队列为空，如下代码： 三、判断循环队列是否为空队 循环
【C++】【数据结构】循环队列的基本操作（初始化、入队、出队、取队头元素、遍历输出队列、求队列长度）顺序队列的算法实现【附全代码】
是小雷同学的博客
04-21 2万+
C++实现循环队列的算法+步骤（附全代码）： 使用c++完成数据结构循环队列的基本操作，包括（初始化、入队、出队、取队头元素、遍历输出队列、求队列长度等），可直接编译运行。 队列又称为 “先进先出” (FIFO)线性表。限定插入操作只能在队尾进行，而删除操作只能在队首进行。 循环队列——采用顺序存储结构来实现，用一组连续的存储单元依次存放从队首到队尾的元素，附设两个整型变量front和rear分别指向队首元素和队尾元素的位置。 循环队列的定义： #define MAXQSIZE 100 typedef
使用C语言实现循环队列
Monstres的博客
10-28 847
队列是一种特殊的线性表，只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作。进行插入操作的端称为队尾，进行删除操作的端称为队头。队列中没有元素时，称为空队列。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值