顺序队列基本操作代码实现

最新推荐文章于 2024-04-26 10:00:00 发布
最新推荐文章于 2024-04-26 10:00:00 发布
阅读量1k 收藏 11
点赞数
分类专栏： 王道考研数据结构（含上机实验)
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43638873/article/details/115467265
版权

顺序队列中包含了队头指针和队尾指针，按照队尾指针所指向的位置的不同，可将顺序队列分成了如下两种：

一、队尾指针指向队尾元素的后一个位置：
在针对队列的基本操作中，如何判空和判满？有以下三种办法
（1）牺牲掉一个存储空间：

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

//顺序队列的数据类型定义
#define ElemType int
#define MaxSize 15
typedef struct{
	ElemType data[MaxSize];
	int front,rear;
}SqQueue;

//初始化顺序队列Q：
void InitQueue(SqQueue &Q)
{
	Q.front=0;
	Q.rear=0;
}

//判空操作：
bool QueueEmpty(SqQueue Q)
{
	if(Q.front==Q.rear)return true;
	else return false;
}

//入队操作：
bool EnQueue(SqQueue &Q,ElemType x)
{
	if((Q.rear+1)%MaxSize==Q.front)return false;
	Q.data[Q.rear]=x;
	Q.rear=(Q.rear+1)%MaxSize;
	printf("\n此队列中目前有: %d个元素\n",(Q.rear+MaxSize-Q.front)%MaxSize);
	return true;
}

//出队操作： 
bool DeQueue(SqQueue &Q,ElemType &x)
{
	if(Q.front==Q.rear)return false;
	printf("\n此队列中目前有: %d个元素\n",(Q.rear+MaxSize-Q.front)%MaxSize);
    x=Q.data[Q.front];
    Q.front=(Q.front+1)%MaxSize;
	return true;
}

//获得队头元素的值：
bool GetTop(SqQueue Q,ElemType &x)
{
	if(Q.front==Q.rear)return false;
    x=Q.data[Q.front];
    printf("\n此队列中目前有: %d个元素\n",(Q.rear+MaxSize-Q.front)%MaxSize);
	return true;
}

//主函数 
int main()
{
	int x;
	SqQueue Q; //声明一个顺序队列Q
	InitQueue(Q); //初始化顺序队列Q 
	
	if(QueueEmpty(Q))printf("\n此队列为空\n");
	else printf("\n此队列不空\n");
	
	printf("\n向队列中输入元素:\n");
	while(1)
	{
		scanf("%d",&x);
		if(x==9999)
		{
			printf("\n输入结束\n");
			break;
	    }
		if(EnQueue(Q,x))printf("\n成功入队\n");
		else{
			printf("\n队列已满\n");
			break;
		}
	}
	
	if(GetTop(Q,x))printf("\n队头元素为: %d\n",x);
	
	if(QueueEmpty(Q))printf("\n此队列为空\n");
	else printf("\n此队列不空\n");
	
	printf("\n依次出队:\n");
	while(DeQueue(Q,x))
	{
		printf("%d ",x);
	}
	printf("\n");
	
	return 0; 
}

我特地在基本操作函数中加了个输出语句，用来输出当前顺序队列中元素的个数。

（2）在队列的数据类型定义中设置一个新的成员size，用来保存当前队列内的元素个数，这个size随着入队和出队操作而发生变化：（这样就保证了每个存储空间都被利用）

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

//顺序队列的数据类型定义
#define ElemType int
#define MaxSize 15
typedef struct{
	ElemType data[MaxSize];
	int front,rear;
	int size;
}SqQueue;

//初始化顺序队列Q：
void InitQueue(SqQueue &Q)
{
	Q.front=0;
	Q.rear=0;
	Q.size=0;
}

//判空操作：
bool QueueEmpty(SqQueue Q)
{
	if(Q.size==0)return true;
	else return false;
}

//入队操作：
bool EnQueue(SqQueue &Q,ElemType x)
{
	if(Q.size==MaxSize)return false;
	Q.data[Q.rear]=x;
	Q.rear=(Q.rear+1)%MaxSize;
	Q.size++;
	printf("\n此队列中目前有: %d个元素\n",Q.size);
	return true;
}

//出队操作： 
bool DeQueue(SqQueue &Q,ElemType &x)
{
	if(Q.size==0)return false;
	printf("\n此队列中目前有: %d个元素\n",Q.size);
    x=Q.data[Q.front];
    Q.front=(Q.front+1)%MaxSize;
    Q.size--;
	return true;
}

//获得队头元素的值：
bool GetTop(SqQueue Q,ElemType &x)
{
	if(Q.size==0)return false;
    x=Q.data[Q.front];
    printf("\n此队列中目前有: %d个元素\n",Q.size);
	return true;
}

//主函数 
int main()
{
	int x;
	SqQueue Q; //声明一个顺序队列Q
	InitQueue(Q); //初始化顺序队列Q 
	
	if(QueueEmpty(Q))printf("\n此队列为空\n");
	else printf("\n此队列不空\n");
	
	printf("\n向队列中输入元素:\n");
	while(1)
	{
		scanf("%d",&x);
		if(x==9999)
		{
			printf("\n输入结束\n");
			break;
	    }
		if(EnQueue(Q,x))printf("\n成功入队\n");
		else{
			printf("\n队列已满\n");
			break;
		}
	}
	
	if(GetTop(Q,x))printf("\n队头元素为: %d\n",x);
	
	if(QueueEmpty(Q))printf("\n此队列为空\n");
	else printf("\n此队列不空\n");
	
	printf("\n依次出队:\n");
	while(DeQueue(Q,x))
	{
		printf("%d ",x);
	}
	printf("\n");
	
	return 0; 
}

（3）在队列的数据类型定义中增加一个成员tag，tag为0表示之前进行了删除操作，为1表示之前进行了插入操作，当队头指针和队尾指针相同时，如果tag=0表示队空，tag=1则表示队满：

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

//顺序队列的数据类型定义
#define ElemType int
#define MaxSize 15
typedef struct{
	ElemType data[MaxSize];
	int front,rear;
	int tag;
}SqQueue;

//统计当前队列中元素个数：
int QueueElemNumber(SqQueue &Q)
{
	if(Q.tag==1&&Q.rear==Q.front)return MaxSize;
	else return (Q.rear+MaxSize-Q.front)%MaxSize;
}

//初始化顺序队列Q：
void InitQueue(SqQueue &Q)
{
	Q.front=0;
	Q.rear=0;
	Q.tag=0;
}

//判空操作：
bool QueueEmpty(SqQueue Q)
{
	if(Q.front==Q.rear&&Q.tag==0)return true;
	else return false;
}

//入队操作：
bool EnQueue(SqQueue &Q,ElemType x)
{
	if(Q.front==Q.rear&&Q.tag==1)return false;
	Q.data[Q.rear]=x;
	Q.rear=(Q.rear+1)%MaxSize;
	Q.tag=1;
	printf("\n此队列中目前有: %d个元素\n",QueueElemNumber(Q));
	return true;
}

//出队操作： 
bool DeQueue(SqQueue &Q,ElemType &x)
{
	if(Q.front==Q.rear&&Q.tag==0)return false;
	printf("\n此队列中目前有: %d个元素\n",QueueElemNumber(Q));
    x=Q.data[Q.front];
    Q.front=(Q.front+1)%MaxSize;
    Q.tag=0;
	return true;
}

//获得队头元素的值：
bool GetTop(SqQueue Q,ElemType &x)
{
	if(Q.front==Q.rear&&Q.tag==0)return false;
    x=Q.data[Q.front];
    printf("\n此队列中目前有: %d个元素\n",QueueElemNumber(Q));
	return true;
}

//主函数 
int main()
{
	int x;
	SqQueue Q; //声明一个顺序队列Q
	InitQueue(Q); //初始化顺序队列Q 
	
	if(QueueEmpty(Q))printf("\n此队列为空\n");
	else printf("\n此队列不空\n");
	
	printf("\n向队列中输入元素:\n");
	while(1)
	{
		scanf("%d",&x);
		if(x==9999)
		{
			printf("\n输入结束\n");
			break;
	    }
		if(EnQueue(Q,x))printf("\n成功入队\n");
		else{
			printf("\n队列已满\n");
			break;
		}
	}
	
	if(GetTop(Q,x))printf("\n队头元素为: %d\n",x);
	
	if(QueueEmpty(Q))printf("\n此队列为空\n");
	else printf("\n此队列不空\n");
	
	printf("\n依次出队:\n");
	while(DeQueue(Q,x))
	{
		printf("%d ",x);
	}
	printf("\n");
	
	return 0; 
}

二、队尾元素指向队尾指针的当前位置：
在针对队列的基本操作中，如何判空和判满？有以下三种办法
（1）牺牲掉一个存储空间：

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

//顺序队列的数据类型定义
#define ElemType int
#define MaxSize 15
typedef struct{
	ElemType data[MaxSize];
	int front,rear;
}SqQueue;

//初始化顺序队列Q：
void InitQueue(SqQueue &Q)
{
	Q.front=0;
	Q.rear=MaxSize-1;
}

//判空操作：
bool QueueEmpty(SqQueue Q)
{
	if((Q.rear+1)%MaxSize==Q.front)return true;
	else return false;
}

//入队操作：
bool EnQueue(SqQueue &Q,ElemType x)
{
	if((Q.rear+2)%MaxSize==Q.front)return false;
	Q.rear=(Q.rear+1)%MaxSize;
	Q.data[Q.rear]=x;
	printf("\n队头指针: %d 队尾指针: %d 此队列中目前有: %d个元素\n",Q.front,Q.rear,(Q.rear+1+MaxSize-Q.front)%MaxSize);	
	return true;
}

//出队操作： 
bool DeQueue(SqQueue &Q,ElemType &x)
{
	if((Q.rear+1)%MaxSize==Q.front)return false;
	printf("\n队头指针: %d 队尾指针: %d 此队列中目前有: %d个元素\n",Q.front,Q.rear,(Q.rear+1+MaxSize-Q.front)%MaxSize);	
    x=Q.data[Q.front];
    Q.front=(Q.front+1)%MaxSize;
	return true;
}

//获得队头元素的值：
bool GetTop(SqQueue Q,ElemType &x)
{
	if((Q.rear+1)%MaxSize==Q.front)return false;
    x=Q.data[Q.front];
    printf("\n队头指针: %d 队尾指针: %d 此队列中目前有: %d个元素\n",Q.front,Q.rear,(Q.rear+1+MaxSize-Q.front)%MaxSize);	
	return true;
}

//主函数 
int main()
{
	int x;
	SqQueue Q; //声明一个顺序队列Q
	InitQueue(Q); //初始化顺序队列Q 
	
	if(QueueEmpty(Q))printf("\n此队列为空\n");
	else printf("\n此队列不空\n");
	
	printf("\n向队列中输入元素:\n");
	while(1)
	{
		scanf("%d",&x);
		if(x==9999)
		{
			printf("\n输入结束\n");
			break;
	    }
		if(EnQueue(Q,x))printf("\n成功入队\n");
		else{
			printf("\n队列已满\n");
			break;
		}
	}
	
	if(GetTop(Q,x))printf("\n队头元素为: %d\n",x);
	
	if(QueueEmpty(Q))printf("\n此队列为空\n");
	else printf("\n此队列不空\n");
	
	printf("\n依次出队:\n");
	while(DeQueue(Q,x))
	{
		printf("%d ",x);
	}
	printf("\n");
	
	return 0; 
}

(2)在队列数据类型定义中设置变量size，用来保存当前队列内的元素个数，这个size随着入队和出队操作而发生变化：（这样就保证了每个存储空间都被利用）:

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

//顺序队列的数据类型定义
#define ElemType int
#define MaxSize 15
typedef struct{
	ElemType data[MaxSize];
	int front,rear;
	int size;
}SqQueue;

//初始化顺序队列Q：
void InitQueue(SqQueue &Q)
{
	Q.front=0;
	Q.rear=MaxSize-1;
	Q.size=0;
}

//判空操作：
bool QueueEmpty(SqQueue Q)
{
	if(Q.size==0)return true;
	else return false;
}

//入队操作：
bool EnQueue(SqQueue &Q,ElemType x)
{
	if(Q.size==MaxSize)return false;
	Q.rear=(Q.rear+1)%MaxSize;
	Q.data[Q.rear]=x;
	Q.size++;
	printf("\n队头指针: %d 队尾指针: %d 此队列中目前有: %d个元素\n",Q.front,Q.rear,Q.size);	
	return true;
}

//出队操作： 
bool DeQueue(SqQueue &Q,ElemType &x)
{
	if(Q.size==0)return false;
	printf("\n队头指针: %d 队尾指针: %d 此队列中目前有: %d个元素\n",Q.front,Q.rear,Q.size);
    x=Q.data[Q.front];
    Q.front=(Q.front+1)%MaxSize;
    Q.size--;
	return true;
}

//获得队头元素的值：
bool GetTop(SqQueue Q,ElemType &x)
{
	if(Q.size==0)return false;
    x=Q.data[Q.front];
    printf("\n队头指针: %d 队尾指针: %d 此队列中目前有: %d个元素\n",Q.front,Q.rear,Q.size);
	return true;
}

//主函数 
int main()
{
	int x;
	SqQueue Q; //声明一个顺序队列Q
	InitQueue(Q); //初始化顺序队列Q 
	
	if(QueueEmpty(Q))printf("\n此队列为空\n");
	else printf("\n此队列不空\n");
	
	printf("\n向队列中输入元素:\n");
	while(1)
	{
		scanf("%d",&x);
		if(x==9999)
		{
			printf("\n输入结束\n");
			break;
	    }
		if(EnQueue(Q,x))printf("\n成功入队\n");
		else{
			printf("\n队列已满\n");
			break;
		}
	}
	
	if(GetTop(Q,x))printf("\n队头元素为: %d\n",x);
	
	if(QueueEmpty(Q))printf("\n此队列为空\n");
	else printf("\n此队列不空\n");
	
	printf("\n依次出队:\n");
	while(DeQueue(Q,x))
	{
		printf("%d ",x);
	}
	printf("\n");
	
	return 0; 
}

(3)在队列的数据类型定义中增加一个成员tag，tag为0表示之前进行了删除操作，为1表示之前进行了插入操作，当队头指针和队尾指针相同时，如果tag=0表示队空，tag=1则表示队满：

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

//顺序队列的数据类型定义
#define ElemType int
#define MaxSize 15
typedef struct{
	ElemType data[MaxSize];
	int front,rear;
	int tag;
}SqQueue;

//统计当前队列中元素个数：
int QueueElemNumber(SqQueue &Q)
{
	if(Q.tag==1&&(Q.rear+1)%MaxSize==Q.front)return MaxSize;
	else return (Q.rear+1+MaxSize-Q.front)%MaxSize;
}

//初始化顺序队列Q：
void InitQueue(SqQueue &Q)
{
	Q.front=0;
	Q.rear=MaxSize-1;
	Q.tag=0;
}

//判空操作：
bool QueueEmpty(SqQueue Q)
{
	if((Q.rear+1)%MaxSize==Q.front&&Q.tag==0)return true;
	else return false;
}

//入队操作：
bool EnQueue(SqQueue &Q,ElemType x)
{
	if((Q.rear+1)%MaxSize==Q.front&&Q.tag==1)return false;
	Q.rear=(Q.rear+1)%MaxSize;
	Q.data[Q.rear]=x;
	Q.tag=1;
	printf("\n队头指针: %d 队尾指针: %d 此队列中目前有: %d个元素\n",Q.front,Q.rear,QueueElemNumber(Q));	
	return true;
}

//出队操作： 
bool DeQueue(SqQueue &Q,ElemType &x)
{
	if((Q.rear+1)%MaxSize==Q.front&&Q.tag==0)return false;
	printf("\n队头指针: %d 队尾指针: %d 此队列中目前有: %d个元素\n",Q.front,Q.rear,QueueElemNumber(Q));
    x=Q.data[Q.front];
    Q.front=(Q.front+1)%MaxSize;
    Q.tag=0;
	return true;
}

//获得队头元素的值：
bool GetTop(SqQueue Q,ElemType &x)
{
	if((Q.rear+1)%MaxSize==Q.front&&Q.tag==0)return false;
    x=Q.data[Q.front];
    printf("\n队头指针: %d 队尾指针: %d 此队列中目前有: %d个元素\n",Q.front,Q.rear,QueueElemNumber(Q));
	return true;
}

//主函数 
int main()
{
	int x;
	SqQueue Q; //声明一个顺序队列Q
	InitQueue(Q); //初始化顺序队列Q 
	
	if(QueueEmpty(Q))printf("\n此队列为空\n");
	else printf("\n此队列不空\n");
	
	printf("\n向队列中输入元素:\n");
	while(1)
	{
		scanf("%d",&x);
		if(x==9999)
		{
			printf("\n输入结束\n");
			break;
	    }
		if(EnQueue(Q,x))printf("\n成功入队\n");
		else{
			printf("\n队列已满\n");
			break;
		}
	}
	
	if(GetTop(Q,x))printf("\n队头元素为: %d\n",x);
	
	if(QueueEmpty(Q))printf("\n此队列为空\n");
	else printf("\n此队列不空\n");
	
	printf("\n依次出队:\n");
	while(DeQueue(Q,x))
	{
		printf("%d ",x);
	}
	printf("\n");
	
	return 0; 
}
非洲蜗牛
关注
  • 0
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
计算队列元素个数，以及分析队尾指针指向队尾和指向队尾下一个元素的不同操作
m0_58323186的博客
04-05 5495
计算队列的元素个数：(尾－头＋表长)%表长 队列头指针为front，队列尾指针为rear，队列容量为M，则元素个数为|rear-front+M|%M,注意，这个%是求余运算。 设f为队头，r为队尾，m为队长，a为元素个数，则1. f>r时，a=m+r-f; 2. f<=r时，a=r-f 正在上传…重新上传取消 拓展资料 为充分利用向量空间，克服"假溢出"现象的方法是：将向量空间想象为一个首尾相接的圆环，并称这种向量为循环向量。存储在其中的队列称为循环队列。这种循环队列可以以单链表的方式
【数据结构】顺序队列的原理及实现
互联网小阿祥
01-29 1208
顺序队列的原理及实现，代码编写验证
（队列篇）1、队列的概念及其基本操作（采用顺序存储结构，C++代码编写，包括初始化、入队、出队、获取当前队列长度等）
最新发布
颜安青的小世界
04-26 1086
此篇文章是采用顺序存储的方式实现队列，在内存中分配一块连续的存储单元存放队列中的元素（相当于创建一个数组而已），还要建立 front 和 rear 指针（虽说是指针，其实就是记住队头和队尾的位置，方便进行插入和删除），本文中 front 指向队头元素，rear 指向队尾元素的下一个位置。（其实如果出队了的话，数组前面其实还是有位置的，所以会造成假溢出，这可以用循环队列进行处理。若队列非空，则将队头元素赋值给x，记住不会改变队列，仅仅是读取而已。若队列非空，删除队头元素，并用x返回。大家一起学，一起进步！
顺序栈的基本操作实现
zhangwei8598的博客
03-27 749
顺序栈的基本操作
数据结构-顺序栈的基本操作（C语言实现）
祝星.的代码库
07-21 1万+
栈（Stack）是一种后进先出的线性表，限定这种类型的线性表为只能在某一端进行插入和删除操作。基于栈的特性，我们把它称作后进先出表（LastinFirstout）LIFO。常用术语栈顶（Top）线性表允许插入和删除的那一端。栈底不可操作的那一端。空栈不包含任何元素的空表。...
队列——顺序存储结构实现( 循环队列 - 不同指针指向)
一个很懒的人
07-29 5843
0.概述 本文首先以思维导图介绍队列的基本知识，其次给出循环队列（顺序存储结构）首尾不同指针指向不同位置时，队列的判空和判满条件，最后给出三种不同指针指向的循环队列代码实现！ 链式队列实现，请参考我的另一篇博客：: 队列——链式存储结构实现. 1.基本知识 2.不同指针指向，队列判空/判满条件 1. rear:指向队尾元素 front:指向队头元素前一个位置 （1）牺牲一个存储空间 （2）判空条件：front == rear （3）判满条件：(rear+1)%MaxSize == fron.
循环顺序队列各种基本操作的实现
05-07
循环顺序队列的实现，包含了各种基本操作，另外附有菜单功能，方便运行，不过好像只能运行整形变量
数据结构C++ 顺序栈、链栈、循环队列、链队列的主要操作（Word文档含代码和注释）
11-04
代码由C++程序设计语言编写，包含栈和队列的基本操作（栈：出、入、取、判空等|队列：出、入、取、打印队列、判空等），并展示了三个具体的使用例子，包括用栈求进制转换和用队列打印杨辉三角形，以及用栈计算后缀...
数据结构之栈和队列的代码实现（C语言）
12-30
这个资源主要是使用C语言实现的栈和队列两种数据结构基本操作，包含栈的入栈、出栈，队列的入队列、出队列的相关操作，具体包含如下几个： 1、顺序栈：入栈、出栈、获取栈顶元素、打印栈。 2、链栈：入栈、出栈、...
环型队列的基本操作 源代码
03-25
⑶编写环型队列的基本操作函数 ①进队操作，返回1为队满 EnQueue(int *queue,int maxn,int *head,int *tail,int x) ②出队操作，返回1为队空 DeQueue(int *queue,int maxn,int *head,int *tail,int *cp) ③输出...
数据结构之循环顺序队列
05-30
顺序循环队列，详细介绍见博客链接：http://blog.csdn.net/u013071074/article/details/27583741
顺序队列(循环队列)的常用操作(C语言)
10-19
C语言实现顺序队列（循环队列）的常用操作，包括初始化顺序队，创建顺序队，入队，出队，计算队的长度，清空队列等等
【C++】【数据结构】顺序栈的基本操作（初始化、入栈、出栈、取栈顶元素、遍历输出栈）的算法实现附全代码
是小雷同学的博客
04-14 1万+
使用c++完成数据结构顺序栈的基本操作，包括（初始化、入栈、出栈、取栈顶元素、遍历输出栈等），可直接编译运行。
C语言数据结构--队列 基本操作代码合集
m0_70744482的博客
04-06 558
三段代码分别是队列的顺序存储，带头结点的链式存储队列，不带头结点的链式存储队列。都包括着初始化、判空、入队 、创建、出队、遍历操作，三段代码都是键入9999即输入结束，方便大家调试。
（图解）循环队列的三种判断队空、队满操作（附带源码和插入删除操作等一些基本操作）
热门推荐
在夜里行走的博客
10-15 2万+
一万字图解循环队列附带测试程序的源码
循环队列中判断队满与队空
silverBlack
08-02 1万+
转载自：https://blog.csdn.net/u010429311/article/details/51043149 在引用循环队列前，我们需要了解队列是如何线性实现的（下图有错，x=sq[front++]）。   简单地讲，便是当队列为空时，front = rear = 0,每当插入元素尾指针+1，删除元素是头指针+1。但是，我们会发现一个问题，如上面的第四个图，0，1，2三个空间并没有...
队列
qq_43627111的博客
12-01 418
队列的逻辑结构 队列：只允许在一端进行插入操作，而另一端进行删除操作的线性表。 空队列：不含任何数据元素的队列。 允许插入（也称入队、进队）的一端称为队尾，允许删除（也称出队）的一端称为队头。 队列的操作特性：先进先出(FIFO,LILO) 队列的顺序存储结构及实现 队头指针和队尾指针： 队头指针指向队列中的第一个元素之前的元素，队尾指针指向队列中的最后一个元素 队头指针指向队列中的第一个元素，队...
关于数据结构（c语言）中，栈中顺序结构的大部分操作的代码实现
weixin_60700743的博客
10-05 496
栈在数据结构中的地位其实是线性表的具体延申，它的实质是受限制的线性表，而它受到限制的部分即在原有线性表的基础上增加了两个指针，分别栈底指针与栈顶指针，并规定栈底指针始终指向栈底结点不动，而栈顶指针始终指向顶部结点（或顶部结点的后一个结点），并随着结点的压栈出栈等操作而上下移动。这样一个受限制的线性表即被称为栈，而这样的限制方式也使得栈拥有了其特别之处，即先进后出(FILO)或后进先出(LIFO)，使得栈有了广泛的应用。因此，学好栈的基本操作的代码实现是必要的，而理解栈这一存储结构的重要思想更是必不可少的。
2019.12.13学习记录
qq_45336632的博客
12-15 220
一.队列 1.队列的概念 队列是一种特殊的线性结构，它只允许在队列的首部（head）进行删除操作，在称 为“出队”，而在队列的尾部（tail）进行插入操作，这称为“入队”。当队列中没有元素时 （即head==tail），称为空队列。 1）、限定在表的一端插入、另一端删除。 插入的那头就是队尾，删除的那头就是队 头。也就是说只能在线性表的表头删除元素，在表尾插入元素。形象的说就是水龙头 和水管，流水...
顺序队列各种基本操作代码实现，包括主函数
07-08
好的，以下是顺序队列的基本操作代码实现，包括主函数： ```c++ #include using namespace std; #define MAXSIZE 100 // 定义顺序队列的最大容量 typedef struct { int data[MAXSIZE]; // 存放队列元素 int ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值