队列重点操作代码集锦

已于 2024-03-19 21:41:49 修改
阅读量495 收藏 6
点赞数 12
分类专栏： 《数据结构及应用算法教程》严蔚敏 陈文博 文章标签： 数据结构
于 2024-03-19 20:39:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_72674633/article/details/136854058
版权

目录

队列的介绍

链队列的重点操作

1.队列的创建和初始化

2.入队

3.出队

4.取队头元素

5.输出队列

6.全部操作代码

循环队列的重点操作

1.队列的创建和初始化

2.入队

3.出队

4.取队头元素

5.求队列长度

6.输出队列

7.全部操作代码

队列的应用

1.编写一个打印二项式系数表（即杨辉三角）

2.运动会划分子集问题

队列的介绍

队列（Queue）是一种先进先出（FIFO，First-In-First-Out）的线性表。

在具体应用中通常用链表或者数组来实现。队列只允许在后端（称为 rear）进行插入操作，在前端（称为 front）进行删除操作。

链队列的重点操作

1.队列的创建和初始化

typedef struct {
	int data;
	struct QNode* next;
}QNode;

typedef struct {
	QNode* front;//队头指针
	QNode* rear;//队尾指针
}LinkQueue;

//初始化
LinkQueue* InitQueue() {
	LinkQueue* Q = malloc(sizeof(LinkQueue));//生成队头队尾指针
	Q->front = (QNode*)malloc(sizeof(QNode));//生成新结点作为头结点，队头队尾指针指向该结点
	Q->rear = Q->front;
	Q->front->next = NULL;//头结点指针域置空
	return Q;
}

2.入队

//入队
void EnQueue(LinkQueue* Q, int e) {
	QNode* p = malloc(sizeof(QNode));//生成新结点
	p->data = e;//新结点数据域置为e，指针域置空
	p->next = NULL;
	Q->rear->next = p;//新结点插入队尾
	Q->rear = p;//修改队尾指针
}

3.出队

//出队
bool DeQueue(LinkQueue* Q, int* e) {
	//删除队头元素，用e返回其值
	if (Q->front == Q->rear)	return false;//判断队列是否为空
	QNode* p = Q->front->next;//p指向队头元素
	*e = p->data;//e保存队头元素
	Q->front->next = p->next;//修改头结点指针域
	if (Q->rear == p)	Q->rear = Q->front;//最后一个元素被删，队尾指针指向头结点
	free(p);//释放队头元素空间
	return true;
}

4.取队头元素

//取队头元素
bool GetHead(LinkQueue* Q, int* e) {
	//返回队头元素，不修改队头指针
	if (Q->front == Q->rear)	return false;//判断队列是否为空
	QNode* p = Q->front->next;
	*e = p->data;//用e返回队头元素值
	return true;
}

5.输出队列

//输出
void print(LinkQueue* Q) {
	//前提为队不为空
	printf("(front) ");
	if (Q->front != Q->rear) {
		QNode* p = Q->front->next;
		while (p != NULL) {
			printf("%d ", p->data);
			p = p->next;
		}
	}
	printf("(rear)\n");
}

6.全部操作代码

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>//使用bool类型的头文件 

typedef struct {
	int data;
	struct QNode* next;
}QNode;

typedef struct {
	QNode* front;//队头指针
	QNode* rear;//队尾指针
}LinkQueue;

//初始化
LinkQueue* InitQueue() {
	LinkQueue* Q = malloc(sizeof(LinkQueue));//生成队头队尾指针
	Q->front = (QNode*)malloc(sizeof(QNode));//生成新结点作为头结点，队头队尾指针指向该结点
	Q->rear = Q->front;
	Q->front->next = NULL;//头结点指针域置空
	return Q;
}
//入队
void EnQueue(LinkQueue* Q, int e) {
	QNode* p = malloc(sizeof(QNode));//生成新结点
	p->data = e;//新结点数据域置为e，指针域置空
	p->next = NULL;
	Q->rear->next = p;//新结点插入队尾
	Q->rear = p;//修改队尾指针
}
//出队
bool DeQueue(LinkQueue* Q, int* e) {
	//删除队头元素，用e返回其值
	if (Q->front == Q->rear)	return false;//判断队列是否为空
	QNode* p = Q->front->next;//p指向队头元素
	*e = p->data;//e保存队头元素
	Q->front->next = p->next;//修改头结点指针域
	if (Q->rear == p)	Q->rear = Q->front;//最后一个元素被删，队尾指针指向头结点
	free(p);//释放队头元素空间
	return true;
}
//取队头元素
bool GetHead(LinkQueue* Q, int* e) {
	//返回队头元素，不修改队头指针
	if (Q->front == Q->rear)	return false;//判断队列是否为空
	QNode* p = Q->front->next;
	*e = p->data;//用e返回队头元素值
	return true;
}
//输出
void print(LinkQueue* Q) {
	//前提为队不为空
	printf("(front) ");
	if (Q->front != Q->rear) {
		QNode* p = Q->front->next;
		while (p != NULL) {
			printf("%d ", p->data);
			p = p->next;
		}
	}
	printf("(rear)\n");
}
int main() {
	LinkQueue* Q = InitQueue();
	int i, n, e;
	scanf("%d", &n);
	for (i = 0; i < n; i++) {
		scanf("%d", &e);
		EnQueue(Q, e);
	}
	print(Q);
	DeQueue(Q, &e);
	printf("%d\n", e);
	print(Q);
	return 0;
}

循环队列的重点操作

1.队列的创建和初始化

typedef struct {
	int* base;//储存空间的基地址
	int front;//头指针
	int rear;//尾指针
	int maxsize;//队列最大长度
}SqQueue;

//初始化
SqQueue* InitQueue(int size) {
	SqQueue* Q = malloc(sizeof(SqQueue));//先创建队列结构体指针
	Q->base = (int*)malloc(sizeof(int) * size);//为队列分配一个最大容量为size的数组空间
	//队列最大长度置为size，头指针尾指针置为0，队列为空
	Q->maxsize = size;
	Q->front = 0;
	Q->rear = 0;
	return Q;
}

2.入队

//入队
bool EnQueue(SqQueue* Q, int e) {
	//插入e作为新队尾元素
	if ((Q->rear + 1) % Q->maxsize == Q->front)	return false;//尾指针在循环意义上加1后等于头指针说明队满
	Q->base[Q->rear] = e;//将元素e插入队尾
	Q->rear = (Q->rear + 1) % Q->maxsize;//尾指针加1
	return true;
}

3.出队

//出队
bool DeQueue(SqQueue* Q, int* e) {
	//删除队头元素，用e返回其值
	if (Q->front == Q->rear)	return false;//队空
	*e = Q->base[Q->front];//用e保存队头元素
	Q->front = (Q->front + 1) % Q->maxsize;//头指针加1
	return true;
}

4.取队头元素

//取队头元素
bool GetHead(SqQueue* Q, int* e) {
	//返回队头元素，不修改头指针
	if (Q->front == Q->rear)	return false;//队空
	*e = Q->base[Q->front];
	return true;
}

5.求队列长度

//取队头元素
bool GetHead(SqQueue* Q, int* e) {
	//返回队头元素，不修改头指针
	if (Q->front == Q->rear)	return false;//队空
	*e = Q->base[Q->front];
	return true;
}

6.输出队列

//输出
void print(SqQueue* Q) {
	printf("(front) ");
	int i;
	//跟遍历数组差不多，就是要通过模运算防止越界
	for (i = Q->front; i != Q->rear; i = (i + 1) % Q->maxsize) {
		printf("%d ", Q->base[i]);
	}
	printf("(rear)\n");
}

7.全部操作代码

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

typedef struct {
	int* base;//储存空间的基地址
	int front;//头指针
	int rear;//尾指针
	int maxsize;//队列最大长度
}SqQueue;

//初始化
SqQueue* InitQueue(int size) {
	SqQueue* Q = malloc(sizeof(SqQueue));//先创建队列结构体指针
	Q->base = (int*)malloc(sizeof(int) * size);//为队列分配一个最大容量为size的数组空间
	//队列最大长度置为size，头指针尾指针置为0，队列为空
	Q->maxsize = size;
	Q->front = 0;
	Q->rear = 0;
	return Q;
}
//输出
void print(SqQueue* Q) {
	printf("(front) ");
	int i;
	//跟遍历数组差不多，就是要通过模运算防止越界
	for (i = Q->front; i != Q->rear; i = (i + 1) % Q->maxsize) {
		printf("%d ", Q->base[i]);
	}
	printf("(rear)\n");
}
//入队
bool EnQueue(SqQueue* Q, int e) {
	//插入e作为新队尾元素
	if ((Q->rear + 1) % Q->maxsize == Q->front)	return false;//尾指针在循环意义上加1后等于头指针说明队满
	Q->base[Q->rear] = e;//将元素e插入队尾
	Q->rear = (Q->rear + 1) % Q->maxsize;//尾指针加1
	return true;
}
//出队
bool DeQueue(SqQueue* Q, int* e) {
	//删除队头元素，用e返回其值
	if (Q->front == Q->rear)	return false;//队空
	*e = Q->base[Q->front];//用e保存队头元素
	Q->front = (Q->front + 1) % Q->maxsize;//头指针加1
	return true;
}
//取队头元素
bool GetHead(SqQueue* Q, int* e) {
	//返回队头元素，不修改头指针
	if (Q->front == Q->rear)	return false;//队空
	*e = Q->base[Q->front];
	return true;
}
//求队列长度
int QueueLength(SqQueue* Q) {
	//返回队列元素个数
	return (Q->rear - Q->front + Q->maxsize) % Q->maxsize;
}
int main() {
	int i, n, e;
	SqQueue* Q = InitQueue(5);
	scanf("%d",&n);
	for (i = 0; i < n; i++) {
		scanf("%d", &e);
		EnQueue(Q, e);
	}
	print(Q);
	DeQueue(Q, &e);
	printf("e=%d\n", e);
	DeQueue(Q, &e);
	printf("e=%d\n", e);
	DeQueue(Q, &e);
	printf("e=%d\n", e);
	scanf("%d",&n);
	for (i = 0; i < n; i++) {
		scanf("%d", &e);
		EnQueue(Q, e);
	}
	print(Q);
}

队列的应用

1.编写一个打印二项式系数表（即杨辉三角）

#include<stdio.h>
#include<stdbool.h>
// 假设队列的结构体定义如下，根据需要进行调整
#define MAXSIZE 100
typedef struct {
    int data[MAXSIZE];
    int front;
    int rear;
} SqQueue;

// 初始化队列
void InitQueue_Sq(SqQueue *Q, int size) {
    Q->front = Q->rear = 0;
}

// 入队
bool EnQueue_Sq(SqQueue *Q, int x) {
    if ((Q->rear + 1) % MAXSIZE == Q->front) {
        return false;  // 队列已满
    }
    Q->data[Q->rear] = x;
    Q->rear = (Q->rear + 1) % MAXSIZE;
    return true;
}

// 出队
bool DeQueue_Sq(SqQueue *Q, int *x) {
    if (Q->front == Q->rear) {
        return false;  // 队列为空
    }
    *x = Q->data[Q->front];
    Q->front = (Q->front + 1) % MAXSIZE;
    return true;
}

// 获取队头元素
bool GetHead_Sq(SqQueue *Q, int *x) {
    if (Q->front == Q->rear) {
        return false;  // 队列为空
    }
    *x = Q->data[Q->front];
    return true;
}

// 判断队列是否为空
bool QueueEmpty(SqQueue *Q) {
    return Q->front == Q->rear;
}

void Yanghui(int n) {
    SqQueue Q;
    int i, k, s, e;
    for(i=1;i<=n;i++){
    	printf(" ");
	}
	printf("1\n");
    InitQueue_Sq(&Q, n + 2);
    EnQueue_Sq(&Q, 0);
    EnQueue_Sq(&Q, 1);
    EnQueue_Sq(&Q, 1);
    k = 1;
    while (k < n) {
        for (i = 1; i <= n - k; i++) {
            printf(" ");
        }
        EnQueue_Sq(&Q, 0);
        do {
            DeQueue_Sq(&Q, &s);
            GetHead_Sq(&Q, &e);
            if (e != 0) {
                printf("%d ", e);
            } else {
                printf("\n");
            }
            EnQueue_Sq(&Q, s + e);
        } while (e != 0);
        k++;
    }
}

int main() {
    Yanghui(5);  // 打印5行的杨辉三角
    return 0;
}

2.运动会划分子集问题

#include<stdio.h>
#include<stdlib.h>
#define MAXSIZE 10

typedef struct SqQueue{
    int *base;// 队列元素
    int front;// 队首
    int rear;// 队尾
}SqQueue;

//队列的初始化
void InitQueue(SqQueue *Q){
    Q->base = (int*)malloc(MAXSIZE *sizeof(int));
    if(Q->base == NULL){
        printf("内存分配失败");
    }
    Q->front = Q->rear = 0;
}
// 判断队列是否为空
int IsEmpty(SqQueue q){
    if(q.rear == q.front){
        return 1;
    }
    return 0;
}

int IsFull(SqQueue q){
    if((q.rear+1)%MAXSIZE ==q.front){
        return 1;
    }
    return 0;
}
//队列元素的增加
int EnQueue(SqQueue *q,int e){
    if((q->rear + 1)%MAXSIZE == q->front){
        return 0;
    }
    q->base[q->rear] = e;
    q->rear = (q->rear + 1)%MAXSIZE;
    return 1;
}
//队列元素的删除
int DeQueue(SqQueue *q,int *x){
    if(q->front == q->rear){
        return 0;
    }
    *x = q->base[q->front];
    q->front = (q->front + 1)%MAXSIZE;
    return 1;
}

void PrintQueue(SqQueue q){
    int len = (q.rear-q.front+MAXSIZE)%MAXSIZE;
    int i,j;
    for(i = 0,j = q.front;i<len;i++,j = (j+1)%MAXSIZE){
        printf("%d ",q.base[j]);
    }
}
// 分类的实现
void DivdeQueue(int R[][9]){
    int result[9] = {0};// 结果矩阵，存放分组结果
    int Group = 0;// 组号

    // 创建循环队列同时初始化
    SqQueue q;
    InitQueue(&q);

    // 将元素排入队列
    int i;
    for(i= 0;i<9;i++){
        EnQueue(&q,i);
    }

    int PreItem = q.rear;
    int CurItem;

    int newr[9] = {0};

    while(!IsEmpty(q)){
        Group += 1;
        for(i = 0;i<9;i++){
            newr[i] = R[q.base[q.front]][i];
        }
        while(q.front!=PreItem){
            DeQueue(&q,&CurItem);
            if(newr[CurItem]==0){
                result[CurItem] = Group;
                for(i = 0;i<9;i++){
                    newr[i] += R[i][CurItem];
                }
            }else{
                EnQueue(&q,CurItem);
            }
        }
        PreItem = q.rear;
    }
    printf("开始输出结果");
    printf("\n");
    int p;
    for(p = 1;p<=Group;p++){
        int q;
        for(q = 0;q<9;q++){
            if(result[q]==p){
                printf("%d ",q+1);
            }
        }
        printf("\n");
    }
}

int main(){
    int R[9][9] = {
        0,1,0,0,0,0,0,0,0,
        1,0,0,0,1,1,0,1,1,
        0,0,0,0,0,1,1,0,0,
        0,0,0,0,1,0,0,0,1,
        0,1,0,1,0,1,1,0,1,
        0,1,1,0,1,0,1,0,0,
        0,0,1,0,1,1,0,0,0,
        0,1,0,0,0,0,0,0,0,
        0,1,0,1,1,0,0,0,0
    };
    DivdeQueue(R);
    return 0;
}
互联网的猫
关注
  • 12
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
队列及代码
09-15
队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作队列的元素是按照先进先出的原则
写一段C语言队列出队的代码
weixin_42588555的博客
02-10 229
下面是一段简单的队列出队的代码： #include <stdio.h> #define MAX_SIZE 100 int queue[MAX_SIZE]; int front = 0; int rear = 0; void dequeue() { if (front == rear) { printf("队列已空，无法出队\n"); return; } ...
（队列篇）1、队列的概念及其基本操作（采用顺序存储结构，C++代码编写，包括初始化、入队、出队、获取当前队列长度等）
最新发布
颜安青的小世界
04-26 1145
此篇文章是采用顺序存储的方式实现队列，在内存中分配一块连续的存储单元存放队列中的元素（相当于创建一个数组而已），还要建立 front 和 rear 指针（虽说是指针，其实就是记住队头和队尾的位置，方便进行插入和删除），本文中 front 指向队头元素，rear 指向队尾元素的下一个位置。（其实如果出队了的话，数组前面其实还是有位置的，所以会造成假溢出，这可以用循环队列进行处理。若队列非空，则将队头元素赋值给x，记住不会改变队列，仅仅是读取而已。若队列非空，删除队头元素，并用x返回。大家一起学，一起进步！
队列代码实现
花园宝宝没有天线的博客
01-18 383
【代码】队列代码实现
简易队列代码:包含基本功能 1.入队 2.出队 3.销毁队列
weixin_52769294的博客
09-12 331
#include<stdio.h> #include<stdlib.h> //队列节点结构体 typedef struct node { //数据域 int data; //指针域 struct node *next; }*Queue_node; //队列管理结构 typedef struct queue { int size; struct node *queue_head; struct node *queue_t.
C语言队列的出队
weixin_44248028的博客
12-05 625
int OutQueue(LinkQueue *Q,char *x)//出队操作 { QNode *p; if(Q->front==Q->rear) { return 0; free(p); } else {`在这里插入代码片` p=Q->front->next; strcpy(x,p->data); Q-&gt...
实验二 堆栈和队列基本操作的编程实现
02-09
本次实验重点在于理解和实现堆栈和队列的基本操作，包括创建、进栈、出栈、进队和出队。在顺序栈的实现中，关键在于理解栈顶指针的移动和如何正确处理栈溢出情况。通过实现将十进制数转换为r进制的功能，加深了对栈...
cpp代码-队列的静态实现
07-14
本知识重点讲解如何在C++中实现一个静态队列。静态队列通常指的是使用数组来存储元素，而非动态内存分配。 在C++中，我们可以通过定义一个结构体或类来实现队列。以下是一个简单的静态队列实现的概述： 1. **定义...
jQuery图片文件批量上传队列代码.zip
09-21
队列管理确保了文件按顺序上传，并在上传过程中保持用户的操作流畅性。 2. **异步上传**：利用XMLHttpRequest或Fetch API实现文件的分块上传，避免一次性加载大量文件导致的内存压力。同时，这允许在上传过程中展示...
队列实现的内存管理源代码
07-14
本文将详细探讨"队列实现的内存管理源代码"这一主题，重点解析其在Linux环境下的应用及工作原理。 队列是一种线性数据结构，具有先进先出（FIFO）的特性，即最早进入队列的元素最先被处理。在内存管理中，队列可以...
操作系统实验代码以及实验报告
05-12
文件的I/O操作、缓冲技术、文件权限和访问控制也是重点。可能还会涉及到磁盘调度算法，如FCFS、SCAN和C-SCAN，用于优化磁盘访问效率。 4. **文档资料**： 实验报告通常包含了实验的目的、步骤、观察结果和结论。这...
C++队列操作入队出队
10-22
简单队列操作，vc++实现。队列类实现，小弟新手，大神莫黑
队列的基本操作
06-03
vs中实现队列的基本操作队列的进队、出队，返回队头，计算队列的大小
链式队列各种基本运算算法的实现
07-17
链式队列是不同于循环数组的另一种队列的实现形式。队列中的元素以Node形式存储。节点Node中存有此节点存于队列中的元素以及指向下一个元素的指针。链式队列的需要保存指向队头和队尾的指针的数据成员。 参见博客：http://blog.csdn.net/xiaowei_cqu/article/details/7748247
数据结构-队列的定义及基本操作(代码+报告)
03-30
数据结构-队列的定义及基本操作(代码+报告)
数据结构循环顺序队列的入队出队代码实现7.22(分文件 c语言)
qq_60071225的博客
07-22 3493
1、数据结构循环顺序队列创建代码 2、循环顺序队列出队入队操作代码实现
出队列c语言程序,队列的c语言实现
weixin_33415023的博客
05-18 1037
#include #include //实现队列的数据结构//队列是只允许队尾插入，队头删除的存储结构//先来看顺序存储结构(数组实现)#define OK 1#define ERROR -1#define MAX 10 //定义队列的长度typedef int ElemType;typedef int Status;typedef struct {ElemType data[MAX];int h...
关于循环队列指针初始位置的讨论。入队出队代码
debug_h的博客
01-29 743
入队出队操作，front rear 值讨论
链式队列的基本操作（详细）
qq_43346784的博客
07-08 7784
队列的基本操作（）链式 ，详细
栈和队列：链队列操作与实现
"链队列操作-栈和队列" 栈和队列是两种重要的数据结构，它们在计算机科学和编程中广泛应用。本资源主要涵盖了栈和队列的基础知识，包括它们的类型定义、表示和实现，以及在实际问题中的应用。 首先，栈是一种后进...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

互联网的猫

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值