三.队列的运用

已于 2023-11-02 13:04:02 修改
阅读量180 收藏
点赞数
分类专栏： 数据结构C 文章标签： 算法 数据结构
于 2023-10-16 20:00:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74161592/article/details/133867952
版权

1.链队：

插入 删除 打印 取队顶
#include <stdio.h>
#include <stdlib.h>

typedef struct Qnode{
    int data;
    struct Qnode *next;
}Qnode,*QuenePtr;

typedef struct {
    QuenePtr front;
    QuenePtr rear;
}LinkQueue;
//初始化
void InitQueue(LinkQueue *q){
    (*q).front=(QuenePtr)malloc(sizeof (Qnode));
    if(!(*q).front) exit(0);
    (*q).front->next=NULL;
    (*q).rear=(*q).front;
}
//销毁
void DestroyQueue(LinkQueue *q){
    while((*q).front){
        (*q).rear=(*q).front->next;
        free((*q).front);
        (*q).front=(*q).rear;
    }
}
//判空
int IsEmpty(LinkQueue q){
    if(q.rear==q.front) return 1;
    else return 0;
}
//入队
void EnQueue(LinkQueue *q,int e){
    QuenePtr p=(QuenePtr)malloc(sizeof(Qnode));
    if(!p)exit(0);
    p->data=e;
    p->next=NULL;
    (*q).rear->next=p;
    (*q).rear=p;
    
}
//出队
void DeQueue(LinkQueue *q,int *e){
    if((*q).rear==((*q).front)) printf("Empty !");
    QuenePtr p=(*q).front->next;
    *e=p->data;
    (*q).front->next=p->next;
    if((*q).rear ==p) (*q).rear=(*q).front;
    free(p);
}
//打印
void Show(LinkQueue *q){
    for(Qnode *p=q->front->next ;p!=NULL;p=p->next){
        printf("%d ",p->data);
    }
    printf("\n");
}

int main(){
    LinkQueue q;
    InitQueue(&q);
    
    for(int i=0;i<5;i++){
        int e; scanf("%d",&e);
        EnQueue(&q,e);
    }
    Show(&q);
    
    if(IsEmpty(q)) printf("empty!");
    else printf("not empty");
    
    int e;DeQueue(&q,&e); printf("出队元素是：%d \n",e);
    Show(&q);
     
    int val;scanf("%d",&val);
    
    
    DestroyQueue(&q);
    return 0;
}

2.循环队列

wenti

#include<stdio.h>
#include<stdlib.h>
#define Maxsize 100

typedef struct {
    int *base;
    int front ;
    int rear;
}SqQueue;

//初始化
void InitQueue (SqQueue *q){
    q->base=(int *)malloc (Maxsize *sizeof (int));
    if(!q->base) exit(0);
    q->front=0;
    q->rear=0;
}
//入队
void EnterQueue(SqQueue *q,int e){
    if((q->rear+1)%Maxsize==q->front) printf("Full!\n");
    q->base[q->rear]=e;
    q->rear=(q->rear +1)%Maxsize;
}
//取队头元素
void getElem(SqQueue q,int *e){
    if(q.front!=q.rear){
        *e=q.base[q.front];
    }
    else {
        printf("Empty! \n");
    }
}
//求队长
int Getlength(SqQueue q){
    int e;
    e=(q.rear-q.front+Maxsize)%Maxsize;
    return e;
}
//出队
void PopQueue(SqQueue *q,int *e){
    if(q->front==q->rear) printf("Empty! \n");
    *e=q->base[q->front];
    q->front=(q->front+1)%Maxsize;
}
//打印
void Print(SqQueue q){
    for (int i=q.front;i!=q.rear;){
        printf("%d ",q.base[i]);
        i=(i+1)%Maxsize;
    }
    printf("\n");
}

int main(){
    SqQueue q;
    int e;
    for(int i=0;i<5;i++){
        scanf("%d",&e);
        EnterQueue(&q,e);
    }
    Print(q);
    getElem(q,&e);
    printf("队顶元素是 %d \n",e);
    
    int length=Getlength(q);
    printf("队长是%d \n",length);
     
    PopQueue(&q,&e);
    printf("出队元素是%d \n",e);
    Print(q);
    return 0;
}


#include<stdio.h>
#include<stdlib.h>
#include<math.h>
#define Maxsize 50

typedef struct {
    int *base;
    int front;
    int rear;
}SqQueue;

void InitQueue(SqQueue *Q){
    (*Q).base=(int )malloc(Maxsize*sizeof(int));
    if(!(*Q).base)exit(0);
    (*Q).front=0;
    (*Q).rear=0;
}

void EnterQueue(SqQueue *q,int e){
    if(((*q).base+1) %Maxsize==q->front){
        printf("Full");
    }
    q->base[q->rear]=e;
    q->rear=(q->rear+1)%Maxsize;
}

void PopQueue(SqQueue *q,int *e){
    if(q->front==q->rear){
        printf("empty!\n");
    }
    e=q->base[q->front];
    q->front=(q->front+1)%Maxsize;
}

int Emp(SqQueue q){
    if(q.front==q.rear) return 0;
    else return 1;
}

int main(){
    int n,m;
    scanf("%d %d",&n,&m);
    int a[n];
    SqQueue Q;
    InitQueue(&Q);
    for(int i=0;i<n;i++){
        scanf("%d ",&a[i]);
        EnterQueue(&Q,a[i]);
    }
    int e;
    for(int i=0;i<m;i++){
        PopQueue(&Q,&e);
        printf("%d ",e);
    }
    
    if(Emp(Q)==1) printf("\n1");
    else printf("\n0");
    return 0;
}


#include <stdio.h>
#include <stdlib.h>
 
#define TOTAL_SPACE 5
 
/**
 * Circle int queue.
 */
typedef struct CircleIntQueue
{
    int data[TOTAL_SPACE];
 
    int head;
 
    int tail;
}*CircleIntQueuePtr;
 
/**
 * Initialize the queue.
 */
CircleIntQueuePtr initQueue()
{
    CircleIntQueuePtr resultPtr = (CircleIntQueuePtr)malloc(sizeof(struct CircleIntQueue));
    resultPtr->head = 0;
    resultPtr->tail = 0;
 
    return resultPtr;
}// Of the first constructor
 
/**
 * Enqueue.
 *
 * @param paraValue The value of the new node.
 */
void enqueue(CircleIntQueuePtr paraPtr, int paraValue)
{
    if ((paraPtr->tail + 1) % TOTAL_SPACE == paraPtr->head) {
        printf("Queue full.\r\n");
        return;
    } // Of if
 
    paraPtr->data[paraPtr->tail % TOTAL_SPACE] = paraValue;
    paraPtr->tail++;
}// Of enqueue
 
/**
 * Dequeue.
 *
 * @return The value at the head.
 */
int dequeue(CircleIntQueuePtr paraPtr)
{
    int resultValue;
    if (paraPtr->head == paraPtr->tail) {
        printf("No element in the queue.\r\n");
        return -1;
    } // Of if
 
    resultValue = paraPtr->data[paraPtr->head % TOTAL_SPACE];
    paraPtr->head++;
 
    return resultValue;
}// Of dequeue
 
/**
 * Output the queue.
 */
void outputLinkQueue(CircleIntQueuePtr paraPtr)
{
    int i;
    if (paraPtr->head == paraPtr->tail)
    {
        printf("Empty queue.");
        return;
    } // Of if
 
    printf("Elements in the queue: ");
    for (i = paraPtr->head; i < paraPtr->tail; i++)
    {
        printf("%d, ", paraPtr->data[i % TOTAL_SPACE]);
    } // Of for i
 
    printf("\r\n");
}//Of outputLinkQueue
 
/**
 * Unit test.
 */
void testLinkQueue()
{
    int i = 10;
    CircleIntQueuePtr tempPtr = initQueue();
    for (; i < 16; i ++)
    {
        enqueue(tempPtr, i);
    }//Of for i
 
    outputLinkQueue(tempPtr);
 
    for (i = 0; i < 6; i ++)
    {
        printf("dequeue gets %d\r\n", dequeue(tempPtr));
    }//Of for i
 
    enqueue(tempPtr, 8);
    outputLinkQueue(tempPtr);
}//Of testLinkQueue
 
/**
 * The entrance.
 */
int main()
{
    testLinkQueue();
    return 1;
    
}

3.问题 A: 【DS3-6】基于顺序存储的循环队列的基本操作

[命题人 : admin_ly]
时间限制 : 1.000 sec  内存限制 : 128 MB
 
题目描述

用顺序存储结构实现队列的入队、出队和判断队列是否为空操作。

输入

第一行输入两个整数n和m，n表示入队序列A的长度（n个数依次连续入队，中间没有出队的情况），m表示出队序列B的元素数量（m个数依次连续出队，中间没有入队的情况）。第二行为序列A（空格分隔的n个整数），整数之间用空格分隔。

输出

第一行输出m个整数，代表出队序列B的各个整数，整数之间用空格分隔。

第二行输出一个整数表示队列是否为空，队列为空输出0，不为空输出1。

样例输入 Copy
<span style="background-color:#ffffff"><span style="color:#333333"><span style="background-color:#ffffff"><span style="color:#333333"><span style="background-color:#f5f5f5">5 3
1 3 5 3 6
</span></span></span></span></span>
样例输出 Copy
<span style="background-color:#ffffff"><span style="color:#333333"><span style="background-color:#ffffff"><span style="color:#333333"><span style="background-color:#f5f5f5">1 3 5
1</span></span></span></span></span>


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

//数据类型
#define ElemType int
//队列的最大空间
#define MAXSIZE 8
//队列的管理结构
typedef struct Queue
{
    ElemType *base; //指向队列空间的基址
    int       front; //头指针
    int       rear; //尾指针
}Queue;
//队列初始化
void InitQueue(Queue *Q)
{
    //为队列分配存储空间
    Q->base = (ElemType *)malloc(sizeof(ElemType) * MAXSIZE);
    if(Q->base == NULL) exit(0);
    //初始时队列为空，头指针和尾指针都指向0位置
    Q->front = 0;
    Q->rear = 0;
}

//入队操作
void EnQueue(Queue *Q, ElemType x)
{
    //判断循环队列是否已满
    if(((Q->rear+1)%MAXSIZE) == Q->front)
        printf("Full\n");
    //队列未满，将数据入队
    Q->base[Q->rear] = x;
    //更改尾指针的指向
    Q->rear = (Q->rear+1)%MAXSIZE;
}

//打印循环队列中的数据
void ShowQueue(Queue *Q)
{
    //遍历循环队列中的元素，并将数据打印
    for(int i=Q->front; i!=Q->rear;)
    {
        printf("%d ",Q->base[i]);
        //此操作是为了实现循环遍历
        i = (i+1)%MAXSIZE;
    }
    printf("\n");
}

//出队操作
int DeQueue(Queue *Q)
{
    //判断循环队列是否为空
    if(Q->front == Q->rear)
        printf("empty\n");
    //如果非空，实现可循环出队
    int e=Q->base[Q->front];
    Q->front = (Q->front+1)%MAXSIZE;
    return e;
}

int main()
{
    Queue Q;
    InitQueue(&Q);
    int m,n;
    scanf("%d %d",&n,&m);
    int a[n];
    for(int i=1; i<=n; ++i)
    {
        scanf("%d",&a[i]);
        EnQueue(&Q, a[i]);
    }
    for(int i=0;i<m;i++){
        int e=DeQueue(&Q);
        printf("%d ",e);
    }
    if(Q.front==Q.rear) printf("\n0");
    else printf("\n1");
    return 0;
}

 

2.问题 B: 【DS3-7】基于循环链表的队列的基本操作

[命题人 : admin_ly]
时间限制 : 1.000 sec  内存限制 : 128 MB
 
题目描述

用带头结点的循环链表表示队列，并且只设一个指针指向队尾元素结点（不设头指针）。实现该队列的入队、出队和判断队列是否为空操作。

输入

第一行输入两个整数n和m，n表示入队序列A的长度（n个数依次连续入队，中间没有出队的情况），m表示出队序列B的元素数量（m个数依次连续出队，中间没有入队的情况）。第二行为序列A（空格分隔的n个整数），整数之间用空格分隔。 

输出

第一行输出m个整数，代表出队序列B的各个整数，整数之间用空格分隔。
第二行输出一个整数表示队列是否为空，队列为空输出0，不为空输出1

样例输入 Copy
<span style="color:#333333"><span style="background-color:#ffffff"><span style="background-color:#ffffff"><span style="background-color:#ffffff"><span style="background-color:#ffffff"><span style="color:#333333"><span style="background-color:#f5f5f5">5 3
1 3 5 3 6
</span></span></span></span></span></span></span>
样例输出 Copy
<span style="color:#333333"><span style="background-color:#ffffff"><span style="background-color:#ffffff"><span style="background-color:#ffffff"><span style="background-color:#ffffff"><span style="color:#333333"><span style="background-color:#f5f5f5">1 3 5
1
</span></span></span></span></span></span></span>
#include<stdio.h>
#include<stdlib.h>

/**
 * 链式循环队列结点结构体定义
 */
typedef struct QNode {
    
    int data;
    
    struct QNode *next;
    struct QNode *rear;
} QNode;
void init(QNode **queue) {
    *queue = (QNode *) malloc(sizeof(QNode));
    // 将链式队列头结点的 next 和 rear 指针都指向自身，因为是循环的，并且是空队列
    (*queue)->next = *queue;
    (*queue)->rear = *queue;
}


void enQueue(QNode **rear, int ele) {
    QNode *newNode = (QNode *) malloc(sizeof(QNode));
    newNode->data = ele;
    newNode->next = NULL;
    newNode->next = (*rear)->next;
    (*rear)->next = newNode;
    (*rear) = newNode;
}


int deQueue(QNode **rear) {
    if ((*rear)->next == *rear) {
        return 0;
    }

    QNode *headNode = (*rear)->next;
     QNode *startNode = headNode->next;
    int ele;
    ele = startNode->data;
     headNode->next = startNode->next;
   
    if (startNode==*rear){
        *rear=(*rear)->next;
    }
    free(startNode);
    return ele;
}


int Is_empty(QNode **rear){
    if ((*rear)->next == *rear) {
        return 0;
    }
    else return 1;
}

int main() {
    QNode *queue;
    init(&queue);
    int n,m;
    scanf("%d %d",&n,&m);
    int a[n];
    for(int i=0;i<n;i++){
        scanf("%d",&a[i]);
        enQueue(&(queue->rear), a[i]);
    }
   
    for(int i=0;i<m;i++){
        int p= deQueue(&(queue->rear));
        printf("%d ",p);
    }
    printf("\n");
    if(Is_empty(&(queue->rear))==1){
        printf("1");
    }
       else printf("0");
    return 0;

   
    
   

}

AHNU-DS

3。问题 C: 【DS3-08】使用队列判断整数是否为回文数

[命题人 : 2022069]

时间限制 : 1.000 sec  内存限制 : 128 MB
 

题目描述

给你一个整数 x ，如果 x 是一个回文整数，返回 true ；否则，返回 false 。

回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。

例如，121 是回文，而 123 不是。

输入

一个整数x

输出

如果 x 是一个回文整数，返回 true ；否则，返回 false 。

样例输入 Copy
121
样例输出 Copy
true
#include <stdio.h>
#include <stdbool.h>

#define MAX_SIZE 100

typedef struct {
    int data[MAX_SIZE];
    int front;
    int rear;
} Queue;

void initQueue(Queue *q) {
    q->front = 0;
    q->rear = -1;
}

bool isQueueEmpty(Queue *q) {
    return q->rear < q->front;
}

bool isQueueFull(Queue *q) {
    return q->rear - q->front + 1 == MAX_SIZE;
}

void enqueue(Queue *q, int value) {
    if (isQueueFull(q)) {
        printf("Queue is full");
        return;
    }
    q->data[++q->rear] = value;
}

int dequeue(Queue *q) {
    if (isQueueEmpty(q)) {
        return -1;
    }
    return q->data[q->front++];
}
int dequeue1(Queue *q) {
    if (isQueueEmpty(q)) {
        return -1;
    }
    return q->data[q->rear--];
}
bool isPalindrome(int x) {
    if (x < 0) {  // 负数不是回文数
        return false;
    }
    Queue q;
    initQueue(&q);
    int temp = x;
    while (temp!= 0) {  // 将整数的每一位入队
    enqueue(&q,temp%10);temp=temp/10;
    }
    while (!isQueueEmpty(&q)) {  // 从队列头和队列尾分别取出数字比较
     if(dequeue(&q)!=dequeue1(&q)||dequeue(&q)&&dequeue1(&q)!=-1)
     return false;
    }    
    return true;
}

int main() {
    int num;
    scanf("%d", &num);
    if (isPalindrome(num)) {
        printf("true");
    } else {
        printf("false");
    }
    return 0;
}

initial- - -
关注
专栏目录
运用队列打印杨辉三角形的c语言代码,打印杨辉三角形C语言.doc
weixin_36350581的博客
05-24 915
使用队列打印杨辉三角形1.主要功能描述：使用队列的入队，出队，获得头结点和判断是否为空等等，来实现对杨辉三角形的打印，第i行上的元素要由第i-1行中的元素来生成。2. 设计分析：由杨辉三角形的特点，即每一行的第一个元素和最后一个元素均为1，其他位置上的数字是其上一行中与之相邻的两个整数之和。所以第i行上的元素要由第i-1行中的元素来生成。3. 运行效果图4.5.①重要变量用途说明 ②算法描述#in...
7.队列算法
感谢关注-最近在编写开源的自动化测试框架还没整理完
04-22 1356
队列是一种抽象的数据结构，有点类似于Stacks。与堆栈不同，队列的两端都是开放的。一端始终用于插入数据(入队)，另一端用于删除数据(出队)。队列遵循先进先出方法，即首先访问先存储的数据项。一个真实的队列示例可以是单车道单向道路，车辆首先进入，首先退出。更多真实世界的例子可以看作是售票窗口和公共汽车站的队列。
解释一下什么是Node.js中的事件队列？
有我更精彩的博客
07-26 1027
在现代JavaScript开发中，Node.js作为一种高效的服务器端开发环境，越来越受到开发者的青睐。其中一个重要概念就是事件队列（Event Queue），它帮助我们理解Node.js如何处理异步操作。通过这篇博客，我们将深入探讨Node.js中的事件队列，包括其工作原理以及在实际应用中的示例。
c语言 队列的运用
xuqingyuxu的博客
08-20 897
c语言 队列的运用
数据结构 | 队列的C++运用
qq_35800083的博客
01-24 1059
队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。 ——《百度百科》 目录 构造 相关函数 适用场景 循环队列 链队列 构造 队列又被称为 先进先出 （First In First Out） 的线性表，简称 FIFO 队列。 其构造函数如下： queue<int> queue; 判断队列空的方法：队首标...
Python 多线程与队列运用实例
热门推荐
生活屁颠过的博客
02-13 2万+
多线程与队列运用实例 #!/usr/bin/env python #-*- coding: utf-8 -*- # import threading import queue as Queue class RunThread(threading.Thread): def __init__(self,name,q): threading.Thread.__init__(s...
C# 1.消息队列MQ使用场景--图文解析
Blue
02-23 1836
C# 1.消息队列MQ使用场景--图文解析
队列——Acwing.829模拟队列
u014114223的博客
06-14 859
队列是一种特殊的线性表，遵循先进先出（First In First Out，FIFO）的原则。可以进行入队（在队尾添加元素）和出队（从队首移除元素）操作。
算法思想总结：优先级队列
weixin_51142926的博客
07-05 1814
优先级队列的本质其实是堆。
RabbitMQ——死信队列的三大来源应用举例
贝尔摩德苦艾酒
10-21 6460
RabbitMQ——死信队列的三大来源应用举例
【ASP.NET编程知识】运用.NetCore实例讲解RabbitMQ死信队列,延时队列.docx
05-21
三、延时消息设置不同过期时间 在RabbitMQ中，我们可以设置消息的过期时间，然后在该时间点将消息发送到延时队列。在ASP.NET编程中，我们可以使用RabbitMQ的延时消息功能来实现消息的延迟处理。 例如，我们可以...
duilie.zip_循环储存_队列的运用
09-20
本文将详细探讨"循环储存"与"队列的运用"，并结合文件"172206100260杨靖冬队列"来深化理解。 队列是一种线性数据结构，遵循“先进先出”（FIFO，First In First Out）的原则。在实际应用中，队列常被用于任务调度、...
栈和队列的运用.doc
10-08
栈和队列的运用 栈和队列是数据结构中两个非常重要的概念，它们广泛应用于计算机科学和信息技术领域。栈是一种特殊的线性表，遵循先进后出的原则，即最后一个入栈的元素将是第一个出栈的元素。栈可以通过顺序栈和...
ComQueue.rar_labview 队列_labview串口队列_串口 队列
07-14
本示例“ComQueue.rar”中的“ComQueue.vi”文件，显然是一个利用LabVIEW实现的串口通信程序，其中运用了队列来确保数据的有序传输。 首先，我们来理解一下队列的基本概念。队列是一种先进先出（FIFO, First In ...
PCA（主成分分析）算法的应用场景
huanfeng_AI的博客
11-09 454
需要注意的是，PCA并不适用于所有场景。例如，当数据之间存在非线性关系时，PCA可能无法完全揭示数据的内在结构。此外，PCA对初始变量的顺序和标签敏感，不同的变量顺序可能导致不同的主成分结果。因此，在选择数据分析方法时，需要根据具体的数据和任务需求来决定是否使用PCA。
1163：阿克曼(Ackmann)函数
最新发布
呆萌很的博客
11-12 172
1163：阿克曼(Ackmann)函数
0-Equity-Transformer：求解NP-Hard Min-Max路由问题的顺序生成算法（AAAI-24)(完)（code）
太极生两鱼
11-12 47
最小最大路由问题旨在通过智能体合作完成任务来最小化多个智能体中最长行程的长度。这些问题包括对现实世界有重大影响的应用场景，但已知属于NP-hard问题。现有方法在大规模问题上面临挑战，尤其是在需要协调大量智能体以覆盖数千个城市的情况下。本文提出了Equity-Transformer来解决大规模最小最大路由问题。首先，我们采用顺序规划方法来处理最小最大路由问题，使我们能够利用强大的序列生成器（例如，Transformer）。其次，我们提出了关键的归纳偏差，以确保智能体之间的公平工作量分配。
点云配准之点到点，点到面，点到线ICP，NDT算法介绍
qq_54375651的博客
11-10 1284
点云配准在人工智能，自动驾驶，SLAM等任务中具有十分关键的作用，本文将介绍点云配准的点到点，点到线，点到面ICP和NDT算法
算法每日双题精讲——双指针（有效三角形的个数，和为s的俩个数）
A Charmer 的博客
11-09 1239
本文围绕算法中的双指针技巧，详细讲解了 “有效三角形的个数” 和 “和为 s 的俩个数” 两道题目。对于 “有效三角形的个数”，通过排序数组后利用双指针遍历统计满足条件的三元组；“和为 s 的俩个数” 则是先排序，再用双指针找到和为目标值的两个数的下标。文中给出了 C++ 代码实现，并分析了每道题的时间复杂度和空间复杂度，最后强调双指针算法在解决数组问题中的优势，鼓励读者在算法学习中掌握该技巧。
队列在消息队列方面的运用
03-30
队列在消息队列方面的运用非常广泛，它是一种常见的数据结构，用于实现消息的异步传输和处理。消息队列是一种基于生产者-消费者模型的通信机制，通过将消息发送到队列中，实现了解耦和异步处理的目的。 在消息队列...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值