第1关：实现一个顺序存储的队列

于 2024-10-14 20:47:41 发布
阅读量1.5k 收藏 5
点赞数 16
CC 4.0 BY-SA版权
分类专栏： 头歌代码 文章标签： 算法 数据结构 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/dust_as_light/article/details/142928315

任务描述
相关知识
顺序存储的队列
顺序队列的主要操作
编程要求
测试说明
任务描述
本关任务：实现 step1/SeqQueue.cpp 中的SQ_IsEmpty、SQ_IsFull、SQ_Length、SQ_In和SQ_Out五个操作函数，以实现判断队列是否为空、是否为满、求队列长度、队列元素入队和出队等功能。

相关知识
队列是一个插入操作和删除操作受到限制的线性表数据结构。队列的插入和删除被限制在表的两端，即插入操作只能在表的一端进行，而删除操作只能在表的另一端进行，因此队列又称先进先出表。

顺序存储的队列
队列既可以采用顺序存储，也可以采用链接存储来实现。下面给出了一种基于顺序存储的队列实现方案：

该队列存储了 4 个元素 {56,77,15,12} ，其中 56 为队列头， 12 为队列尾。

这种实现方案将队列元素存储在一片连续的空间中，并通过data、front、rear和max四个属性元素组织成为一个结构：

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

基于这些属性要素组织成的队列结构如下所示：

struct SeqQueue {
    T* data; // 指向数据元素数组的指针
    int front; // 下一个出队元素的数组下标
    int rear; // 下一个入队元素应该存放的单元的数组下标
    int max;  // 队列中最多可放max-1个数据元素，留一个空数据单元以区分空和满
};
为了大家更好地理解队列空、队列满以及入队和出队操作，相关知识介绍如下：

队列为空的判断：当front与rear相等时，队列为空。

队列为满的判断：当front=0,rear=max-1或者front=rear+1时，队列为满。

出队操作：出队操作的前提是队列不为空。每出队一个元素（将front处的元素出队），就将front加 1 ；加 1 后，如果front超出最后一个位置max-1，就将front重新设置为 0 。

入队操作：入队操作的前提是队列不为满。每入队一个元素（新元素存储在rear处），就将rear加 1 ；加 1 后，如果rear超出最后一个位置max-1，就将rear重新设置为 0 。

同时为了讨论简单，我们假设队列元素的数据类型为整数：

typedef int T; // 队列元素的数据类型
据此，只要给定指向该结构的一指针sq，就可对队列进行出队入队操作。

在给定图1的状态下，连续 2 次出队操作，这时的状态则变为如图 2 所示的状态。


在给定图 2 的状态下，连续 2 次入队操作（依次入队 23 、78 ），这时的状态则如图 3 所示。


顺序队列的主要操作
对数据元素进行操作处理是一个数据结构的重要组成部分。队列涉及的主要操作如下：

创建队列：创建一个最多可以存储maxlen个元素的顺序队列。具体操作函数定义如下：
SeqQueue* SQ_Create(int maxlen)；

释放队列空间：释放队列所占用的空间，以删除队列。具体操作函数定义如下：
void SQ_Free(SeqQueue* sq)；

置空队列：将队列置空。具体操作函数定义如下：
void SQ_MakeEmpty(SeqQueue* sq)；

判断队列是否为空：若队列为空，则返回true，否则返回false。具体操作函数定义如下：
bool SQ_IsEmpty(SeqQueue* sq)；

判断队列是否为满：若队列满，则返回true，否则返回false。具体操作函数定义如下：
bool SQ_IsFull(SeqQueue* sq)；

求队列长度：获取队列的长度。具体操作函数定义如下：
int SQ_Length(SeqQueue* sq)；

将元素 x 入队：将 x 入队，若入队失败(队列满)，则返回false，否则返回true。具体操作函数定义如下：
bool SQ_In(SeqQueue* sq, T x)；

从队列sq出队一个元素：item为出队的元素的值。若出队成功(队列不为空)，则返回true；否则(队列空)，返回false，此时item不会返回有效值。具体操作函数定义如下：
bool SQ_Out(SeqQueue* sq, T& item)；

获取队列头结点元素：返回时head保存头结点元素。若获取失败(队列空)，则返回值为false，否则返回值为true。具体操作函数定义如下：
bool SQ_Head(SeqQueue* sq, T& head)；

打印队列元素：依次打印出队列中的每个元素。具体操作函数定义如下：
void SQ_Print(SeqQueue* sq)。

编程要求
本关任务是实现 step1/SeqQueue.cpp 中的SQ_IsEmpty、SQ_IsFull、SQ_Length、SQ_In和SQ_Out五个操作函数，以实现判断队列是否为空、是否为满、求队列长度、队列元素入队和出队等功能。具体要求如下：

SQ_IsEmpty：判断队列是否为空，若队列为空，则返回true，否则返回false。

SQ_IsFull：判断队列是否为满，若队列满，则返回true，否则返回false。

SQ_Length：获取队列的长度。

SQ_In：将 x 入队，若入队失败(队列满)，则返回false，否则返回true。

SQ_Out：从队列出队一个元素，若出队成功(队列不为空)，则返回true；否则(队列空)，返回false。

输入输出格式请参见后续说明及测试样例

注意：本关必读中提及的其他操作已经由平台实现，你在实现本关任务的五个操作函数时，在函数体内可调用其他操作。
本关涉及的代码文件 SeqQueue.cpp 中的 5 个操作函数的代码框架如下：

bool SQ_IsEmpty(SeqQueue* sq)
// 判断队列是否为空，为空返回true，否则返回false。
{
    // 请在这里补充代码，完成本关任务
    /********** Begin *********/
    /********** End **********/
}
bool SQ_IsFull(SeqQueue* sq)
// 判断队列是否为满。为满返回true，否则返回false。
{
    // 请在这里补充代码，完成本关任务
    /********** Begin *********/
    /********** End **********/
}
int SQ_Length(SeqQueue* sq)
// 队列长度
{
    // 请在这里补充代码，完成本关任务
    /********** Begin *********/
    /********** End **********/
}
bool SQ_In(SeqQueue* sq, T x)
// 将x入队。若入队失败(队列满)，则返回false，否则返回true。
{
    // 请在这里补充代码，完成本关任务
    /********** Begin *********/
    /********** End **********/
}
bool SQ_Out(SeqQueue* sq, T& item)
// 从队列sq出队一个元素，返回时item为出队的元素的值。若出队成功(队列不为空)，则返回true，否则(队列空)，返回false，此时item不会返回有效值。
{
    // 请在这里补充代码，完成本关任务
    /********** Begin *********/
    /********** End **********/
}
测试说明
本关的测试文件是 step1/Main.cpp ，负责对你实现的代码进行测试。具体代码如下：

#include <stdio.h>
#include <stdlib.h>
#include "SeqQueue.h"
#include <string.h>
#pragma warning(disable:4996)
void 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);
    system("PAUSE");
    SQ_Free(sq);
}
注意：step1/Main.cpp 的代码不能被修改。

输入输出说明：
输入格式：
首先输入一个值 len ，测试程序创建一个可以存储 len 个数据元素的队列。然后输入多个操作：如果输入 “in” ，则后面跟一个数 x ，表示 x 入队列；如果输入 “out” ，表示出队列操作；如果输入 “end” ，表示输入结束。

输出格式：
先输出队列长度，然后从队头到队尾依次输出队列的各元素。

以下是平台对step1/Main.cpp的测试样例：
样例输入:
5
in 1
in 3
in 5
in 9
in 12
out
end
样例输出
Queue length: 4
Queue data: 3  5  9  12

开始你的任务吧，祝你成功！

人生，最宝贵的莫过于光阴。人生，最璀璨的莫过于事业。人生，最快乐的莫过于奋斗。

如果你觉得有收获，请在下面点赞或留言。

/*************************************************************
    date: April 2017
    copyright: Zhu En
    DO NOT distribute this code without my permission.
**************************************************************/
// 循环顺序的队列实现文件
/////////////////////////////////////////////////////////
#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->rear==sq->front)
    return true;
    else return false;

    /********** End **********/
}

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

    /********** End **********/
}

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

bool SQ_In(SeqQueue* sq, T x)
// 将x入队。若入队失败(队列满)，则返回false，否则返回true。
{
    // 请在Begin-End之间补充代码，将 x 入队。
    /********** Begin *********/
    if(SQ_IsFull(sq))
    {
        return false;
    }
    else {
        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))
   {
       return false;
   }
   else{
       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");
}

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值