队列+PTA

已于 2024-04-27 00:45:13 修改
阅读量967 收藏 10
点赞数 7
文章标签： 算法 数据结构 笔记
于 2024-04-27 00:24:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/HeaoDng/article/details/138234751
版权

队列

定义：队列（queue）是只允许在一端进行插入操作，而在另一端进行删除操作的线性表。
队列是一种先进先出（First In First Out）的线性表，简称FIFO。允许插入的一端称为队尾，允许删除的一端称为队头。

在这里插入图片描述

队头（Front）：允许删除的一端，又称队首。
队尾（Rear）：允许插入的一端。
空队列：不包含任何元素的空表

队列的顺序实现与操作

队列的顺序实现是指分配一块连续的存储单元【数组】存放队列中的元素，并附设两个指针：队头指针 front指向队头元素，队尾指针 rear 指向队尾元素的下一个位置。

#define MAXQSIZE 100 //队列可能达到的最大长度
typedef struct
{
 QElemType *base; //存储空间的基地址
 int front; //头指针
 int rear; //尾指针
}SqQueue;

【说明】：在初始化创建空队列的时候，为了方便，经常将front=rear=0，每当插入新的队尾元素时，rear+1，每当删除队头元素时，头指针front+1。

同时为了解决“假溢出”的问题，我们借助每次对rear和front指针操作时都取模一次MAXQSIZE，这样会自动形成一个环状空间，我们称这样的队列是循环队列。

循环队列中存在的数学关系：

初始时：Q->front = Q->rear=0。
队首指针进1：Q->front = (Q->front + 1) % MAXQSIZE。
队尾指针进1：Q->rear = (Q->rear + 1) % MAXQSIZE。
队列长度：(Q->rear - Q->front + MAXQSIZE) % MAXQSIZE。

【注意】

为了区分队空与队满，我们默认牺牲一个单元来区分此情况，约定以“队头指针在队尾指针的下一位置作为队满的标志”。

队满条件： (Q->rear + 1)%Maxsize == Q->front
队空条件仍： Q->front == Q->rear
队列中元素的个数： (Q->rear - Q ->front + Maxsize)% Maxsize

1、循环队列的初始化

【算法步骤】

① 为队列分配一个最大容量为MAXQSIZE的数组空间，base指向数组空间的首地址。

② 将头指针和尾指针置为0，表示队列为空。

Status InitQueue(SqQueue *Q)
{
    Q->base=(QElemType*)malloc(MAXQSIZE*sizeof(QElemType));
    Q->front=Q->rear=0;
    return OK;
}

2、求循环队列的长度

int QueueLength(SqQueue Q)
{
    return (Q.rear-Q.front+MAXQSIZE)%MAXQSIZE;
}

3、循环队列的入队

【算法步骤】

① 判断队列是否满，若满则返回ERROR。

② 将新元素插入队尾。

③ 队尾指针加1。

Status EnQueue(SqQueue *Q,QElemType e)
{
    if((Q->rear+1)%MAXQSIZE==Q->front) return ERROR;
    Q->base[Q->rear]=e;
    Q->rear=(Q->rear+1)%MAXQSIZE;
    return OK;
}

4、循环队列的出队

【算法步骤】

① 判断队列是否为空，若空则返回ERROR。

② 保存队头元素。

③ 队头指针加1。

Status DeQueue(SqQueue *Q,QElemType *e)
{
    if(Q->rear==Q->front) return ERROR;
    *e=Q->base[Q->front];
    Q->front = (Q->front + 1) % MAXQSIZE;
    return OK;
}

5、取循环队列的队头元素

QElemType GetHead(SqQueue Q)
{
	if(Q.front!=Q.rear)
        return Q.base[Q.front];
}

链队列

定义：链队列是指采用链式存储结构实现的队列。通常链队列用单链表来表示。这里和线性表的单链表一样，为了操作方便起见，给链队列添加一个头节点，并令头指针始终指向头节点。

typedef struct QNode
{
 QElemType data;
 struct QNode *next;
}QNode, *QueuePtr;
typedef struct
{
 QueuePtr front; //队头指针
 QueuePtr rear; //队尾指针
}LinkQueue;

1、链队列的初始化

【算法步骤】

① 生成新节点作为头节点，队头和队尾指针指向此节点。

② 头节点的指针域置空。

Status InitQueue(LinkQueue *Q)
{
	Q->front=Q->rear=(QNode*)malloc(sizeof(QNode)*1);
    Q->front->next=NULL;
    return OK;
}

2、链队列的入队

【算法步骤】

① 为入队元素分配节点空间，用指针p指向。

② 将新节点数据域置为e。

③ 将新节点插入到队尾。

④ 修改队尾指针为p。

Status EnQueue(LinkQueue *Q,QElemType e)
{
	QNode *p=(QNode*)malloc(sizeof(QNode)*1);
    p->data=e;
    p->next=NULL;
    Q->rear->next=p;
    Q->rear=p;
    return OK;
}

3、链队列的出队

【算法步骤】

① 判断队列是否为空，若空则返回ERROR。

② 临时保存队头元素的值，以释放空间。

③ 修改头节点的指针域，指向下一个节点。

④ 判断出队元素是否为最后一个元素，若是，则将队尾指针重新赋值，指向头节点。

⑤ 释放原队头元素的空间。

Status DeQueue(LinkQueue *Q,QElemType *e){
	if(Q->front==Q->rear)  return ERROR;
    QNode *p=Q->front->next;
    *e=p->data;
    Q->front->next=p->next;
    if(Q->rear==p) Q->rear=Q->front;
    free(p);
    return OK;
}

4、取链队列队头元素

QElemType GetHead(LinkQueue Q)
{
	if(Q.front!=Q.rear)
        return Q.front.next->data;
}

PTA

6-1

6-1 小孩报数（顺序循环队列版）

分数 30

作者 张庆

单位 集美大学

有若干个小孩围成一圈，现从指定的第1个开始报数，报到第 w个时，该小孩出列，然后从下一个小孩开始报数，仍是报到w个出列，如此重复下去，直到所有的小孩都出列（总人数不足w个时将循环报数），求小孩出列的顺序。
算法要求：使用顺序循环队列来存储所有小孩，报数时小孩出队，未数到w时，接着入队；数到w时，输出小孩的名字，该小孩不再入队，如此直到所有小孩出队，队列为空时停止报数。
请写出顺序循环队列的所有基本操作。
说明 ：参与报数游戏的小孩人数不能超过10人。

数据结构与操作函数接口定义：

typedef char ElemType;
typedef struct   // 顺序循环队列结点定义
{
    ElemType *name[MaxSize];   //小孩姓名
    int front,rear;        //队首和队尾指针
} SqQueue;
void InitQueue(SqQueue *&q);   //初始化队列；
void DestroyQueue(SqQueue *&q);  //销毁队列；
bool QueueEmpty(SqQueue *q);  //判定队列为空时返回true; 否则返回false;
bool enQueue(SqQueue *&q,ElemType *e);  // e 入队；成功入队返回true; 否则返回false;
bool deQueue(SqQueue *&q,ElemType *&e);  //出队，返回出队元素e，且成功出队返回true,否则返回false;

裁判测试程序样例：

#include <stdio.h>
#include <malloc.h>
#include <string.h>
#define MaxSize 11
#define N 10

int main()
{
    ElemType *e;
    int n,i;
    SqQueue *q;
    InitQueue(q);    
    scanf("%d",&n);
    while(1)
    {
        char *name=(char *)malloc(sizeof(char)*N);
        scanf("%s",name);
        if( (strcmp("-1",name)==0)||!enQueue(q,name))
            break;
    }
    i=n-1;
    while(!QueueEmpty(q))
    {
        deQueue(q,e);
        if(i-->0) 
            enQueue(q,e);
        else
        {
            printf("%s\n",e);
            i=n-1;
            free(e);            
        }        
    }
    DestroyQueue(q);
}


/* 请在这里填写答案 */

输入样例：

第一行：报数w;
第二行：输入若干小孩姓名，以空格符间隔，以字符串“-1”结束输入。
在这里给出一组输入。例如：

3
Jenny Mike Lily Tom Yoyo -1

输出样例：

在这里给出相应的输出。例如：

Lily
Jenny
Yoyo
Mike
Tom

答案：

void InitQueue(SqQueue*& q)  // 初始化队列；
{
    q = (SqQueue*)malloc(sizeof(SqQueue));
    q->front = q->rear = 0;
}

void DestroyQueue(SqQueue*& q)  // 销毁队列；
{
    while (q->front != q->rear) {
        free(q->name[q->front]);
        q->front = (q->front + 1) % MaxSize;
    }
    free(q);
}

bool QueueEmpty(SqQueue* q)  // 判定队列为空时返回true; 否则返回false;
{
    return q->front == q->rear;
}

bool enQueue(SqQueue*& q, ElemType* e)  // e 入队；成功入队返回true; 否则返回false;
{
    if ((q->rear + 1) % MaxSize == q->front) {
        return false;
    }
    q->name[q->rear] = e;
    q->rear = (q->rear + 1) % MaxSize;
    return true;
}

bool deQueue(SqQueue*& q, ElemType*& e)  // 出队，返回出队元素e，且成功出队返回true,否则返回false;
{
    if (q->front == q->rear) return false;
    e = q->name[q->front];
    q->front = (q->front + 1) % MaxSize;
    return true;
}

6-2

6-2 带头结点的链队列的基本操作

分数 30

作者 黄复贤

单位 菏泽学院

实现链队列的入队列及出队列操作。

函数接口定义：

Status QueueInsert(LinkQueue *Q,ElemType e)；

Status QueueDelete(LinkQueue *Q,ElemType *e)；

其中 Q 和 e 都是用户传入的参数。 LinkQueue 的类型定义如下：

typedef int ElemType; 
typedef struct LNode
{
    ElemType data;
    struct LNode * next;
}LNode,*LinkList;
typedef struct
 {
   LinkList front,rear; /* 队头、队尾指针 */
 }LinkQueue;

裁判测试程序样例：

#include <stdio.h>
#include<malloc.h>
#define OK 1
#define ERROR 0
typedef int Status;
typedef int ElemType; 
typedef struct LNode
{
    ElemType data;
    struct LNode * next;
}LNode,*LinkList;

typedef struct
 {
   LinkList front,rear; /* 队头、队尾指针 */
 }LinkQueue;
 /* 带头结点的链队列的基本操作 */
 Status InitQueue(LinkQueue *Q)
 { /* 构造一个空队列Q */
     LinkList p;
   p=(LNode*)malloc(sizeof(LNode)); 
   p->next=NULL;
   (*Q).rear=(*Q).front=p;
   return OK;
 }
Status List(LinkList L)
{
    LinkList p;
    if(!L) return ERROR;
    p=L->next;
    
    while(p)
    {
        printf(" %d",p->data);
        p=p->next;
    }
    printf("\n");
    return OK;
}

int QueueLenth(LinkQueue Q)
{
    int n=0;
    LinkList p;
    if(Q.rear==Q.front)
        return 0;
    p=Q.front->next;
    while(p)
    {
        n++;
        p=p->next;
    }
    return n;
}

int main()
{
    int x;
    LinkQueue Q;
    InitQueue(&Q);
    QueueInsert(&Q,1);QueueInsert(&Q,2);QueueInsert(&Q,3);
    List(Q.front );
    QueueDelete( &Q,&x);
    printf(" %d %d\n",x,QueueLenth(Q));
    QueueDelete(&Q,&x);QueueDelete(&Q,&x);
    printf(" %d %d\n",x,QueueLenth(Q));
    return 0;
}

/* 请在这里填写答案 */

输出样例：

在这里给出相应的输出。例如：

 1 2 3
 1 2
 3 0

答案：

Status QueueInsert(LinkQueue* Q, ElemType e)
{
    LNode* p = (LNode*)malloc(sizeof(LNode) * 1);
    p->data = e;
    p->next = Q->rear->next;
    Q->rear->next = p;
    Q->rear = p;
    return OK;
}

Status QueueDelete(LinkQueue* Q, ElemType* e)
{
    if (Q->rear == Q->front)
        return ERROR;
    LNode* p = Q->front->next;
    *e = p->data;
    Q->front->next = p->next;
    if (Q->rear == p) Q->rear = Q -> front;
    free(p);
    return OK;
}
HeaoDng144
关注
  • 7
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
PTA C语言 6-1 小孩报数（顺序循环队列版）
superyunbin的博客
12-14 622
typedef struct // 顺序循环队列结点定义 { ElemType *name[MaxSize];//小孩姓名 int front,rear;//队首和队尾指针 } SqQueue;//初始化队列；//销毁队列；//判定队列为空时返回true;否则返回false;// e 入队；成功入队返回true;否则返回false;//出队，返回出队元素e，且成功出队返回true,否则返回false;
顺序循环队列
weixin_45671534的博客
03-23 141
#include<stdio.h> #define Maxsize 100 typedef struct { char name[20]; int age; }Student; typedef struct{ Student a[Maxsize]; int front; int rear; int count; }Queue; void Init(Queue *q) { q...
PTA 习题8-4 报数（约瑟夫环问题——数组实现）
2301_79790088的博客
11-22 689
其中n是初始人数；m是游戏规定的退出位次（保证为小于n的正整数）。函数CountOff将每个人的退出顺序编号存在数组out[]中。因为C语言数组下标是从0开始的，所以第i个位置上的人是第out[i-1]个退出的。
小孩报数（顺序循环队列版） （10 分)
qq_43269093的博客
03-27 8879
有若干个小孩围成一圈，现从指定的第1个开始报数，报到第 w个时，该小孩出列，然后从下一个小孩开始报数，仍是报到w个出列，如此重复下去，直到所有的小孩都出列（总人数不足w个时将循环报数），求小孩出列的顺序。 算法要求：使用顺序循环队列来存储所有小孩，报数时小孩出队，未数到w时，接着入队；数到w时，输出小孩的名字，该小孩不再入队，如此直到所有小孩出队，队列为空时停止报数。 请写出顺序循环队列的所有基本...
出圈问题的代码
xiaoweibeibei的专栏
05-16 863
前几天没事，学习循环链表时候写的关于出圈问题的代码~~~~所谓出圈问题是指N个人排成一圈，然后报数，谁报到指定的数字，然后“出圈”，也就是从链表里删除，然后再从一开始报数，知道剩下最后一个为止，然后输出这个数。#include#includetypedef struct Node{ int value; struct Node *next;}NODE;void initcir(NODE *header);void outputscir(NODE *header);void calculatecir(NODE
栈+PTA
HeaoDng的博客
04-26 381
结构实现的栈，即利用一组地址连续的存储单元（
PTA数据结构答案
08-24
例如，"PTA数据结构答案"中的C或C++代码可能包括实现栈和队列的操作、二分查找、树的遍历、图的搜索算法等。解题过程会涉及到动态规划、贪心策略、回溯法等算法思想。这些实践性的题目对于提高编程能力、备战ACM/...
PTA分队列(C语言)
11-06
【PTA】分队列（C语言）是一个编程任务，主要涉及C语言的基本概念和数据结构，特别是队列的应用。在计算机科学中，队列是一种先进先出（First In First Out，简称FIFO）的数据结构，它在处理大量数据的顺序访问时...
code_pta_
10-04
同时，还可以学习如何有效地使用数据结构，如栈、队列、树、图等来解决问题。 在实际编程过程中，代码的可读性、效率和错误处理都是重要的考量因素。这些代码实例可能会展示如何进行错误调试，如何编写清晰的注释，...
PTA列车调度C语言版
12-30
火车站的列车调度铁轨的结构如下图所示。 两端分别是一条入口（Entrance）轨道和一条出口（Exit）轨道，它们之间有N条平行的轨道。每趟列车从入口可以选择任意一条轨道进入，最后从出口离开。在图中有9趟列车，在...
表达式转换(PTA)
woteicaile的博客
12-15 3431
算术表达式有前缀表示法、中缀表示法和后缀表示法等形式。日常使用的算术表达式是采用中缀表示法，即二元运算符位于两个运算数中间。请设计程序将中缀表达式转换为后缀表达式。 输入格式: 输入在一行中给出不含空格的中缀表达式，可包含+、-、*、\以及左右括号()，表达式不超过20个字符。 输出格式: 在一行中输出转换后的后缀表达式，要求不同对象（运算数、运算符号）之间以空格分隔，但结尾不得有多余空格。 输入样例: 2+3*(7-4)+8/4 输出样例: 2 3 7 4 - * + 8 4 / + 我的代码是格式错误，
PTA 特殊约瑟夫问题
LYQ_YXQ的博客
01-14 1410
PTA 特殊约瑟夫问题
CSP 2020 第三题：表达式
m0_46183615的博客
08-03 545
CSP 2020 第三题：表达式
day 9 回溯算法
最新发布
m0_73924943的博客
08-08 145
优化后的比之前的在叶子结点少递归一层。在排序candidates后，碰到target<0的情况直接结束本层的遍历，后面没遍历到的也不用遍历了。1.目标数n一直在随i的加入减小，如果目标数n已经<0，那么剪枝。即path中的数已经大于目标数了。利用数组去重，因为题目的数值范围小，所以可以尽量使用。剪枝优化：（对每层循环遍历的范围进行了缩小）2.对for循环i的遍历范围进行缩小。也可以不用st数组去重。
嵌入式初学-C语言-十五
MaBaB的博客
08-05 615
函数：实现一定功能的，独立的代码模块，我们的函数一定是先定义后使用使用函数的优势可以通过函数提供功能给别人使用，当然我们也可以使用别人提供的函数，减少代码量借助函数可以减少重复性代码。实现结构化（模块化）程序设计思想结构化程序设计思想：将大型的任务功能，划分为相互独立的小型的任务模块来设计3.函数是c语言程序的基本组成单元：C语言程序是由一个（必然是main函数）或多个函数组成。语法：返回类型 函数名(形参列表) -- 函数头 | 函数首部。
【算法】动态规划解决背包问题
2302_78914800的博客
08-04 455
1.动态规划算法的核心是：将大问题划分为小问题进行解决，从而一步步获取最优解的处理算法2.动态规划算法与分治算法类似，其基本思想也是将待求解问题分解成若干个子问题，先求解子问题，然后从这些子问题的解得到原问题的解3.与分治算法不同的是，适合于用动态规划求解的问题，经分解得到的子问题往往不是相互独立的（即下一个子阶段的求解是建立在上一个子阶段的解的基础上，进行进一步的求解）4.动态规划可以通过填表的方式来逐步推进，得到最优解。
学习笔记--算法（双指针）5
weixin_71085457的博客
08-04 656
学习自用！！
【算法】分治算法以及用分治算法解决汉诺塔问题
2302_78914800的博客
08-04 247
分治算法的思想是 “ 分而治之 ” ，就是把一个复杂的问题分成两个或更多的相同或相似的子问题，再把子问题分成更小的子问题......知道最后子问题可以简单的直接求解，原问题的解即子问题的解的合并。这个技巧是很多高效算法的基础。
windows消息队列pta
10-09
Windows消息队列（Windows Message Queue）是一种在Windows操作系统中实现进程间通信（IPC）的机制。它允许不同的应用程序之间通过消息进行通信，以便共享数据或执行某些特定的任务。 消息队列主要由两个部分组成：消息发送者和消息接收者。发送者将消息发送到队列中，接收者从队列中获取消息并进行处理。发送者和接收者可以是同一个应用程序的不同部分，也可以是不同的应用程序。 Windows消息队列的主要优点是它提供了一种异步通信的方式。发送者可以将消息发送到队列中后继续执行其他任务，而不需要等待接收者处理消息。接收者可以在合适的时候从队列中获取消息进行处理。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值