PTA-队列练习题
选择题
2-1在少用一个元素空间的循环队列(m为最大队列长度)是满队列的条件（ ）。
A.rear== front
B.(rear+1)%m==front
C.(rear+1) == front
D.front ==(front+1)%m
2-2循环队列存储在数组A[0…n-1]中，其头尾指针分别为f和r，头指针f总是指向队头元素，尾指针r总是指向队尾元素的下一个位置，假设队列不空，元素出队时头尾指针的操作为（ ）。
A.f=(f+1)%n
B.f=f+1
C.r=(r+1)%n
D.f=(f+1)%(n-1)
2-3设循环队列中数组的下标范围是0—n-1，其头尾指针分别为front和rear，头指针front总是指向队头元素，尾指针rear总是指向队尾元素的下一个位置，则其元素的个数为( )
A.rear-front
B.rear-front+1
C.(rear-front)%n+1
D.(rear-front+n) %n
2-4设循环队列中数组的下标范围是0—n，其头尾指针分别为front和rear，头指针front总是指向队头元素，尾指针rear总是指向队尾元素的下一个位置，则其元素的个数为( )。
A.rear-front
B.rear-front+1
C.(rear-front+n+1)%（n+1）
D.(rear-front+n) %n
2-5设循环队列中数组的下标范围是0—n-1，其头尾指针分别为f和r，头指针f总是指向队头元素，尾指针r总是指向队尾元素的下一个位置，则队满的条件为( )。
A.(r+1)%n == f
B. r == f
C.r+1 == f
D.(r-l)%n == f
2-6在一个链表表示的队列中， f和r分别指向队列的头和尾。下列哪个操作能正确地将s结点插入到队列中：
A.f->next=s; f=s;
B.r->next=s; r=s;
C.r+1 == f
D.(r-l)%n == f
2-7用链接方式存储的队列，在进行删除运算时（ ）。
A.仅修改头指针
B.仅修改尾指针
C.头、尾指针都要修改
D.头、尾指针可能都要修改
2-8
最大容量为n的循环队列，队尾指针是rear，队头是front，则队空的条件是（ ）。
(2分)
A.
(rear+1)%n==front
B.
rear==front
C.
rear+1==front
D.
(rear-l)%n==front
2-9
队列的“先进先出”特性是指（ ）。
Ⅰ.最后插入队列中的元素总是最后被删除
Ⅱ.当同时进行插入、删除操作时，总是插入操作优先
Ⅲ.每当有删除操作时，总要先做一次插入操作
Ⅳ.每次从队列中删除的总是最早插入的元素
(2分)
A.
Ⅰ
B.
Ⅰ、Ⅳ
C.
Ⅱ、Ⅲ
D.
Ⅳ
2-10
已知循环队列的存储空间为数组A[21]，front指向队头元素的前一个位置，rear指向队尾元素，假设当前front和rear的值分别为8和3，则该队列的长度为（ ）。
(2分)
A.
5
B.
6
C.
16
D.
17
2-11
若用数组A[0…5]来实现循环队列，且当前rear和front的值分别为1和5，当从队列中删除一个元素，再加入两个元素后，rear和front的值分别为（ ）。
(2分)
A.
3和4
B.
3和0
C.
5和0
D.
5和1
2-12
循环队列放在一维数组A[0…M-1]中，end1指向队头元素，end2指向队尾元素的后一个位置。假设队列两端均可进行入队和出队操作，队列中最多能容纳M－1个元素。初始时为空。下列判断队空和队满的条件中，正确的是（ ）。
(2分)
A.
队空：end1 == end2;队满： end1==(end2+1)mod M
B.
队空：end1 == end2;队满：end2==(end1+1)mod (M-1)
C.
队空：end2==(end1+1) mod M;队满：end1==(end2+1) mod M
D.
队空：end1==(end2+1) mod M;队满：end2==(end1+1)mod (M-1)
答案：
DCDCA
BDBBC
BA
程序填空题
5-1
已知循环队列的结构定义如下：
typedef struct
{
int size, front, rear;
int *element;
} AQUEUE;
说明：element 为存储队列数据元素的动态数组，size 为动态数组的尺寸，front 为队首元素的下标，rear 为队尾元素下一位置的下标。
假设有以下定义：
AQUEUE *queue;
判断 queue 所指队列为空的条件是：
queue->front==queue->rear
；
判断 queue 所指队列为满的条件是：
(queue->rear + 1) % queue->size == queue->front
；
queue 所指队列的长度是：
(queue->rear - queue->front + queue->size) % queue->size
5-3
循环队列入队出队操作。
#include
using namespace std;
#define MAXQSIZE 100
#define OK 1
#define ERROR 0
#define OVERFLOW -2
typedef char QElemType;
typedef char SElemType;
typedef int Status;
typedef struct {
QElemType *base;
int front;
int rear;
} SqQueue;
Status InitQueue(SqQueue &Q) {
Q.base=new QElemType
;
if (!Q.base)
exit(OVERFLOW);
Q.front=Q.rear=0
;
return OK;
}
Status EnQueue(SqQueue &Q, QElemType e) {
if (
(Q.rear+1) % MAXQSIZE == Q.front
)
return ERROR;
Q.base[Q.rear] = e;
Q.rear=(Q.rear+1) % MAXQSIZE
;
return OK;
}
Status DeQueue(SqQueue &Q, QElemType &e) {
if (
Q.front == Q.rear
)
return ERROR;
e = Q.base[Q.front];
Q.front = (Q.front+1) % MAXQSIZE
;
return OK;
}
int main() {
SqQueue Q;
int n, i;
char c;
InitQueue(Q);
cin >> n;
for(i=0;i
EnQueue(Q,c);
}
for(i=0;i}
5-4
链队基本操作。
#include
using namespace std;
#define OK 1
#define ERROR 0
typedef int Status;
typedef char QElemType;
typedef struct QNode {
QElemType data;
struct QNode *next;
} QNode, *QueuePtr;
typedef struct {
QueuePtr front;
QueuePtr rear;
} LinkQueue;
Status InitQueue(LinkQueue &Q) {
Q.front = Q.rear = new QNode;
Q.front->next = NULL;
return OK;
}
Status EnQueue(LinkQueue &Q, QElemType e) {
QueuePtr p;
p = new QNode;
p->data = e;
p->next = NULL;
Q.rear->next=p
;
Q.rear=p
;
return OK;
}
Status DeQueue(LinkQueue &Q, QElemType &e) {
QueuePtr p;
if (Q.front == Q.rear)
return ERROR;
p = Q.front->next;
e = p->data;
Q.front->next=p->next
;
if (Q.rear == p)
Q.rear=Q.front
;
delete p;
return OK;
}
int main() {
LinkQueue Q;
int n,m,i;
char c;
InitQueue(Q);
cin >> n;
for(i=0;i
EnQueue(Q,c);
}
for(i=0;i
}
cin >> m;
for(i=0;i
EnQueue(Q,c);
}
for(i=0;i
cout << c << " ";
}
return 0;
}
输入格式:
输入第一行为1个整数n，第二行输入n个字符，将n个字符依次入队，再执行n次出队操作（不输出）。 输入第三行为1个整数m，第四行输入m个字符，将m个字符依次入队，再执行m次出队操作并输出。
4
ABCD
5
12345
输出格式:
1 2 3 4 5
函数题
6-1 舞伴问题
假设男士和女士的记录存放在一个数组中，设计算法实现舞伴配对，要求输出配对的舞伴，并输出没有配对的队头元素的姓名。
函数接口定义：
void DancePartner(DataType dancer[], int num) ;
其中 dancer[]是存放男士和女士信息的数组，num是数组大小。
裁判测试程序样例：
#include
#include
typedef struct {
char name[20];
char sex;
} DataType;
struct Node {
DataType data;
struct Node* next;
};
typedef struct Node *PNode;
struct Queue
{
PNode f;
PNode r;
};
typedef struct Queue *LinkQueue;
LinkQueue SetNullQueue_Link()
{
LinkQueue lqueue;
lqueue = (LinkQueue)malloc(sizeof(struct Queue));
if (lqueue != NULL)
{
lqueue->f = NULL;
lqueue->r = NULL;
}
else
printf("Alloc failure! \n");
return lqueue;
}
int IsNullQueue_link(LinkQueue lqueue)
{
return (lqueue->f == NULL);
}
void EnQueue_link(LinkQueue lqueue, DataType x)
{
PNode p;
p = (PNode)malloc(sizeof(struct Node));
if (p == NULL)
printf("Alloc failure!");
else {
p->data = x;
p->next = NULL;
if (lqueue->f == NULL)
{
lqueue->f = p;
lqueue->r = p;
}
else
{
lqueue->r->next = p;
lqueue->r = p;
}
}
}
void DeQueue_link(LinkQueue lqueue)
{
struct Node * p;
if (lqueue->f == NULL)
printf("It is empty queue!\n ");
else
{
p = lqueue->f;
lqueue->f = lqueue->f->next;
free(p);
}
}
DataType FrontQueue_link(LinkQueue lqueue)
{
if (lqueue->f == NULL)
{
printf("It is empty queue!\n");
}
else
return (lqueue->f->data);
}
void DancePartner(DataType dancer[], int num)
{
/* 请在这里填写答案 */
}
int main()
{
DataType dancer[9];
for (int i = 0; i < 9; i++)
scanf("%s %c", dancer[i].name, &dancer[i].sex);
DancePartner(dancer, 9);
return 0;
}
输入样例：
在这里给出一组输入。例如：
李敏浩 M
李钟硕 M
高欣雅 F
吴彦祖 M
王思聪 M
张甜源 F
张智霖 M
许丹丹 F
马小云 F
输出样例：
高欣雅 李敏浩
张甜源 李钟硕
许丹丹 吴彦祖
马小云 王思聪
张智霖
void DancePartner(DataType dancer[], int num)
{
LinkQueue Queue_head = SetNullQueue_Link();
for (int i = 0; i < num; i++)
{
if (!IsNullQueue_link(Queue_head) &&
(FrontQueue_link(Queue_head).sex) != dancer[i].sex)
{
if (dancer[i].sex == 'F')
printf("%s %s\n", dancer[i].name, Queue_head->f->data.name);
else
{
printf("%s %s\n", Queue_head->f->data.name, dancer[i].name);
}
DeQueue_link(Queue_head);
}
else
{
EnQueue_link(Queue_head, dancer[i]);
}
}
printf("\n");
if (!IsNullQueue_link(Queue_head))
{
printf("%s", Queue_head->f->data.name);
}
}
编程题
7-1 队列的实现及基本操作
给定一个初始为空的队列和一系列入队、出队操作，请编写程序输出每次出队的元素。队列的元素值均为整数。
输入格式:
输入第1行为1个正整数n，表示操作个数；接下来n行，每行表示一个操作，格式为1 d或0。1 d表示将整数d入队，0表示出队。n不超过20000。
输出格式:
按顺序输出每次出队的元素，每个元素一行。若某出队操作不合法（如在队列空时出队），则对该操作输出invalid。
输入样例:
7
1 1
1 2
0
0
0
1 3
0
输出样例:
1
2
invalid
3
答
#include
int queue[20000];
int front;
int rear;
void initqueue();//初始化队列
void enterqueue(int x);//入队
int deletequeue();//出队
int main()
{
int n,t;
int i,k=0;
int a[20000][2];
char ch;
scanf("%d",&n);
for(i=0;i