数据结构5-队列

于 2022-07-07 10:43:33 发布
阅读量552 收藏
点赞数
分类专栏： 数据结构 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_54591377/article/details/125641547
版权

队列

队列(queue)是一种先进先出(First In First Out FIFO)的线性表。在表一端(表尾)插入，在另一端(表头)删除
在这里插入图片描述
相关术语：

  • 队列（Queue)是仅在表尾进行插入操作，在表头进行删除操作的线性表。
  • 表尾即an端，称为队尾；
  • 表头即a1端，称为队头。
  • 它是一种先进先出（FIFO)的线性表。
    例如：队列Q=(a1,a2,a3,……，an-1,an)
  • 插入元素称为人队；删除元素称为出队。
  • 队列的存储结构为链队或顺序队（常用循环顺序队）

队列的总结：

1.定义：只能在表的一端进行插入运算在表的另一端进行删除操作运算的线性表(头删尾插)

2.逻辑结构：同线性表一样栈元素具有线性关系即前驱后继关系(一对一)

3.存储结构：顺序队和链队均可，循环顺序队更常见

4.运算规则：只能在队首和队尾运算，且访问结点时依照后进先出的原则(FIFO)

5.实现方式：关键是掌握入队和出队操作具体实现依顺序队和链队的不同而不同

栈和队列的区别：栈是吃进去的东西吐出来(嘴【栈顶】)队列是吃进去的东西拉出来（队首和队尾）

队列的基本操作：

  1. 队QQ的初始化操作。
    void InitQueue(QQ);
  2. 销毁队列SS。
    void DestroyQueue(QQ);
  3. 清空队列。
    void Clear(QQ);
  4. 元素入队，返回值：0-失败；1-成功。
    int InQueue(QQ ee);
  5. 元素出队，返回值：0-失败；1-成功。
    int OutQueue(QQ ee);
  6. 判断队列是否为空，返回值：1-空，0-非空或失败。
    int IsEmpty(QQ);
  7. 判断队列是否已满，返回值：1-已满，0-未满或失败。
    int IsFull(QQ);
  8. 求队列的长度，返回队列QQ元素的个数。
    int Length(QQ);
  9. 获取队头元素，返回值：0-失败；1-成功。
    int GetHead(QQee);

队列的顺序存储

顺序存储为了最大化使用空间采用循环队列。
循环队列
方案一：
在这里插入图片描述

/*
 * 程序名：seqqueue3.c，此程序演示循环队列的数组实现，队尾指针指向队尾元素，没有length的辅助变量。
*/
#include <stdio.h>
#include <string.h>

#define MAXSIZE 10       // 循环队列的最大长度，最多可以存放MAXSIZE-1个元素。

typedef int ElemType;    // 自定义循环队列的数据元素为整数。

typedef struct
{
  ElemType data[MAXSIZE];   // 用数组存储循环队列中的元素。
  int front;                // 队列的头指针。
  int rear;                 // 队列的尾指针，指向队尾元素。
}SeqQueue,*PSeqQueue;

// 循环队列QQ的初始化操作。
void InitQueue(PSeqQueue QQ);                     

// 销毁循环队列QQ。
void DestroyQueue(PSeqQueue QQ);

// 元素入队，返回值：0-失败；1-成功。
int InQueue(PSeqQueue QQ, ElemType *ee);

// 元素出队，返回值：0-失败；1-成功。
int OutQueue(PSeqQueue QQ, ElemType *ee);

// 求循环队列的长度，返回值：>=0-队列QQ元素的个数。
int  Length(PSeqQueue QQ);                   

// 清空循环队列。
void Clear(PSeqQueue QQ);                    

// 判断循环队列是否为空，返回值：1-空，0-非空或失败。
int  IsEmpty(PSeqQueue QQ);                    

// 判断循环队列是否已满，返回值：1-已满，0-未满或失败。
int IsFull(PSeqQueue QQ);

// 打印循环队列中全部的元素。
void PrintQueue(PSeqQueue QQ);                    

// 获取队头元素，返回值：0-失败；1-成功。
// 只查看队头元素的值，元素不出队。
int GetHead(PSeqQueue QQ, ElemType *ee);

int main()
{
  SeqQueue QQ;     // 创建循环队列。

  InitQueue(&QQ);  // 初始化循环队列。

  ElemType ee;     // 创建一个数据元素。

  printf("元素（1、2、3、4、5、6、7、8、9、10、11）入队。\n");
  ee=1;  InQueue(&QQ, &ee);
  ee=2;  InQueue(&QQ, &ee);
  ee=3;  InQueue(&QQ, &ee);
  ee=4;  InQueue(&QQ, &ee);
  ee=5;  InQueue(&QQ, &ee);
  ee=6;  InQueue(&QQ, &ee);
  ee=7;  InQueue(&QQ, &ee);
  ee=8;  InQueue(&QQ, &ee);
  ee=9;  InQueue(&QQ, &ee);
  ee=10; InQueue(&QQ, &ee);
  ee=11; InQueue(&QQ, &ee);

  printf("队列的长度是%d\n",Length(&QQ));
  PrintQueue(&QQ);

  if (OutQueue(&QQ,&ee)==1)  printf("出队的元素值为%d\n",ee);
  if (OutQueue(&QQ,&ee)==1)  printf("出队的元素值为%d\n",ee);
  if (OutQueue(&QQ,&ee)==1)  printf("出队的元素值为%d\n",ee);
  if (OutQueue(&QQ,&ee)==1)  printf("出队的元素值为%d\n",ee);
  if (OutQueue(&QQ,&ee)==1)  printf("出队的元素值为%d\n",ee);
  if (OutQueue(&QQ,&ee)==1)  printf("出队的元素值为%d\n",ee);
  if (OutQueue(&QQ,&ee)==1)  printf("出队的元素值为%d\n",ee);

  printf("队列的长度是%d\n",Length(&QQ));
  PrintQueue(&QQ);

  printf("元素（11、12、13、14、15）入队。\n");
  ee=11;  InQueue(&QQ, &ee);
  ee=12;  InQueue(&QQ, &ee);
  ee=13;  InQueue(&QQ, &ee);
  ee=14;  InQueue(&QQ, &ee);
  ee=15;  InQueue(&QQ, &ee);

  printf("队列的长度是%d\n",Length(&QQ));

  PrintQueue(&QQ);

  // 只查看队头元素的值，元素不出队。
  if (GetHead(&QQ,&ee)==1)  printf("队头的元素值为%d\n",ee);

  return 0;
}

// 初始化循环队列
void InitQueue(PSeqQueue QQ)
{
  Clear(QQ); // 清空循环队列。
}

// 清空循环队列。
void Clear(PSeqQueue QQ)
{
  if (QQ == NULL) return;   // 检查空指针。

  QQ->front=0;
  QQ->rear=MAXSIZE-1;    // xxxx
  memset(QQ->data,0,sizeof(ElemType)*MAXSIZE);  // 数组元素清零。
}

// 求循环队列的长度，返回值：>=0-队列QQ元素的个数。
int Length(PSeqQueue QQ)
{
  if (QQ == NULL) return 0;  // 检查空指针。

  // xxxxxxx
  return (QQ->rear-QQ->front+1+MAXSIZE)%MAXSIZE;
}

// 销毁循环队列QQ。
void DestroyQueue(PSeqQueue QQ)
{
  // 静态循环队列无需释放内存，不需要销毁操作。

  Clear(QQ); // 清空循环队列。

  return;
}

// 判断循环队列是否为空，返回值：1-空，0-非空或失败。
int IsEmpty(PSeqQueue QQ)
{
  if (QQ == NULL) return 0;   // 检查空指针。

  // xxxxx
  if ( ((QQ->rear+1)%MAXSIZE) == QQ->front ) return 1;

  return 0;
}

// 判断循环队列是否已满，返回值：1-已满，0-未满或失败。
int IsFull(PSeqQueue QQ)
{
  if (QQ == NULL) return 0;   // 检查空指针。

  // xxxxx
  if ( ((QQ->rear+2)%MAXSIZE) == QQ->front ) return 1;

  return 0;
}

// 元素入队，返回值：0-失败；1-成功。
int InQueue(PSeqQueue QQ, ElemType *ee)
{
  if ( (QQ == NULL) || (ee == NULL) ) return 0;   // 检查空指针。

  if (IsFull(QQ) == 1)
  {
    printf("循环队列已满，不能插入。\n"); return 0;
  }

  // xxxx 先移动队尾指针，然后再插入数据。
  QQ->rear=(QQ->rear+1)%MAXSIZE;  // 队尾指针后移。

  memcpy(&QQ->data[QQ->rear],ee,sizeof(ElemType));  // 用数组的下标访问。
  // memcpy(QQ->data+QQ->rear,ee,sizeof(ElemType));    // 采用指针运算也可以。

  return 1;
}

// 打印循环队列中全部的元素。
void PrintQueue(PSeqQueue QQ)
{
  if (QQ == NULL) return;   // 检查空指针。

  if (IsEmpty(QQ) == 1) { printf("队列为空。\n"); return; }

  int kk,qlen=Length(QQ);
  for (kk = 0; kk < qlen; kk++)
  {
    // 用数组的下标访问。
    printf("data[%d],value=%d\n",(QQ->front+kk)%MAXSIZE,QQ->data[(QQ->front+kk)%MAXSIZE]);     
   
    // 采用指针运算也可以。
    // printf("data[%d],value=%d\n",(QQ->front+kk)%MAXSIZE,*(QQ->data+(QQ->front+kk)%MAXSIZE));
  }
}

// 元素出队，返回值：0-失败；1-成功。
int OutQueue(PSeqQueue QQ, ElemType *ee)
{
  if ( (QQ == NULL) || (ee == NULL) ) return 0;   // 检查空指针。

  if (IsEmpty(QQ) == 1) { printf("队列为空。\n"); return 0; }

  memcpy(ee,&QQ->data[QQ->front],sizeof(ElemType));  // 用数组的下标访问。
  // memcpy(ee,QQ->data+QQ->front,sizeof(ElemType));    // 采用指针运算也可以。

  QQ->front=(QQ->front+1)%MAXSIZE;  // 队列头指针后移。

  return 1;
}

// 获取队头元素，返回值：0-失败；1-成功。
// 只查看队头元素的值，元素不出队。
int GetHead(PSeqQueue QQ, ElemType *ee)
{
  if ( (QQ == NULL) || (ee == NULL) ) return 0;   // 检查空指针。

  if (IsEmpty(QQ) == 1) { printf("队列为空。\n"); return 0; }

  memcpy(ee,&QQ->data[QQ->front],sizeof(ElemType));  // 用数组的下标访问。
  // memcpy(ee,QQ->data+QQ->front,sizeof(ElemType));    // 采用指针运算也可以。

  return 1;
}

方案二：
在这里插入图片描述

/*
 * 程序名：seqqueue1.c，此程序演示循环队列的数组实现，队尾指针指向队尾的下一个元素，没有length的辅助变量。
*/
#include <stdio.h>
#include <string.h>

#define MAXSIZE 10       // 循环队列的最大长度，最多可以存放MAXSIZE-1个元素。

typedef int ElemType;    // 自定义循环队列的数据元素为整数。

typedef struct
{
  ElemType data[MAXSIZE];   // 用数组存储循环队列中的元素。
  int front;                // 队列的头指针。
  int rear;                 // 队列的尾指针，指向队尾的下一个元素。
}SeqQueue,*PSeqQueue;

// 循环队列QQ的初始化操作。
void InitQueue(PSeqQueue QQ);                     

// 销毁循环队列QQ。
void DestroyQueue(PSeqQueue QQ);

// 元素入队，返回值：0-失败；1-成功。
int InQueue(PSeqQueue QQ, ElemType *ee);

// 元素出队，返回值：0-失败；1-成功。
int OutQueue(PSeqQueue QQ, ElemType *ee);

// 求循环队列的长度，返回值：>=0-队列QQ元素的个数。
int  Length(PSeqQueue QQ);                   

// 清空循环队列。
void Clear(PSeqQueue QQ);                    

// 判断循环队列是否为空，返回值：1-空，0-非空或失败。
int  IsEmpty(PSeqQueue QQ);                    

// 判断循环队列是否已满，返回值：1-已满，0-未满或失败。
int IsFull(PSeqQueue QQ);

// 打印循环队列中全部的元素。
void PrintQueue(PSeqQueue QQ);                    

// 获取队头元素，返回值：0-失败；1-成功。
// 只查看队头元素的值，元素不出队。
int GetHead(PSeqQueue QQ, ElemType *ee);

int main()
{
  SeqQueue QQ;     // 创建循环队列。

  InitQueue(&QQ);  // 初始化循环队列。

  ElemType ee;     // 创建一个数据元素。

  printf("元素（1、2、3、4、5、6、7、8、9、10、11）入队。\n");
  ee=1;  InQueue(&QQ, &ee);
  ee=2;  InQueue(&QQ, &ee);
  ee=3;  InQueue(&QQ, &ee);
  ee=4;  InQueue(&QQ, &ee);
  ee=5;  InQueue(&QQ, &ee);
  ee=6;  InQueue(&QQ, &ee);
  ee=7;  InQueue(&QQ, &ee);
  ee=8;  InQueue(&QQ, &ee);
  ee=9;  InQueue(&QQ, &ee);
  ee=10; InQueue(&QQ, &ee);
  ee=11; InQueue(&QQ, &ee);

  printf("队列的长度是%d\n",Length(&QQ));
  PrintQueue(&QQ);

  if (OutQueue(&QQ,&ee)==1)  printf("出队的元素值为%d\n",ee);
  if (OutQueue(&QQ,&ee)==1)  printf("出队的元素值为%d\n",ee);
  if (OutQueue(&QQ,&ee)==1)  printf("出队的元素值为%d\n",ee);
  if (OutQueue(&QQ,&ee)==1)  printf("出队的元素值为%d\n",ee);
  if (OutQueue(&QQ,&ee)==1)  printf("出队的元素值为%d\n",ee);
  if (OutQueue(&QQ,&ee)==1)  printf("出队的元素值为%d\n",ee);
  if (OutQueue(&QQ,&ee)==1)  printf("出队的元素值为%d\n",ee);

  printf("队列的长度是%d\n",Length(&QQ));
  PrintQueue(&QQ);

  printf("元素（11、12、13、14、15）入队。\n");
  ee=11;  InQueue(&QQ, &ee);
  ee=12;  InQueue(&QQ, &ee);
  ee=13;  InQueue(&QQ, &ee);
  ee=14;  InQueue(&QQ, &ee);
  ee=15;  InQueue(&QQ, &ee);

  printf("队列的长度是%d\n",Length(&QQ));

  PrintQueue(&QQ);

  // 只查看队头元素的值，元素不出队。
  if (GetHead(&QQ,&ee)==1)  printf("队头的元素值为%d\n",ee);

  return 0;
}

// 初始化循环队列
void InitQueue(PSeqQueue QQ)
{
  Clear(QQ); // 清空循环队列。
}

// 清空循环队列。
void Clear(PSeqQueue QQ)
{
  if (QQ == NULL) return;  // 检查空指针。

  QQ->front=QQ->rear=0;
  memset(QQ->data,0,sizeof(ElemType)*MAXSIZE);  // 数组元素清零。
}

// 求循环队列的长度，返回值：>=0-队列QQ元素的个数。
int Length(PSeqQueue QQ)
{
  if (QQ == NULL) return 0;  // 检查空指针。

  return (QQ->rear-QQ->front+MAXSIZE)%MAXSIZE;
}

// 销毁循环队列QQ。
void DestroyQueue(PSeqQueue QQ)
{
  // 静态循环队列无需释放内存，不需要销毁操作。

  Clear(QQ); // 清空循环队列。

  return;
}

// 判断循环队列是否为空，返回值：1-空，0-非空或失败。
int IsEmpty(PSeqQueue QQ)
{
  if (QQ == NULL) return 0;    // 检查空指针。

  if (QQ->front == QQ->rear) return 1;

  return 0;
}

// 判断循环队列是否已满，返回值：1-已满，0-未满或失败。
int IsFull(PSeqQueue QQ)
{
  if (QQ == NULL) return 0;   // 检查空指针。

  if ( ((QQ->rear+1)%MAXSIZE) == QQ->front) return 1;

  return 0;
}

// 元素入队，返回值：0-失败；1-成功。
int InQueue(PSeqQueue QQ, ElemType *ee)
{
  if ( (QQ == NULL) || (ee == NULL) ) return 0;   // 检查空指针。

  if (IsFull(QQ) == 1)
  {
    printf("循环队列已满，不能插入。\n"); return 0;
  }

  memcpy(&QQ->data[QQ->rear],ee,sizeof(ElemType));  // 用数组的下标访问。
  // memcpy(QQ->data+QQ->rear,ee,sizeof(ElemType));    // 采用指针运算也可以。

  QQ->rear=(QQ->rear+1)%MAXSIZE;  // 队尾指针后移。

  return 1;
}

// 打印循环队列中全部的元素。
void PrintQueue(PSeqQueue QQ)
{
  if (QQ == NULL) return;   // 检查空指针。

  if (IsEmpty(QQ) == 1) { printf("队列为空。\n"); return; }

  int kk,qlen=Length(QQ);
  for (kk = 0; kk < qlen; kk++)
  {
    // 用数组的下标访问。
    printf("data[%d],value=%d\n",(QQ->front+kk)%MAXSIZE,QQ->data[(QQ->front+kk)%MAXSIZE]);     
   
    // 采用指针运算也可以。
    // printf("data[%d],value=%d\n",(QQ->front+kk)%MAXSIZE,*(QQ->data+(QQ->front+kk)%MAXSIZE));
  }
}

// 元素出队，返回值：0-失败；1-成功。
int OutQueue(PSeqQueue QQ, ElemType *ee)
{
  if ( (QQ == NULL) || (ee == NULL) ) return 0;   // 检查空指针。

  if (IsEmpty(QQ) == 1) { printf("队列为空。\n"); return 0; }

  memcpy(ee,&QQ->data[QQ->front],sizeof(ElemType));  // 用数组的下标访问。
  // memcpy(ee,QQ->data+QQ->front,sizeof(ElemType));    // 采用指针运算也可以。

  QQ->front=(QQ->front+1)%MAXSIZE;  // 队列头指针后移。

  return 1;
}

// 获取队头元素，返回值：0-失败；1-成功。
// 只查看队头元素的值，元素不出队。
int GetHead(PSeqQueue QQ, ElemType *ee)
{
  if ( (QQ == NULL) || (ee == NULL) ) return 0;   // 检查空指针。

  if (IsEmpty(QQ) == 1) { printf("队列为空。\n"); return 0; }

  memcpy(ee,&QQ->data[QQ->front],sizeof(ElemType));  // 用数组的下标访问。
  // memcpy(ee,QQ->data+QQ->front,sizeof(ElemType));    // 采用指针运算也可以。

  return 1;
}

方案三：
在这里插入图片描述

//SeqQueue.h
#pragma once
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

//函数结果状态代码 
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define MAXSIZE 10
//Status 是函数的类型，其值是函数结果状态代码
typedef int Status;
// 循环队列的最大长度，最多可以存放MAXSIZE个元素。

typedef int ElemType;    // 自定义循环队列的数据元素为整数。

typedef struct
{
	ElemType data[MAXSIZE];   // 用数组存储循环队列中的元素。
	int front;                // 队列的头指针。
	int rear;                 // 队列的尾指针，指向队尾的下一个元素。
	int length;               // 队列的实际长度。    // xxx
}SeqQueue, *PSeqQueue;

// 循环队列QQ的初始化操作。
void InitQueue(PSeqQueue QQ);

// 销毁循环队列QQ。
void DestroyQueue(PSeqQueue QQ);

// 元素入队，返回值：0-失败；1-成功。
int InQueue(PSeqQueue QQ, ElemType *ee);

// 元素出队，返回值：0-失败；1-成功。
int OutQueue(PSeqQueue QQ, ElemType *ee);

// 求循环队列的长度，返回值：>=0-队列QQ元素的个数。
int  Length(PSeqQueue QQ);

// 清空循环队列。
void Clear(PSeqQueue QQ);

// 判断循环队列是否为空，返回值：1-空，0-非空或失败。
int  IsEmpty(PSeqQueue QQ);

// 判断循环队列是否已满，返回值：1-已满，0-未满或失败。
int IsFull(PSeqQueue QQ);

// 打印循环队列中全部的元素。
void PrintQueue(PSeqQueue QQ);

// 获取队头元素，返回值：0-失败；1-成功。
// 只查看队头元素的值，元素不出队。
int GetHead(PSeqQueue QQ, ElemType *ee);

  


//SeqQueue.cpp
#include "SeqQueue.h"
//循环队列的数组实现，队尾指针指向队尾的下一个元素，增加了length的辅助变量。
// 循环队列QQ的初始化操作。
void InitQueue(PSeqQueue QQ)
{
	if (QQ == NULL )
	{
		return ;
	}

		QQ->front = QQ->rear = QQ->length = 0;
		memset(QQ->data, 0, sizeof(ElemType)*MAXSIZE);  // 数组元素清零。
}

// 销毁循环队列QQ。
void DestroyQueue(PSeqQueue QQ)
{
	if (QQ)
	{
		QQ->front = QQ->rear = QQ->length = 0;
		memset(QQ->data, 0, sizeof(ElemType)*MAXSIZE);  // 数组元素清零。
		delete QQ;
	}
	return;
}

// 元素入队，返回值：0-失败；1-成功。
int InQueue(PSeqQueue QQ, ElemType *ee)
{
	if (QQ==NULL ||  ee == NULL )
	{
		return ERROR;
	}
	if (IsFull(QQ))
	{
		printf("循环队列已满，不能插入。\n"); return 0;
	}
	memcpy(&QQ->data[QQ->rear], ee, sizeof(ElemType));  // 用数组的下标访问。
	QQ->rear = (QQ->rear + 1) % MAXSIZE;
	QQ->length++;
	return OK;
}

// 元素出队，返回值：0-失败；1-成功。
int OutQueue(PSeqQueue QQ, ElemType *ee)
{
	if (QQ == NULL || ee == NULL)
	{
		return ERROR;
	}
	//memset(ee,&QQ->data[QQ->front], sizeof(ElemType));
	memcpy(ee, &QQ->data[QQ->front], sizeof(ElemType));  // 用数组的下标访问。
	QQ->front = (QQ->front + 1) % MAXSIZE;
	QQ->length--;
	return OK;
}

// 求循环队列的长度，返回值：>=0-队列QQ元素的个数。
int  Length(PSeqQueue QQ)
{
	if (QQ == NULL )return ERROR;
	return QQ->length;
}

// 清空循环队列。
void Clear(PSeqQueue QQ)
{
	if (QQ == NULL)return;
	QQ->front = QQ->rear = QQ->length = 0;
	memset(QQ->data, 0, sizeof(ElemType)*MAXSIZE);  // 数组元素清零。
}

// 判断循环队列是否为空，返回值：1-空，0-非空或失败。
int  IsEmpty(PSeqQueue QQ)
{
	if (QQ == NULL) return ERROR;
	if (QQ->length == 0)
	{
		return OK;
	}
	else
	{
		return 0;
	}
}

// 判断循环队列是否已满，返回值：1-已满，0-未满或失败。
int IsFull(PSeqQueue QQ)
{
	if (QQ == NULL) return ERROR;
	if (QQ->length < MAXSIZE)
	{
		return 0;
	}
	else
	{
		return OK;
	}
}

// 打印循环队列中全部的元素。
void PrintQueue(PSeqQueue QQ)
{
	if (QQ == NULL) return ;
	if (IsEmpty(QQ) == 1) { printf("队列为空。\n"); return; }
	for (int i = 0; i < QQ->length ; i++)
	{
		//printf("data[%d],value=%d\n", i, QQ->data[(QQ->front+i )% MAXSIZE]);
		// 用数组的下标访问。
		printf("data[%d],value=%d\n", /*(QQ->front + i) % MAXSIZE*/i, QQ->data[(QQ->front + i) % MAXSIZE]);
		//printf("data[%d],value=%d\n",(QQ->front+i)%MAXSIZE,QQ->data[(QQ->front+i)%MAXSIZE]);   
	}
}

// 获取队头元素，返回值：0-失败；1-成功。
// 只查看队头元素的值，元素不出队。
int GetHead(PSeqQueue QQ, ElemType *ee)
{
	if (QQ == NULL || ee == NULL) return ERROR;
	memcpy(ee, &QQ->data[QQ->front], sizeof ElemType);
	return OK;
}

void test01()
{
	SeqQueue QQ;     // 创建循环队列。

	InitQueue(&QQ);  // 初始化循环队列。

	ElemType ee;     // 创建一个数据元素。
	  
	printf("元素（1、2、3、4、5、6、7、8、9、10、11）入队。\n");
	ee = 1;  InQueue(&QQ, &ee);
	ee = 2;  InQueue(&QQ, &ee);
	ee = 3;  InQueue(&QQ, &ee);
	ee = 4;  InQueue(&QQ, &ee);
	ee = 5;  InQueue(&QQ, &ee);
	ee = 6;  InQueue(&QQ, &ee);
	ee = 7;  InQueue(&QQ, &ee);
	ee = 8;  InQueue(&QQ, &ee);
	ee = 9;  InQueue(&QQ, &ee);
	ee = 10; InQueue(&QQ, &ee);
	ee = 11; InQueue(&QQ, &ee);

	printf("队列的长度是%d\n", Length(&QQ));
	PrintQueue(&QQ);

	if (OutQueue(&QQ, &ee) == 1)  printf("出队的元素值为%d\n", ee);
	if (OutQueue(&QQ, &ee) == 1)  printf("出队的元素值为%d\n", ee);
	if (OutQueue(&QQ, &ee) == 1)  printf("出队的元素值为%d\n", ee);
	if (OutQueue(&QQ, &ee) == 1)  printf("出队的元素值为%d\n", ee);
	if (OutQueue(&QQ, &ee) == 1)  printf("出队的元素值为%d\n", ee);
	if (OutQueue(&QQ, &ee) == 1)  printf("出队的元素值为%d\n", ee);
	if (OutQueue(&QQ, &ee) == 1)  printf("出队的元素值为%d\n", ee);

	printf("队列的长度是%d\n", Length(&QQ));
	PrintQueue(&QQ);

	printf("元素（11、12、13、14、15）入队。\n");
	ee = 11;  InQueue(&QQ, &ee);
	ee = 12;  InQueue(&QQ, &ee);
	ee = 13;  InQueue(&QQ, &ee);
	ee = 14;  InQueue(&QQ, &ee);
	ee = 15;  InQueue(&QQ, &ee);

	printf("队列的长度是%d\n", Length(&QQ));

	PrintQueue(&QQ);

	// 只查看队头元素的值，元素不出队。
	if (GetHead(&QQ, &ee) == 1)  printf("队头的元素值为%d\n", ee);

}
int main()
{
	test01();//test
	system("pause");
	return EXIT_SUCCESS;	
}

方案四：
尾指针指向队尾元素，增加length变量。

/*
 * 程序名：seqqueue4.c，此程序演示循环队列的数组实现，队尾指针指向队尾元素，增加了length的辅助变量。
*/
#include <stdio.h>
#include <string.h>

#define MAXSIZE 10       // 循环队列的最大长度，最多可以存放MAXSIZE个元素。

typedef int ElemType;    // 自定义循环队列的数据元素为整数。

typedef struct
{
  ElemType data[MAXSIZE];   // 用数组存储循环队列中的元素。
  int front;                // 队列的头指针。
  int rear;                 // 队列的尾指针，指向队尾元素。
  int length;               // 队列的实际长度。    // xxx
}SeqQueue,*PSeqQueue;

// 循环队列QQ的初始化操作。
void InitQueue(PSeqQueue QQ);                     

// 销毁循环队列QQ。
void DestroyQueue(PSeqQueue QQ);

// 元素入队，返回值：0-失败；1-成功。
int InQueue(PSeqQueue QQ, ElemType *ee);

// 元素出队，返回值：0-失败；1-成功。
int OutQueue(PSeqQueue QQ, ElemType *ee);

// 求循环队列的长度，返回值：>=0-队列QQ元素的个数。
int  Length(PSeqQueue QQ);                   

// 清空循环队列。
void Clear(PSeqQueue QQ);                    

// 判断循环队列是否为空，返回值：1-空，0-非空或失败。
int  IsEmpty(PSeqQueue QQ);                    

// 判断循环队列是否已满，返回值：1-已满，0-未满或失败。
int IsFull(PSeqQueue QQ);

// 打印循环队列中全部的元素。
void PrintQueue(PSeqQueue QQ);                    

// 获取队头元素，返回值：0-失败；1-成功。
// 只查看队头元素的值，元素不出队。
int GetHead(PSeqQueue QQ, ElemType *ee);

int main()
{
  SeqQueue QQ;     // 创建循环队列。

  InitQueue(&QQ);  // 初始化循环队列。

  ElemType ee;     // 创建一个数据元素。

  printf("元素（1、2、3、4、5、6、7、8、9、10、11）入队。\n");
  ee=1;  InQueue(&QQ, &ee);
  ee=2;  InQueue(&QQ, &ee);
  ee=3;  InQueue(&QQ, &ee);
  ee=4;  InQueue(&QQ, &ee);
  ee=5;  InQueue(&QQ, &ee);
  ee=6;  InQueue(&QQ, &ee);
  ee=7;  InQueue(&QQ, &ee);
  ee=8;  InQueue(&QQ, &ee);
  ee=9;  InQueue(&QQ, &ee);
  ee=10; InQueue(&QQ, &ee);
  ee=11; InQueue(&QQ, &ee);

  printf("队列的长度是%d\n",Length(&QQ));
  PrintQueue(&QQ);

  if (OutQueue(&QQ,&ee)==1)  printf("出队的元素值为%d\n",ee);
  if (OutQueue(&QQ,&ee)==1)  printf("出队的元素值为%d\n",ee);
  if (OutQueue(&QQ,&ee)==1)  printf("出队的元素值为%d\n",ee);
  if (OutQueue(&QQ,&ee)==1)  printf("出队的元素值为%d\n",ee);
  if (OutQueue(&QQ,&ee)==1)  printf("出队的元素值为%d\n",ee);
  if (OutQueue(&QQ,&ee)==1)  printf("出队的元素值为%d\n",ee);
  if (OutQueue(&QQ,&ee)==1)  printf("出队的元素值为%d\n",ee);

  printf("队列的长度是%d\n",Length(&QQ));
  PrintQueue(&QQ);

  printf("元素（11、12、13、14、15）入队。\n");
  ee=11;  InQueue(&QQ, &ee);
  ee=12;  InQueue(&QQ, &ee);
  ee=13;  InQueue(&QQ, &ee);
  ee=14;  InQueue(&QQ, &ee);
  ee=15;  InQueue(&QQ, &ee);

  printf("队列的长度是%d\n",Length(&QQ));

  PrintQueue(&QQ);

  // 只查看队头元素的值，元素不出队。
  if (GetHead(&QQ,&ee)==1)  printf("队头的元素值为%d\n",ee);

  return 0;
}

// 初始化循环队列
void InitQueue(PSeqQueue QQ)
{
  Clear(QQ); // 清空循环队列。
}

// 清空循环队列。
void Clear(PSeqQueue QQ)
{
  if (QQ == NULL) return;  // 检查空指针。

  QQ->front=0;
  QQ->rear=MAXSIZE-1;    // xxxx
  QQ->length=0;
  memset(QQ->data,0,sizeof(ElemType)*MAXSIZE);  // 数组元素清零。
}

// 求循环队列的长度，返回值：>=0-队列QQ元素的个数。
int Length(PSeqQueue QQ)
{
  if (QQ == NULL) return 0;  // 检查空指针。

  return QQ->length;    // xxx
}

// 销毁循环队列QQ。
void DestroyQueue(PSeqQueue QQ)
{
  // 静态循环队列无需释放内存，不需要销毁操作。

  Clear(QQ); // 清空循环队列。

  return;
}

// 判断循环队列是否为空，返回值：1-空，0-非空或失败。
int IsEmpty(PSeqQueue QQ)
{
  if (QQ == NULL) return 0;   // 检查空指针。

  // if (QQ->front == QQ->rear) return 1;  

  if (QQ->length == 0) return 1;    // xxx

  return 0;
}

// 判断循环队列是否已满，返回值：1-已满，0-未满或失败。
int IsFull(PSeqQueue QQ)
{
  if (QQ == NULL) return 0;   // 检查空指针。

  // if ( ((QQ->rear+1)%MAXSIZE) == QQ->front) return 1;
  if (QQ->length == MAXSIZE) return 1;    // xxx

  return 0;
}

// 元素入队，返回值：0-失败；1-成功。
int InQueue(PSeqQueue QQ, ElemType *ee)
{
  if ( (QQ == NULL) || (ee == NULL) ) return 0;   // 检查空指针。

  if (IsFull(QQ) == 1)
  {
    printf("循环队列已满，不能插入。\n"); return 0;
  }

  // xxxx 先移动队尾指针，然后再插入数据。
  QQ->rear=(QQ->rear+1)%MAXSIZE;  // 队尾指针后移。

  memcpy(&QQ->data[QQ->rear],ee,sizeof(ElemType));  // 用数组的下标访问。
  // memcpy(QQ->data+QQ->rear,ee,sizeof(ElemType));    // 采用指针运算也可以。

  QQ->length++;    // xxx

  return 1;
}

// 打印循环队列中全部的元素。
void PrintQueue(PSeqQueue QQ)
{
  if (QQ == NULL) return;   // 检查空指针。

  if (IsEmpty(QQ) == 1) { printf("队列为空。\n"); return; }

  int kk,qlen=Length(QQ);
  for (kk = 0; kk < qlen; kk++)
  {
    // 用数组的下标访问。
    printf("data[%d],value=%d\n",(QQ->front+kk)%MAXSIZE,QQ->data[(QQ->front+kk)%MAXSIZE]);     
   
    // 采用指针运算也可以。
    // printf("data[%d],value=%d\n",(QQ->front+kk)%MAXSIZE,*(QQ->data+(QQ->front+kk)%MAXSIZE));
  }
}

// 元素出队，返回值：0-失败；1-成功。
int OutQueue(PSeqQueue QQ, ElemType *ee)
{
  if ( (QQ == NULL) || (ee == NULL) ) return 0;   // 检查空指针。

  if (IsEmpty(QQ) == 1) { printf("队列为空。\n"); return 0; }

  memcpy(ee,&QQ->data[QQ->front],sizeof(ElemType));  // 用数组的下标访问。
  // memcpy(ee,QQ->data+QQ->front,sizeof(ElemType));    // 采用指针运算也可以。

  QQ->front=(QQ->front+1)%MAXSIZE;  // 队列头指针后移。

  QQ->length--;    // xxx

  return 1;
}

// 获取队头元素，返回值：0-失败；1-成功。
// 只查看队头元素的值，元素不出队。
int GetHead(PSeqQueue QQ, ElemType *ee)
{
  if ( (QQ == NULL) || (ee == NULL) ) return 0;   // 检查空指针。

  if (IsEmpty(QQ) == 1) { printf("队列为空。\n"); return 0; }

  memcpy(ee,&QQ->data[QQ->front],sizeof(ElemType));  // 用数组的下标访问。
  // memcpy(ee,QQ->data+QQ->front,sizeof(ElemType));    // 采用指针运算也可以。

  return 1;
}

队列的链式存储

只讨论带头节点的链式存储队列
在这里插入图片描述

只能采用链尾入队，链头出队。
双端队列，不常用
在这里插入图片描述

//Linkqueue.h
#pragma once
#pragma once
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

//函数结果状态代码 
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
//Status 是函数的类型，其值是函数结果状态代码
typedef int Status;


typedef int ElemType;    // 自定义循环队列的数据元素为整数。
typedef struct LNode
{
	ElemType data;         // 存储队列中的元素。
	struct LNode *next;    // next指针。
}LNode;

typedef struct
{
	LNode *front, *rear;     // 队列的头指针和尾指针。
}LinkQueue, *PLinkQueue;

// 队列QQ的初始化操作。
int InitQueue(PLinkQueue QQ);

// 销毁队列QQ。
void DestroyQueue(PLinkQueue QQ);

// 清空队列。
void Clear(PLinkQueue QQ);

// 元素入队，返回值：0-失败；1-成功。
int InQueue(PLinkQueue QQ, ElemType *ee);

// 打印队列中全部的元素。
void PrintQueue(PLinkQueue QQ);

// 求队列的长度，返回值：>=0-队列QQ元素的个数。
int  Length(PLinkQueue QQ);

// 判断队列是否已满，链式队列不存在队满的说法。
int IsFull(PLinkQueue QQ);

// 判断队列是否为空，返回值：1-空，0-非空或失败。
int  IsEmpty(PLinkQueue QQ);

// 元素出队，返回值：0-失败；1-成功。
int OutQueue(PLinkQueue QQ, ElemType *ee);

// 获取队头元素，返回值：0-失败；1-成功。
// 只查看队头元素的值，元素不出队。
int GetHead(PLinkQueue QQ, ElemType *ee);




//


//Linkqueue.cpp
#include "LinkQueue.h"

// 队列QQ的初始化操作。
int InitQueue(PLinkQueue QQ)
{
	if (QQ == NULL)return ERROR;
	LNode *s = new LNode;
	s->next = NULL;
	QQ->front =QQ->rear =  s;
	return OK;
}

// 销毁队列QQ。
void DestroyQueue(PLinkQueue QQ)
{
	if (QQ == NULL)return;
	LNode *p = QQ->front;
	LNode *q ;
	while (p)
	{
		q = p->next;
		delete p;
		p = q;
	}
	QQ->front = QQ->rear = NULL;  // 防止野指针。
	return;
}

// 清空队列。
void Clear(PLinkQueue QQ)
{
	if (QQ == NULL)return;
	LNode *p = QQ->front->next;
	LNode *q;
	while (p)
	{
		q = p->next;
		delete p;
		p = q;
	}
	QQ->rear = QQ->front;
	QQ->front->next = NULL;
	
}

// 元素入队，返回值：0-失败；1-成功。
int InQueue(PLinkQueue QQ, ElemType *ee)
{
	if (QQ == NULL || *ee == NULL)return ERROR;
	if (QQ->front ==  NULL)
	{
		printf("队列未初始化\n");
	}

	LNode *s = new LNode;
	if (s == NULL) return 0;  // 内存不足，返回失败
	memcpy(&s->data, ee, sizeof(ElemType));
	s->next = NULL;

	QQ->rear->next = s;
	QQ->rear = s;
	return OK;

}

// 打印队列中全部的元素。
void PrintQueue(PLinkQueue QQ)
{
	if (QQ == NULL)return;
	if (QQ->front == NULL)
	{
		printf("队列未初始化\n");
	}
	LNode *p = QQ->front->next;
	while (p)
	{
		printf("%-3d", p->data);  // 如果元素ee为结构体，这行代码要修改。
		p = p->next;

	}
	printf("\n");
}

// 求队列的长度，返回值：>=0-队列QQ元素的个数。
int  Length(PLinkQueue QQ)
{
	if (QQ == NULL)return ERROR;
	if (QQ->front == NULL)
	{
		return 0;
	}
	int n = 0;
	LNode *p = QQ->front->next;
	while (p)
	{
		++n;
		p = p->next;
	}
	return n;
}

// 判断队列是否为空，返回值：1-空，0-非空或失败。
int  IsEmpty(PLinkQueue QQ)
{
	if (QQ == NULL)return ERROR;
	if (QQ->front == NULL)
	{
		printf("队列未初始化\n");
		return ERROR;
	}
	if (QQ->front->next == NULL)
	{
		printf("队列为空\n");
		return OK;
	}
	return ERROR;
}

// 元素出队，返回值：0-失败；1-成功。
int OutQueue(PLinkQueue QQ, ElemType *ee)
{
	if (QQ == NULL || *ee == NULL)return ERROR;
	if (QQ->front == NULL)
	{
		printf("队列未初始化\n");
	}
	if (IsEmpty(QQ) == 1) { printf("队列为空。\n"); return 0; }
	LNode * p = QQ->front->next;
	memcpy(ee, &p->data, sizeof ElemType);
	QQ->front->next = p->next;
	if (QQ->rear == p) QQ->rear = QQ->front;
	delete p;
	return OK;

}

// 获取队头元素，返回值：0-失败；1-成功。
// 只查看队头元素的值，元素不出队。
int GetHead(PLinkQueue QQ, ElemType *ee)
{
	if (QQ == NULL || *ee == NULL)return ERROR;
	if (QQ->front == NULL)
	{
		printf("队列未初始化\n");
	}
	if (IsEmpty(QQ) == 1) { printf("队列为空。\n"); return 0; }
	memcpy(ee, &QQ->front->next->data, sizeof ElemType);
	return OK;
}



void test01()
{
	LinkQueue QQ;     // 创建队列。

	memset(&QQ, 0, sizeof(LinkQueue));

	InitQueue(&QQ);  // 初始化队列。

	ElemType ee;     // 创建一个数据元素。

	printf("元素（1、2、3、4、5、6、7、8、9、10）入队。\n");
	ee = 1;  InQueue(&QQ, &ee);
	ee = 2;  InQueue(&QQ, &ee);
	ee = 3;  InQueue(&QQ, &ee);
	ee = 4;  InQueue(&QQ, &ee);
	ee = 5;  InQueue(&QQ, &ee);
	ee = 6;  InQueue(&QQ, &ee);
	ee = 7;  InQueue(&QQ, &ee);
	ee = 8;  InQueue(&QQ, &ee);
	ee = 9;  InQueue(&QQ, &ee);
	ee = 10; InQueue(&QQ, &ee);

	printf("队列的长度是%d\n", Length(&QQ));

	PrintQueue(&QQ);

	if (OutQueue(&QQ, &ee) == 1)  printf("出队的元素值为%d\n", ee);
	if (OutQueue(&QQ, &ee) == 1)  printf("出队的元素值为%d\n", ee);
	if (OutQueue(&QQ, &ee) == 1)  printf("出队的元素值为%d\n", ee);
	if (OutQueue(&QQ, &ee) == 1)  printf("出队的元素值为%d\n", ee);
	if (OutQueue(&QQ, &ee) == 1)  printf("出队的元素值为%d\n", ee);
	if (OutQueue(&QQ, &ee) == 1)  printf("出队的元素值为%d\n", ee);
	if (OutQueue(&QQ, &ee) == 1)  printf("出队的元素值为%d\n", ee);

	printf("队列的长度是%d\n", Length(&QQ));
	PrintQueue(&QQ);

	printf("元素（11、12、13、14、15）入队。\n");
	ee = 11;  InQueue(&QQ, &ee);
	ee = 12;  InQueue(&QQ, &ee);
	ee = 13;  InQueue(&QQ, &ee);
	ee = 14;  InQueue(&QQ, &ee);
	ee = 15;  InQueue(&QQ, &ee);

	printf("队列的长度是%d\n", Length(&QQ));

	PrintQueue(&QQ);

	// 只查看队头元素的值，元素不出队。
	if (GetHead(&QQ, &ee) == 1)  printf("队头的元素值为%d\n", ee);

	DestroyQueue(&QQ); // 销毁队列QQ。

}

int main()
{
	test01();
	system("pause");
	return EXIT_SUCCESS;
	
}
Dev晚风
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构10分钟入门--队列
wszdezh123的博客
09-09 180
队列是一种先进先出（First In First Out， FIFO）的线性存储结构，限定只能在表的一端（队尾）进行插入元素，表的另一端（队头）进行删除元素
数据结构5--队列
温故知新
05-22 298
队列队列模型队列的顺序存储 队列模型 队列：只允许在一端进行插入操作，而另一端进行删除操作的线性表 允许插入（入队，进队）的一端称为队尾，允许删除（出队）的一端称为队头 空队列：不含任何数据元素的队列。. 操作特性：先进先出 队列的顺序存储 顺序存储的改进 队头指针 front 指向队头元素的前一个位置, 队尾指针 rear 指向队尾元素。 特点：从队尾依次入队，从队头依次出队。 出队的话，操作 front 指针即可，时间复杂度提高为 O(1)，整个队列向数组下标较大方向移动，具有单向移动性
数据结构(四)--队列
weixin_30470643的博客
12-27 215
数据结构(四)--队列 本文主要讲解了队列的定义和队列主要功能实现的算法。最后会列举一些队列在程序设计当中常见的应用实例！相信了解了队列对你理解数据结构和程序设计会更加有益处！ 1. 队列的定义 队列 (Queue)是一种先进先出(first in first out : FIFO)的线性表。它只允许在表的一端进行插入，在另一端进行删除元素。这和我们平时战队买票很一样。最早进入队列的元素...
c语言Inqueue函数用法,队列实例代码（C语言）
weixin_34626779的博客
05-20 527
队列实例代码(C语言)，具体的实现如下代码所示：QueueDemo.c#include #include #include #include #define MAX 6int intArray[MAX];int front = 0;int rear = -1;int itemCount = 0;int peek(){return intArray[front];}bool isEmpty(){re...
inEdit 的设计方法--inQueue
achun
11-12 1052
在inEdit包里面有一个inCore.js的文件,这个文件的对象是inEdit的基础. 在这里面设计的几个对象里面inQueue队列处理对象是比较特殊的一个.   inQueue :对序列化函数调用的处理(由于目前仅有Event有实例可讲,所以我只能说这个了)   inQueue认为DOM事件的处理也属于队列,不管是一个Element上绑定了多个事件,还是绑定了同一个事件的不同函数调用...
数据结构学习--队列及其应用
06-25
数据结构学习--队列及其应用 队列是一种重要的数据结构，它广泛应用于计算机科学和信息技术领域。队列的应用非常广泛，例如医院排队、银行排队、超market排队等等。 一、队列的定义 队列是一种特殊的线性表，它...
数据结构学习-队列/栈
04-28
简单的介绍了队列的实现原理，和一些开发中的考量
数据结构--队列--思维导图.pdf
08-29
数据结构--队列--思维导图.pdf 数据结构中，队列（Queue）是一种重要的抽象数据类型，具有重要的应用价值。队列是一种特殊的线性表，它只允许在一端进行插入，另一端进行删除。队列的基本概念和操作将在下面详细...
数据结构--队列实验报告.docx
03-24
数据结构--队列实验报告
数据结构实验-队列的相关计算
最新发布
05-12
采用链式存储结构的队列实质上是限定了仅在头结点之后执行删除操作、在表尾结点后执行插入操作的线性链表，如下图所示。 队列的存储结构定义为： typedef struct Node{ QueueElementType data; /* 数据域 */ ...
c语言Inqueue函数用法,In Queue
weixin_35823067的博客
05-20 944
Apologies for the tardiness of today’s post.A 1 ½ hour sojourn to the auto shop to get a new tire knocked me right on my psychologically ill butt.SPLAT!Gathering what remains of my badly chipped psyc...
c语言Inqueue函数用法,C语言用两个栈实现队列(完整版)
weixin_39788792的博客
05-20 1273
队列是一种 先进先出(first in - first out， FIFO)的数据结构，队列中的元素都从后端(rear)入队(push)，从前端(front)出队(pop)。实现队列最直观的方法是用链表，但在这篇文章里我会介绍另一个方法 - 使用栈。栈是一种 后进先出(last in - first out， LIFO)的数据结构，栈中元素从栈顶(top)压入(push)，也从栈顶弹出(pop)。...
数据结构之队列
学习日常分享
06-03 588
队列是另一种限定性线性表，限定：一端插入元素，另一端删除元素。 队尾(rear)：允许插入的一端。 队头(front)：允许删除的一端。 特性：先进先出 队列：即FIFO表 队列的表示和实现 两种基本存储结构：循环队列、链队列 循环队列：顺序存储的队列。 链队列： 链式存储的队列。队头指针：指向头结点 队尾指针：指向尾结点 (1) 链队列结点类型定义 (2) 链队列类型定义 队头指针、队尾指针封装的结构体 队头指针：Q.front、Q->front 队尾指针： Q.rear、Q->rear 循环
队列Queue定义与操作
qq_32535377的博客
03-28 926
#include #define MaxSize 100 #define OK 1 #define ERROR 0 typedef int Status;//表示返回的状态值 typedef int ElemType; /* 1、队列可分为“循环队列”和“栈队列” 循环队列 ：通过将顺序的内存地址看做首位相连的地址，来实现队列的增删，缺点是队列有最大的固定大小 栈队列 ：则
C++队列queue用法详解
热门推荐
KEPROM的博客
11-17 14万+
C++队列queue用法详解一、定义一、queue初始化初始化示例注意：不能用vector容器初始化queue二、queue常用函数1.常用函数2.函数运用示例 一、定义 queue是一种容器转换器模板，调用#include< queue>即可使用队列类。 一、queue初始化 queue<Type, Container> (<数据类型，容器类型>） 初始化时必须要有数据类型，容器可省略，省略时则默认为deque 类型 初始化示例 1： queueq1; queueq2
C语言队列
qq_40104597的博客
05-14 255
2021-5-14
数据结构篇——顺序队列
handsomeRE的博客
07-02 812
数据结构篇——顺序队列
数据结构-队列_习题
weixin_33682719的博客
04-18 1597
《实用数据结构》 第4章 6.1题//算法设计题.要求：设一个循环队列Queue，只有头指针front,不设尾指针，另设一个含有元素个数的记录器count, //试写出相应的入队和出队的算法 #include<iostream> #include<stdlib.h> #include<time.h> usingnamespace...
数据结构(Queue) — Queue 综述
Elson的博客
05-31 1212
一、概述 队列 是一种特殊的线性表，只允许在表的前面(队头)进行删除操作，而在表的后面(队尾)进行插入操作。即最先插入的元素最先被删除；因此队列又称为 先进先出（FIFO) 的线性表。 还有一种数据结构是 栈，它的特点是 后入先出(FILO)，即最先进入的元素最后才出来。 二、类图 三、...
数据结构-队列的应用数据结构-队列的应用
07-27
队列是一种先进先出（FIFO）的数据结构，它常用于需要按顺序处理数据的场景。下面是一些队列的常见应用： 1. 网络通信：在网络通信中，数据包通常按照到达的顺序进行处理。使用队列可以确保数据包被按照顺序处理，避免数据丢失或乱序。 2. 高级编程语言中的函数调用：函数调用堆栈通常使用队列来管理函数调用的顺序。每次函数调用时，函数会被添加到队列的末尾，然后按照先进先出的顺序执行。 3. 多线程编程：在多线程编程中，队列可以用于线程间的数据共享和通信。一个线程可以将数据放入队列，而另一个线程可以从队列中取出并进行处理。 4. 操作系统任务调度：操作系统中的任务调度器通常使用队列来管理待执行任务的顺序。每个任务被添加到队列中，然后按照顺序执行。 5. 打印机队列：打印机可以接收多个打印任务，而这些任务需要按照到达的先后顺序进行打印。打印机队列可以使用队列来管理这些打印任务，确保它们按照正确的顺序进行处理。 这些只是队列应用的一些例子，实际上队列在计算机科学和软件开发中有很多应用。它们通常用于需要按照顺序处理数据的场景，确保数据的有序性和一致性。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值