C语言：队列

已于 2023-08-13 20:15:22 修改
阅读量947 收藏 6
点赞数
分类专栏： 算法设计 C语言 文章标签： 队列
于 2021-05-11 15:27:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51354361/article/details/116655824
版权

队列

顺序队列

在这里插入图片描述

结构体中成员：

1.data给出队列存储空间的起始地址
2.front为队头指针，它指向队头元素
3.rear为队尾指针，它指向下一个入队元素的存储位置
4.max指明队列存储空间中最多可存储的数据元素个数。（通常为了区分队列空和满，会在队列尾留一个空数据单元，此时队列最多可放max-1个数据元素）
特别说明：空间的开始地址为data，连续空间里的位置编号从data所指的开始位置起，到该空间的结束位置，编号依次是0,1,2,…,max-1。在图1的示例中max=6。下一个出队元素（这里是队列的头结点）所存储的位置编号用front给出，下一个入队元素应存储的位置编号用rear给出。

顺序队列操作

1.判空：当front与rear相等时，队列为空
2.判满：当front=0,rear=max-1或者front=rear+1时，队列为满
3.出队：出队操作的前提是队列不为空。每出队一个元素（将front处的元素出队），就将front加 1 ；加 1 后，如果front超出最后一个位置max-1，就将front重新设置为 0
4.入队：入队操作的前提是队列不为满。每入队一个元素（新元素存储在rear处），就将rear加 1 ；加 1 后，如果rear超出最后一个位置max-1，就将rear重新设置为 0

  • 在给定图1的状态下，连续 2 次出队操作，这时的状态则变为如图 2 所示的状态
    在这里插入图片描述
  • 在给定图 2 的状态下，连续 2 次入队操作（依次入队 23 、78 ），这时的状态则如图 3 所示
    在这里插入图片描述

SeqQueue.cpp

#include <stdio.h>
#include <stdlib.h>
#include "SeqQueue.h"

SeqQueue* SQ_Create(int maxlen)
// 创建顺序队列, 队列最多存储maxlen个队列元素。
{
    SeqQueue* sq=(SeqQueue*)malloc(sizeof(SeqQueue));
    sq->data=(T*)malloc(sizeof(T)*(maxlen+1));
    sq->front=sq->rear=0;
    sq->max=maxlen+1;
    return sq;
}

void SQ_Free(SeqQueue* sq)
// 释放队列空间，以删除队列。
{
    free(sq->data);
    free(sq);
}

void SQ_MakeEmpty(SeqQueue* sq)
// 将队列置空。
{
    sq->front=0;
    sq->rear=0;
}

bool SQ_IsEmpty(SeqQueue* sq)
// 判断队列是否为空，为空返回true，否则返回false。
{
    // 请在Begin-End之间补充代码，完成队列是否为空的判断。
    /********** Begin *********/
	if(sq->front == sq->rear) return true;
	return false;
    /********** End **********/
}

bool SQ_IsFull(SeqQueue* sq)
// 判断队列是否为满。为满返回true,否则返回false。
{
    // 请在Begin-End之间补充代码，完成队列是否为满的判断。
    /********** Begin *********/
	if((sq->front == 0&&sq->rear == sq->max - 1)||sq->front == sq->rear + 1) return true;
	return false;
    /********** End **********/
}

int SQ_Length(SeqQueue* sq)
// 队列长度。
{
    // 请在Begin-End之间补充代码，获取队列长度。
    /********** Begin *********/
	if(SQ_IsFull(sq)) return sq->max-1;
	return sq->rear - sq->front;
    /********** End **********/
}

bool SQ_In(SeqQueue* sq, T x)
// 将x入队。若入队失败(队列满)，则返回false，否则返回true。
{
    // 请在Begin-End之间补充代码，将 x 入队。
    /********** Begin *********/
	if(SQ_IsFull(sq)) return false;
	sq->data[sq->rear] = x;
	sq->rear++;
	if(sq->rear > sq->max - 1) sq->rear = 0;
	return true;
    /********** End **********/
}

bool SQ_Out(SeqQueue* sq, T& item)
// 从队列sq出队一个元素，返回时item为出队的元素的值。若出队成功(队列不为空)，则返回true，否则(队列空)，返回false，此时item不会返回有效值。
{
    // 请在Begin-End之间补充代码，完成元素出队操作。
    /********** Begin *********/
	if(SQ_IsEmpty(sq)) 
	{
		item = -1;
		return false;
	}
	item = sq->data[sq->front];
	sq->front++;
	if(sq->front > sq->max - 1) sq->front = 0;
	return true;
	item = sq->data[sq->front];
	sq->front++;
	if(sq->front > sq->max - 1) sq->front = 0;
	return true;
    /********** End **********/
}

bool SQ_Head(SeqQueue* sq, T& head)
// 获取队列头结点元素，返回时head保存头结点元素。
// 若获取失败(队列空)，则返回值为false，否则返回值为true。
{
    if ( SQ_IsEmpty(sq) ){
        return false;
    }
    else {
        head = sq->data[sq->front];
        return true;
    }
}

void SQ_Print(SeqQueue* sq)
// 依次打印出队列中的每个元素。
{
    int i=sq->front;
    if (SQ_IsEmpty(sq)) {
        printf("queue is emtpy");
        return;
    }
    for (i=sq->front; i!=sq->rear; i=(i+1)%sq->max) {
        printf("%d  ", sq->data[i]);
    }
    printf("\n");
}

SeqQueue.h

#if !defined(SEQUENCE_QUEUE_H_LIELJE7398CNHD_INCLUDE_)
#define SEQUENCE_QUEUE_H_LIELJE7398CNHD_INCLUDE_
typedef int T;
struct SeqQueue { 
    T* data; // 指向数据元素数组的指针。
    int front; // 下一个出队元素的数组下标。
    int rear; // 下一个入队元素应该存放的单元的数组下标。
    int max;  // 队列中最多可放max-1个数据元素，留一个空数据单元以区分空和满。
};

SeqQueue* SQ_Create(int maxlen);
void SQ_Free(SeqQueue* sq);
void SQ_MakeEmpty(SeqQueue* sq);
bool SQ_IsEmpty(SeqQueue* sq);
bool SQ_IsFull(SeqQueue* sq);
int SQ_Length(SeqQueue* sq);

bool SQ_In(SeqQueue* sq, T x);
bool SQ_Out(SeqQueue* sq, T& item);
bool SQ_Head(SeqQueue* sq, T& head);

void SQ_Print(SeqQueue* sq);

#endif

Main.cpp

#include <stdio.h>
#include <stdlib.h>
#include "SeqQueue.h"
#include <string.h>
#pragma warning(disable:4996)

int main()
{
    int maxlen;
    scanf("%d", &maxlen);
    SeqQueue* sq=SQ_Create(maxlen);
    char dowhat[100];
    while(true) {
        scanf("%s", dowhat);
        if (!strcmp(dowhat,"in")) {
            T x;
            scanf("%d", &x);
            SQ_In(sq,x);
        }else if (!strcmp(dowhat,"out")) {
            T item;
            SQ_Out(sq, item);
        }
        else {
            break;
        }
    }
    int length=SQ_Length(sq);
    printf("Queue length: %d\n", length);
    printf("Queue data: ");
    SQ_Print(sq);
    SQ_Free(sq);
}

样例输入:

5
in 1
in 3
in 5
in 9
in 12
out
end

样例输出：

Queue length: 4
Queue data: 3 5 9 12

链队列

链式储存方式
在这里插入图片描述
当队列是空队列时，rear指向附加头结点，附加头结点的数据项等于 0 ，如图 2 所示
在这里插入图片描述

  • 在给定图 1 的状态下，进队一个元素 25 以后的状态如图 3 所示：
    在这里插入图片描述
  • 若出队一个元素是指将当前队列头结点去掉。则在给定图 3 的状态下，进行一次出队后的状态如图 4 所示：
    在这里插入图片描述

CLnkQueue.cpp

#include <stdio.h>
#include <stdlib.h>
#include "CLnkQueue.h"

LNode* CLQ_Create()
// 创建一个队列。
{
    LNode* rear=(LNode*)malloc(sizeof(LNode));
    rear->data = 0;
    rear->next = rear;
    return rear;
}
void CLQ_Free(LNode* rear)
// rear指向尾结点。
{
    CLQ_MakeEmpty(rear);
    free(rear);
}

void CLQ_MakeEmpty(LNode* & rear)
// rear指向尾结点。
// 将队列变为空队列。
{
    T item;
    while(!CLQ_IsEmpty(rear))
        CLQ_Out(rear,item);
}

bool CLQ_IsEmpty(LNode* rear)
// 判断队列是否为空。
{
    // 请在Begin-End之间补充代码，完成队列是否为空的判断。
    /********** Begin *********/
	if(rear == rear->next) {
        rear->data = 0;
        return true;
    }
	return false;
    /********** End **********/
}

int CLQ_Length(LNode* rear)
// 返回队列长度，rear指向尾结点。
{
    // 请在Begin-End之间补充代码，获取队列长度。
    /********** Begin *********/
	int cnt = 0;
	LNode* p = rear->next;
	while(p != rear){
		cnt++;
		p = p->next;
	}
	return cnt;
    /********** End **********/
}

void CLQ_In(LNode* & rear, T x)
// 入队列, 新结点加入链表尾部。rear指向尾结点。
{
    // 请在Begin-End之间补充代码，完成新结点入队操作。
    /********** Begin *********/
	LNode *s =(LNode*)malloc(sizeof(LNode));
	LNode *t;
	t = rear->next;
	s->data = x;
	rear->next =s;
	rear =s;
	rear->next = t;
    /********** End **********/
}

bool CLQ_Out(LNode* & rear, T& item)
// 出队列。空队列时，返回值为false。rear指向尾结点。
{
    // 请在Begin-End之间补充代码，完成结点出队操作。
    /********** Begin *********/
	if(CLQ_IsEmpty(rear)) return false;
	LNode *t;
    item = t->data;
	t = rear->next;
	rear->next = t->next;
	free(t);
	return true;
    /********** End **********/
}

bool CLQ_Head(LNode* rear, T& item)
// rear指向尾结点。
// 获取队列头。空队列时返回值为false。
{
    if (CLQ_IsEmpty(rear)) 
        return false;

    item = rear->next->next->data;
    return true;
}
void CLQ_Print(LNode* rear)
// 打印队列。
{
    if (CLQ_IsEmpty(rear))  {
        printf("The queue is: empty. \n");
        return;
    }
    LNode* node=rear->next->next;
    do {
        printf("%d  ", node->data);
        node = node->next;
    }   while (node != rear->next); 
    //printf("\n");
}

CLnkQueue.h

#if !defined(LINKED_QUEUE_H_983982)
#define LINKED_QUEUE_H_983982

typedef int T;

struct LNode {
    T data;
    LNode* next;
};

LNode* CLQ_Create();
void CLQ_Free(LNode* rear);
void CLQ_MakeEmpty(LNode*& rear);
bool CLQ_IsEmpty(LNode* rear);
int CLQ_Length(LNode* rear);
void CLQ_In(LNode* & rear, T x);
bool CLQ_Out(LNode* & rear, T& item);
bool CLQ_Head(LNode* rear, T& item);
void CLQ_Print(LNode* rear);
#endif

Main.cpp

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "CLnkQueue.h"
#pragma warning(disable:4996)

int main()
{
    LNode* rear=CLQ_Create();
    char dowhat[100];
    while(true) {
        scanf("%s", dowhat);
        if (!strcmp(dowhat,"in")) {
            T x;
            scanf("%d", &x);
            CLQ_In(rear,x);
        }else if (!strcmp(dowhat,"out")) {
            T item;
            CLQ_Out(rear, item);
        }
        else {
            break;
        }
    }
    int length=CLQ_Length(rear);
    printf("Queue length: %d\n", length);
    printf("Queue data: ");
    CLQ_Print(rear);
    CLQ_Free(rear);
}

样例输入:

in 1
in 3
in 5
in 9
in 12
out
end

样例输出:

Queue length: 4
Queue data: 3 5 9 12

『魔法猫咪』
关注
  • 0
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【数据结构】队列的顺序表示
WINGREZ‘S BLOG
09-09 1982
参考资料：《数据结构（C语言版）严蔚敏著》 版权说明：未经作者允许，禁止转载。如引用本文内容，需标明作者及出处。如本文侵犯了您的权益，请联系我删除并致歉。 文章说明：如文章中出现错误，请联系我更改。如您对文章的内容有任何疑问，也欢迎来与我讨论。 本文正在施工中...请稍等... 队列的顺序表示 顺序队列 用一块连续的存储单元存放队列中的元素，并附加两个指针front和rear分别指示队头元素...
【数据结构】C语言队列(详解)
weixin_65186652的博客
08-31 7236
C语言实现队列,详细解读
队列——（c语言实现）
最新发布
2302_77041624的博客
05-12 1076
队列，是一种先进先出（first in first out 简称FIFO）的数据结构，是只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，在队列中，进行插入的一端称为队尾，进行删除的一端称为队头。
队列（C语言实现）
m0_59311392的博客
09-18 2580
1.1 定义：队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出 FIFO(First In First Out)入队列：进行插入操作的一端称为队尾出队列：进行删除操作的一端称为队头int front;int rear;}QueNode;int size;}Queue双端队列是指允许两端都可以进行入队和出队操作的队列。其元素的逻辑结构仍是线性结构。将队列的两端称为前端和后端，两端都可以入队和出队。
educoder数据结构与算法 队列 第1关：实现一个顺序存储的队列
qq_54008392的博客
12-09 1万+
任务描述 本关任务：实现 step1/SeqQueue.cpp 中的SQ_IsEmpty、SQ_IsFull、SQ_Length、SQ_In和SQ_Out五个操作函数，以实现判断队列是否为空、是否为满、求队列长度、队列元素入队和出队等功能。 相关知识 队列是一个插入操作和删除操作受到限制的线性表数据结构。队列的插入和删除被限制在表的两端，即插入操作只能在表的一端进行，而删除操作只能在表的另一端进行，因此队列又称先进先出表。 顺序存储的队列 队列既可以采用顺序存储，也可以采用链接存储来实现。下面给出
数据结构——队列（C语言实现）
sinzz的博客
04-16 2993
首先，我们需要定义的是链式结构的队列，即单链表为底层实现的。所以需要定义单链表结构来存储数据。然后，定义队列，队列里需要定义两个指向单链表的指针，一个是指向单链表头结点的指针，另一个则用来保存尾结点地址的指针。最后，还需定义一个记录当前队列元素个数的变量，用于遍历队列和判空。int size;} Queue;
queue_C语言消息队列_
10-04
在C语言中，实现消息队列通常涉及到操作系统提供的API，如POSIX消息队列或Windows的消息队列API。本节将深入探讨如何使用C语言构建消息队列，以及其在实时消息共享和传输中的应用。 首先，我们需要理解消息队列的...
C语言实现 队列
11-24
C语言实现队列
c语言实现队列功能
11-04
1. 初始化队列：创建一个新的空队列，通常设置队头和队尾为-1或者NULL，表示队列为空。 2. 入队：在队尾添加元素。如果使用数组，我们需要检查队列是否已满；如果使用链表，我们需要创建新节点并将其链接到队尾。 3....
C语言：基于c代码实现的二维单调队列
04-12
C语言：基于c代码实现的二维单调队列
c语言简单队列
04-22
//实现的是类似循环队列，但由于是静态线性队列(数组) //而不是用链表来实现的，所以到静态队列(数组)尾部,尾指针自动指向(数组)头部 *Rear = mQueue; } puts("Input Data:"); scanf("%d", *Rear); //...
数据结构与算法基础之线性表顺序实现(C语言)
zyx18211503935的博客
05-05 343
数据结构与算法基础之线性表顺序实现 学习来源: 数据结构与算法基础（青岛大学-王卓） 地址： https://www.bilibili.com/video/BV1nJ411V7bd?p=22&spm_id_from=pageDriver 背景: 实现视频里老师的伪代码，并不完全一样，但基本雷同。 代码: SequenceList.h #ifndef _SEQUENCELIST_H_ #define _SEQUENCELIST_H_ struct List_SQ { int *Sequ
【c语言】队列
weixin_74337975的博客
04-23 1020
队列（Queue）是一种数据结构，它遵循先进先出（FIFO）的原则。队列在计算机科学中有着广泛的应用，如操作系统、编译器、图形学等领域。C语言中队列可以使用数组或链表来实现。队列通常有两个指针，一个指向队头，一个指向队尾。入队操作将元素插入队尾，出队操作将队头元素移出队列。队列中还包含一些基本操作，如获取队列长度、判断队列是否为空、获取队头元素等。在C语言中，使用结构体来表示队列和队列中的节点。具体实现可以参考上面的代码示例。
数据结构与算法 - 队列
aiains的博客
10-24 2717
数据结构
c语言数据结构之队列
Qurry的博客
09-25 1327
不同于栈，队列是一个先进先出的数据结构，规定数据节点从队列尾插入，从队列头取出，禁止对头尾两端以外的数据进行操作。队列可以分为顺序队列和循环队列。
增加了front和rear后的顺序队列
lzjsqn的专栏
05-10 2585
头文件 #ifndef __SEQQUEUE_H__ #define __SEQQUEUE_H__ typedef void SeqQueue; SeqQueue* SeqQueue_Create(int capacity); void SeqQueue_Destroy(SeqQueue* queue); void SeqQueue_Clear(SeqQueue* queue); in
实现一个顺序存储的栈（数据结构与算法 - 栈）
热门推荐
韶言大雅
04-24 1万+
相关知识 栈的基本概念 栈是一种运算受限的线性表。其限制是仅允许在表的一端进行插入和删除运算，这一端被称为栈顶。栈既可以采用顺序存储，也可以采用链接存储来实现。下面给出了一种基于顺序存储的栈的实现方案： 如图 1 所示：该栈存储了 4 个元素 {56,77,15,12} ，其中 12 是栈顶元素。 这种实现方案将栈元素存储在一片连续的空间中，栈相关的三个属性元素data、top和max介绍如下：...
队列的基本操作
麻辣清汤的博客
09-14 1万+
队列是一个插入操作和删除操作受到限制的线性表数据结构 队列的插入和删除被限制在表的两端，即插入操作只能在表的一端进行，而删除操作只能在表的另端进行，因此队列又称先进先出表 　　（1）允许删除的一端称为队头（Front）。 　　（2）允许插入的一端称为队尾（Rear）。 　　（3）当队列中没有元素时称为空队列。 　　（4）队列亦称作先进先出（First In First Out）的线性表，简称为FIFO表。 　队列的修改是依先进先出的原则进行的。新来的成员总是加入队尾（即不允许"加塞"...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值