第1关：循环队列的基本操作
任务描述
本关任务是实现循环队列的基本操作函数，以实现判断队列是否为满、是否为空、求队列元素个数、进队和出队等功能。
相关知识
队列的基本概念
队列（简称队）也是一种运算受限的线性表，在这种线性表上，插入限定在表的某一端进行，删除限定在表的另一端进行。
队列的插入操作称为进队，删除操作称为出队。
允许插入的一端称为队尾，允许删除的一端称为队头。
新插入的元素只能添加到队尾，被删除的只能是排在队头的元素。
一个队列的示意图:
队列通常有两种存储结构，即顺序存储结构和链式存储结构。
队列的顺序存储结构简称为顺序队列，它由一个一维数组（用于存储队列中元素）及两个分别指示队头和队尾的变量组成，这两个变量分别称为“队头指针”和“队尾指针”。
通常约定队尾指针指示队尾元素的当前位置，队头指针指示队头元素的前一个位置。
循环队列的类型定义
#define MAX_QSIZE 5 // 最大队列长度+1
struct SqQueue
{
QElemType *base; // 初始化的动态分配存储空间
int front; // 头指针，若队列不空，指向队列头元素
int rear; // 尾指针，若队列不空，指向队列尾元素的下一个位置
};
使用顺序队列时会出现“假溢出现象”，为了能够充分地使用数组中的存储空间，可以把数组的前端和后端连接起来，形成一个环形的表，即把存储队列元素的表从逻辑上看成一个环。这个环形的表叫做循环队列。
一个循环队列示意图：
队头队尾指针进1的操作为：
队头指针进1：front=(front+1) MOD MaxSize
队尾指针进1：rear=(rear+1) MOD MaxSize
为了在循环队列中区分队空和队满，规定：
设置队空条件为front==rear。
设置队满条件为(rear+1) MOD MaxSize==front。也就是说，当rear指到front的前一位置时就认为队列满了。
显然在这样设置的队满条件下，队满条件成立时队中还有一个空闲单元，也就是说这样的队中最多只能进队MaxSize-1个元素。
#include <stdio.h>
#include<stdlib.h>
#include <iostream>
using namespace std;
// 函数结果状态代码
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define OVERFLOW -1
typedef int QElemType;
#define MAX_QSIZE 5 // 最大队列长度+1
struct SqQueue
{
QElemType *base; // 初始化的动态分配存储空间
int front; // 头指针，若队列不空，指向队列头元素
int rear; // 尾指针，若队列不空，指向队列尾元素的下一个位置
};
void print(QElemType i)
{
printf("%d ",i);
}
void InitQueue(SqQueue &Q); // 构造一个空队列Q
void DestroyQueue(SqQueue &Q); // 销毁队列Q，Q不再存在
void ClearQueue(SqQueue &Q); // 将Q清为空队列
int QueueEmpty(SqQueue Q); // 若队列Q为空队列，则返回TRUE；否则返回FALSE
int QueueLength(SqQueue Q); // 返回Q的元素个数，即队列的长度
int GetHead(SqQueue Q,QElemType &e); // 若队列不空，则用e返回Q的队头元素，并返回OK；否则返回ERROR
int EnQueue(SqQueue &Q,QElemType e); // 插入元素e为Q的新的队尾元素
int DeQueue(SqQueue &Q,QElemType &e); // 若队列不空，则删除Q的队头元素，用e返回其值，并返回OK；否则返回ERROR
void QueueTraverse(SqQueue Q,void(*vi)(QElemType)); // 从队头到队尾依次对队列Q中每个元素调用函数vi()
int main()
{
int j;
int i=0,l;
QElemType d;
SqQueue Q;
InitQueue(Q);
for(i=0;i<MAX_QSIZE;i++)
{
scanf("%d",&d);
EnQueue(Q,d);
};
printf("队列长度为: %d\n",QueueLength(Q));
printf("现在队列中元素:\n");
QueueTraverse(Q,print);
DeQueue(Q,d);
printf("删除的元素是%d\n",d);
DeQueue(Q,d);
printf("删除的元素是%d\n",d);
scanf("%d",&d);
EnQueue(Q,d);
printf("队列长度为: %d\n",QueueLength(Q));
printf("现在队列中元素:\n");
QueueTraverse(Q,print);
j=GetHead(Q,d);
if(j)
printf("现在队头元素为:%d\n",d);
ClearQueue(Q);
DestroyQueue(Q);
}
// 循环队列的基本操作(9个)
void InitQueue(SqQueue &Q)
{ // 构造一个空队列Q
/********** Begin **********/
Q.base = (QElemType *)malloc(MAX_QSIZE * sizeof(QElemType));
if (!Q.base) exit(OVERFLOW); // 存储分配失败
Q.front = Q.rear = 0; // 头指针和尾指针置为零，队列为空
/********** End **********/
}
void DestroyQueue(SqQueue &Q)
{ // 销毁队列Q，Q不再存在
/********** Begin **********/
free(Q.base);
Q.base = NULL;
Q.front = Q.rear = 0;
/********** End **********/
}
void ClearQueue(SqQueue &Q)
{ // 将Q清为空队列
/********** Begin **********/
Q.front = Q.rear = 0;
/********** End **********/
}
int QueueEmpty(SqQueue Q)
{ // 若队列Q为空队列，则返回TRUE；否则返回FALSE
/********** Begin **********/
return Q.front == Q.rear;
/********** End **********/
}
int QueueLength(SqQueue Q)
{ // 返回Q的元素个数，即队列的长度
/********** Begin **********/
return (Q.rear - Q.front + MAX_QSIZE) % MAX_QSIZE;
/********** End **********/
}
int GetHead(SqQueue Q,QElemType &e)
{ // 若队列不空，则用e返回Q的队头元素，并返回OK；否则返回ERROR
/********** Begin **********/
if(Q.front==Q.rear) // 队列空
return ERROR;
e=Q.base[Q.front];
return OK;
/********** End **********/
}
int EnQueue(SqQueue &Q,QElemType e)
{ // 插入元素e为Q的新的队尾元素
/********** Begin **********/
if ((Q.rear + 1) % MAX_QSIZE == Q.front) // 队列满
return ERROR;
Q.base[Q.rear] = e;
Q.rear = (Q.rear + 1) % MAX_QSIZE; // rear指针向后移一位置，若到最后则转到数组头部
return OK;
/********** End **********/
}
int DeQueue(SqQueue &Q,QElemType &e)
{ // 若队列不空，则删除Q的队头元素，用e返回其值，并返回OK；否则返回ERROR
/********** Begin **********/
if (Q.front == Q.rear) // 队列空
return ERROR;
e = Q.base[Q.front]; // 将队头元素赋值给e
Q.front = (Q.front + 1) % MAX_QSIZE; // front指针向后移一位置，若到最后则转到数组头部
return OK;
/********** End **********/
}
void QueueTraverse(SqQueue Q,void(*vi)(QElemType))
{ // 从队头到队尾依次对队列Q中每个元素调用函数vi()
/********** Begin **********/
for (int i = Q.front; i != Q.rear; i = (i + 1) % MAX_QSIZE) {
vi(Q.base[i]); // 调用函数vi输出队中元素
}
printf("\n"); // 输出换行
/********** End **********/
}
第2关：链队列的基本操作
任务描述
本关任务是实现链队列的基本操作函数，以实现判断队列是否为满、是否为空、求队列元素个数、进队和出队等功能。
相关知识
链队列的基本概念
队列的链式存储结构简称为链队列。
这里采用的链队是一个同时带有队头指针front和队尾指针rear的单链表。
队头指针指向队头结点，队尾指针指向队尾结点即单链表的尾结点，并将队头和队尾指针结合起来构成链队结点，
链队列的类型定义
typedef struct QNode
{
QElemType data;
QNode *next;
}*QueuePtr;
struct LinkQueue
{
QueuePtr front,rear; // 队头、队尾指针
};
#include <stdio.h>
#include<stdlib.h>
#include <iostream>
using namespace std;
// 函数结果状态代码
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define OVERFLOW -1
typedef int QElemType;
typedef struct QNode
{
QElemType data;
QNode *next;
}*QueuePtr;
struct LinkQueue
{
QueuePtr front,rear; // 队头、队尾指针
};
void print(QElemType i)
{
printf("%d ",i);
}
void InitQueue(LinkQueue &Q); // 构造一个空队列Q
void DestroyQueue(LinkQueue &Q); // 销毁队列Q，Q不再存在
void ClearQueue(LinkQueue &Q); // 将Q清为空队列
int QueueEmpty(LinkQueue Q); // 若队列Q为空队列，则返回TRUE；否则返回FALSE
int QueueLength(LinkQueue Q); // 返回Q的元素个数，即队列的长度
int GetHead(LinkQueue Q,QElemType &e); // 若队列不空，则用e返回Q的队头元素，并返回OK；否则返回ERROR
int EnQueue(LinkQueue &Q,QElemType e); // 插入元素e为Q的新的队尾元素
int DeQueue(LinkQueue &Q,QElemType &e); // 若队列不空，则删除Q的队头元素，用e返回其值，并返回OK；否则返回ERROR
void QueueTraverse(LinkQueue Q,void(*vi)(QElemType)); // 从队头到队尾依次对队列Q中每个元素调用函数vi()
int main()
{
int j;
int i=0,l;
QElemType d;
LinkQueue Q;
InitQueue(Q);
for(i=0;i<5;i++)
{
scanf("%d",&d);
EnQueue(Q,d);
};
printf("队列长度为: %d\n",QueueLength(Q));
printf("现在队列中元素:\n");
QueueTraverse(Q,print);
DeQueue(Q,d);
printf("删除的元素是%d\n",d);
DeQueue(Q,d);
printf("删除的元素是%d\n",d);
scanf("%d",&d);
EnQueue(Q,d);
printf("队列长度为: %d\n",QueueLength(Q));
printf("现在队列中元素:\n");
QueueTraverse(Q,print);
j=GetHead(Q,d);
if(j)
printf("现在队头元素为:%d\n",d);
ClearQueue(Q);
DestroyQueue(Q);
}
// 链队列的基本操作(9个)
void InitQueue(LinkQueue &Q)
{ // 构造一个空队列Q
/********** Begin **********/
Q.front = Q.rear = (QueuePtr)malloc(sizeof(QNode)); // 创建头结点
if (!Q.front) exit(OVERFLOW); // 存储分配失败
Q.front->next = NULL; // 头结点之后暂时没有元素
/********** End **********/
}
void DestroyQueue(LinkQueue &Q)
{ // 销毁队列Q(无论空否均可)
/********** Begin **********/
QElemType temp;
while (!QueueEmpty(Q)) {
DeQueue(Q, temp); // 出队所有元素
}
free(Q.front); // 释放头结点
Q.front = Q.rear = NULL;
/********** End **********/
}
void ClearQueue(LinkQueue &Q)
{ // 将Q清为空队列
/********** Begin **********/
QElemType temp;
while (!QueueEmpty(Q)) {
DeQueue(Q, temp); // 出队所有元素
}
/********** End **********/
}
int QueueEmpty(LinkQueue Q)
{ // 若Q为空队列，则返回TRUE，否则返回FALSE
/********** Begin **********/
return Q.front == Q.rear;
/********** End **********/
}
int QueueLength(LinkQueue Q)
{ // 求队列的长度
/********** Begin **********/
int length = 0;
QueuePtr p = Q.front->next;
while (p) {
length++;
p = p->next;
}
return length;
/********** End **********/
}
int GetHead(LinkQueue Q,QElemType &e)
{ // 若队列不空，则用e返回Q的队头元素，并返回OK，否则返回ERROR
/********** Begin **********/
if (QueueEmpty(Q)) return ERROR;
e = Q.front->next->data;
return OK;
/********** End **********/
}
int EnQueue(LinkQueue &Q,QElemType e)
{ // 插入元素e为Q的新的队尾元素
/********** Begin **********/
QueuePtr p = (QueuePtr)malloc(sizeof(QNode));
if (!p) exit(OVERFLOW); // 存储分配失败
p->data = e;
p->next = NULL;
Q.rear->next = p; // 插入到队尾
Q.rear = p; // 修改队尾指针
return OK;
/********** End **********/
}
int DeQueue(LinkQueue &Q,QElemType &e)
{ // 若队列不空，删除Q的队头元素，用e返回其值，并返回OK，否则返回ERROR
/********** Begin **********/
if (QueueEmpty(Q)) return ERROR;
QueuePtr p = Q.front->next;
e = p->data;
Q.front->next = p->next; // 修改头结点的next指针
if (Q.rear == p) Q.rear = Q.front; // 删除的是队尾元素，则修改队尾指针
free(p);
return OK;
/********** End **********/
}
void QueueTraverse(LinkQueue Q,void(*vi)(QElemType))
{ // 从队头到队尾依次对队列Q中每个元素调用函数vi()
/********** Begin **********/
QueuePtr p = Q.front->next; // p指向队头元素
while (p) {
vi(p->data); // 调用函数vi()
p = p->next;
}
printf("\n");
/********** End **********/
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
