（单选）已知一个顺序存储的循环队列Q定义如下： #define MAXSIZE 50 typedef struct { QueueElementType element[MAXSIZE]; int front; //队头指示器 int rear; //队尾指示器 ｝SeqQueue; 则该非空队列取队头元素操作的语句是（) A. Q-＞element[0]; B. Q-＞element[1]; C. Q-＞element[Q-＞front]; D. Q-＞element[Q-＞rear];
题目
（单选）已知一个顺序存储的循环队列Q定义如下： #define MAXSIZE 50 typedef struct { QueueElementType element[MAXSIZE]; int front; //队头指示器 int rear; //队尾指示器 ｝SeqQueue; 则该非空队列取队头元素操作的语句是（) A. Q-＞element[0]; B. Q-＞element[1]; C. Q-＞element[Q-＞front]; D. Q-＞element[Q-＞rear];
相似考题
更多“（单选）已知一个顺序存储的循环队列Q定义如下： #define MAXSIZE 50 typedef struct { QueueElementType element[MAXSIZE]; int front; //队头指示器 int rear; //队尾指示器 ｝SeqQueue; 则该非空队列取队头元素操作的语句是（) A. Q-＞element[0]; B. Q-＞element[1]; C. Q-＞element[Q-＞front]; D. Q-＞element[Q-＞rear];”相关问题
-
第1题：
在队列中，(7)允许插入操作，(7)允许删除操作。
A．队头(front)队尾(rear)
B．队尾(rear)队头(front)
C．队头(front)和队尾(rear)队头(front)
D．队头(front)和队尾(rear)队头(front)和队尾(rear)
正确答案：B
解析：队列是一种先进先出的线性表，它只允许在队尾插入，在队头删除。 -
第2题：
设数组data[0…m]作为循环队列s q的存储空间，front为队头指针，rear为队尾指针，则执行出队操作的语句为（ ）。
A.S q↑．front：＝s q↑．front＋1；
B.S q↑．front：＝(S q↑．front＋1)%maxsize；
C.S q↑．rear：＝(S q↑．rear＋1)%maxsize；
D.S q↑．front：＝(s q↑．front＋1)%(maxsize＋1)；
正确答案：B
循环队列采用的方法是：假设向量Sq↑．data[maxsize]是一个首尾相接的圆环，即Sq↑．data[0]接在Sq↑．data[maxsize—1]之后，我们将这种意义下的向量称循环向量，并将循环向量中的队列称为循环队列。若当前尾指针等于向量的上界，则再做入队列操作时，令尾指针等于向量的下界，这样就利用到已被删除的元素空间，克服假上溢现象。因此入队操作时，在循环意义下的尾指针加1操作可描述为：if(Sq↑．rear>＝maxsize)sq↑．near：＝0；elsesq↑．rear＋＋；如果利用“模运算”，上述循环意义下的尾指针加l操作，可以更简洁地描述为：Sq↑．rear＝(sq↑．rear＋1)%maxsize。同样，出队操作时，在循环意义下的头指针加1操作，也可利用“模运算”来实现：sq↑．front：＝(sq↑．front＋1)%max—size。 -
第3题：
循环队列A[0…m-1)存放其元素，用front和Feat分别表示队头和队尾，则循环队列满的条件是(35)。
A．Q.rear+1==Q.front
B．Q.rear==Q.front+1
C．Q.rear==Q.front
D．(Q.rear+1)%m==Q.front
正确答案：D
解析：本题考查队列的基本知识。队列也是一种特殊的线性表，只允许在一端进行插入，另一端进行删除运算。循环队列就是将实现队列的A[M]的第一个元素A[0]与最后一个元素A[M-1]连接起来。在循环队列中用队头和队尾表示队列满的条件是(Q.rear+1)%m==Q.front。 -
第4题：
阅读下列函数说明和C函数，将应填入(n)处的字句写在对应栏内。
[说明]
链式存储的队列称为链队。根据队列的FIFO原则，为了操作上的方便，可以使用带头指针front和尾指针rear的单链表来实现链队。若链队元素的数据类型为datatype，则链队结构描述如下：
typedef struct node
{ datatypedata;
structnode *next;
} QNode; /*链队结点的类型*/
typedef struct
{ QNnode *front,*rear;
} LQueue; /*将头尾指针封装在一起的链队*/
以下这种链队的几个例子：
设q是一个指向链队的指针，即LQueue *q。下面各函数的功能说明如下：
(1) LQueue *Init_LQueue()：创建并返回一个带头尾结点的空链队；
(2) intEmpty_LQueue( LQueue *q):判断链队q是否空；
(3) void In_LQueue(LQueue *q, datatypex):将数据x压入链队q；
(4) int Out_LQueue(LQuere *q, datatype *x):弹出链队q的第一个元素x，若成功则返回返回1否则返回0。
[函数]
LQueae *Init_LQueue()
{ LQueue *q, *p;
q=malloc(sizeof(LQueue)); /*申请链队指针*/
P=malloc(sized(QNode));/*申请头尾指针结点*/
p-＞next=NULL;
(1)=p;
return q;
}
int Empty_LQueue(LQueue *q)
{ if(q-＞front (2) q＞rear) return 0;
else return 1;
}
void In_LQueue(LQueue *q, datatype x)
{ QNoda *p;
p=malloc(sizeof(QNnode));/*申请新接点*/
p-＞data=x;
p-＞next=NULL;
(3)=p;
q-＞rear=p;
}
int Out_LQueue(LQueue *q, datatype *x)
{ QNnode *p;
if(Empty_LQueue(q)) return 0; /*队空,操作失败*/
else{
p=q-＞front-＞next;
*x=(4);
(5)=p-＞next;
free(p);
if (q-＞front-＞next= =NULL)q-＞rear=q-＞front;
return 1;
}
}
正确答案：(1) q-＞front=q-＞rear (2) = = (3)q-＞ rear-＞next (4) p-＞data (5) q-＞front-＞next
(1) q-＞front=q-＞rear (2) = = (3)q-＞ rear-＞next (4) p-＞data (5) q-＞front-＞next 解析：(1)初始化链队q时，需要初始化其头尾指针，空链队的头尾指针相等；
(2)链队头尾指针重合当且仅当链队为空；
(3)向链队插入新元素的操作是在链队末尾进行的，需要将新元素结点接在原链队队尾，再让新的尾指针指向这一新结点；
(4)～(5)：链队q的第一个元素存放在其头结点之后的第一个结点(即p=q-＞front-＞next)中。*x= p-＞data表示将这个元素取出，以参数*x的形式返回：q-＞front-＞next=p-＞next表示将结点p从链队中取出。 -
第5题：
阅读以下说明和C函数，填补函数代码中的空缺(1)～(5)，将解答填入答题纸
的对应栏内。
【说明】
队列是一种常用的数据结构，其特点是先入先出，即元素的插入在表头、删除在表
尾进行。下面采用顺序存储方式实现队列，即利用一组地址连续的存储单元存放队列元
素，同时通过模运算将存储空间看作一个环状结构（称为循环队列）。
设循环队列的存储空间容量为MAXQSIZE，并在其类型定义中设置base、rear和
lengtb三个域变量，其中’base为队列空间的首地址，rear为队尾元素的指针，length表
示队列的长度。
define maxqstze 100
typedef struct {
QElemType *base; /*循环队列的存储空间首地址*／
int rear; ／*队尾元素索引*／
int length; ／*队列的长度*／
) SqQueue;
例如，容量为8的循环队列如图3-1所示，初始时创建的空队列如图3一l(a)所示
经过一系列的入队、出队操作后，队列的状态如图3-1 (b)所示(队列长度为3)。
下面的C函数1、C函数2和C函数3用于实现队列的创建、插入和删除操作，请
完善这些代码。
【C函数1】创建一个空的循环队列。
int initQueue (SqQueue *Q)
／*创建容量为MAXQSIZE的空队列，若成功则返回1；否则返回0*／
{ Q-＞base = (QElemType*) malloc(MAXQSIZE* (1) )
if (!Q=＞base) return 0;。；
Q-＞length=O；
Q-’rear =O：
Return 1;
} /*InitQueue*/
【c函数2】元素插入循环队列。
int EnQueue(sqQueue *Q. QElemType e）／*元素e入队，若成功则返回1；否则返回0*/
{if ( Q-＞length＞=MAXQSIZE) return 0.;
Q-＞rear=(2)；
Q-＞base [Q-＞rear]=e;
(3) ;
Return 1
) /*EnQUeue*/
【c函数3】元素出循环队列。
int DeQueue (SqQueue *Q. QElemType *e)
／*若队列不空，则删除队头元素，由参数e带回其值并返回1；否则返回O*／
{1f‘(4)，return 0；
*e =O-＞base[ (Q=＞rear - Q-＞length+I+MAXQSTZE) %MAXQSIZE]
(5) ；
returnl；
} /*DeQueue*/
正确答案：
分析本题考查数据结构实现和C语言基本应用。队列是一种基本的数据结构，其基本操作有初始化、判断是否为空、八队列和出队列等。循环队列是一种采用顺序存储结构实现的队列，其特点是将队列存储空间的首尾单元在逻辑上连接起来，从而得到一个环形结构的队列空间。在循环队列的类型定义SqQueue中，指针成员base存放队列空间的首地址，存储空间应在队列的初始化操作中实现，对应的语句如下：Q-＞base=(QElemType*)malloc(MAXQSIZE*(1)),由于InitQueue(SqQueue*Q)的形参为指向结构体的指针，因此队列的参数可表示为“Q-＞base、Q-＞rear、Q-＞lengrh”或“(*Q).base、(*Q).rear、(*Q).length”，由于队列元素类型为QElemType、队列容量为MAXQSIZE，因此空(l)处应填入“sizeof(QElemType)”。入队列操作由EnQueue(SqQueue*Q，QElemTypee)实现。由于循环队列空间的容量为MAXQSIZE(也就是队满条件为“Q-＞length>=MAXQSLZE”），因此元素入队列时，需先判断是否队满，在队列中有空闲单元的情况下才能进行入队列操作。其次需确定新元素在队列空间中的位置，从图3—1(b)中可以看出，Q-＞rear指出了当前队尾元素，新元素应放入下一个位置，结合队列环形空间的要求，空(2)处应填入“(Q-＞rear+I)%。MAXQSIZE”或其等价形式。通过“Q-＞base[Q-＞rear]=e”将元素加入队列后，队列长度增加了，因此空(3)处应填入“Q-＞length++”或其等价形式。出队列操作由DeQueue(SqQueue*Q，QElemType*e)实现。元素出队列时，需要判断队列是否为空，显然，队列长度为0就直接表示了队空，因此空(4)处应填入“Q-＞length=0”或其等价形式，空(5)处应填入“Q-＞length--”或其等价形式。试题三参考答案(1)sizeoftQElemtype)(2)(Q-＞rear+1)%MAXQSIZE或等价表示(3)Q-＞length++或Q-＞length=Q-＞length+l或等价表示(4)Q-＞length=0或Q-＞length=0或等价表示(5)Q-＞length-，或Q-＞length=Q-＞length-1或等价表示 -
第6题：
设某循环队列Q的定义中有front和rear两个域变量，其中，front指示队头元素的位置，rear指示队尾元素之后的位置，如下图所示。若该队列的容量为M，则其长度为（57）。
A.（Q.rear-Q.front+1）
B.（Q.rear-Q.front+M）
C.（Q.rear-Q.front+1）%M
D.（Q.rear-Q.front+M）%M答案：D解析：本题考查数据结构基础知识。根据题目中所给的示意图，Q.front为队头元素的指针，Q.rear表示队尾元素之后的一个空位置，故队列长度为Q.rear-Q.front，由于队列中存储位置编号是在0～M－1之间循环的，Q.rear-Q.front的结果有可能是负数，故在Q.rear-Q.front基础上加上M可恢复为正数，而此正数有可能超出0～M－1的范围，故用整除，M取余运算恢复一下，因此长度计算的式子为(Q.rear-Q.front+M)%M。 -
第7题：
循环队列sq中，用数组elem存放数据元素，sq．front指示队头元素的前一个位置，sq．rear指示队尾元素的当前位置，队列的最大容量为MAXSIZE，则在队列未满时元素x入队列的主要操作为（）。
- A、sq．rear= （sq．rear+1）mod MAXSIZE； sq．elem[sq．rear]=x；
- B、sq．elem[sq．rear]=x； sq．rear= （sq．rear+1）mod MAXSIZE；
- C、sq．front= （sq．front+1）mod MAXSIZE； sq．elem[sq．front]=x；
- D、sq．elem[sq．front]=x； sq．front= sq．front+1；
正确答案:A -
第8题：
某循环队列的容量MAXSIZE=6，队头指针front=3，队尾指针rear=0，则该队列有（）个元素。
正确答案:3 -
第9题：
循环队列的最大存储空间为MaxSize=6，采用少用一个元素空间以有效地判断栈空或栈满，若队头指针front=4，当队尾指针rear=（）时队满，队列中共有（）个元素。
正确答案:3；5 -
第10题：
循环队列的队头和队尾指针分别为front和rear，则判断循环队列为空的条件是（）。
- A、front==rear
- B、front==0
- C、rear==0
- D、front=rear+1
正确答案:A -
第11题：
填空题某循环队列的容量MAXSIZE=6，队头指针front=3，队尾指针rear=0，则该队列有（）个元素。正确答案： 3解析： 暂无解析 -
第12题：
单选题在数组表示的循环队列中，front、rear分别为队列的头、尾指针，maxSize为数组的最大长度，队满的条件是（）Afront=maxSize
B（rear+1）%maxSize=front
Crear=maxSize
Drear=front
正确答案： A解析： 暂无解析 -
第13题：
阅读下列函数说明和C函数，将应填入(n)处的字句写在对应栏内。
[说明]
循环队列的类型定义如下(其中队列元素的数据类型为datatype)：
typedef struct{
datatype data[MAXSIZE]; /*数据的存储区*/
int front,rear; /*队首、队尾指针*/
int num; /*队列中元素的个数*/
}c _ SeQueue; /*循环队*/
下面函数及其功能说明如下：
(1) c_SeQueue* Init_SeQueue()：新建队列；
(2) int ln_SeQueue( c_SeQueue *q, datatype x)：将元素x插入队列q，若成功返回1否则返回0；
(3) int Out_SeQueue (c_SeQueue *q, datatype *x)：取出队列q队首位置的元素，若成功返回1否则返回0。
[函数]
c_SeQueue* Init_SeQueue()
{ q=malloc(sizeof(c_SeQueue));
q-＞front=q-＞rear=MAXSIZE-1;
(1);
return q;
}
int In_SeQueue( c_SeQueue *q, datatype x)
{ if(q-＞num= =MAXSIZE) return 0; /*队满不能入队*/
else {
q-＞rear=(2);
q-＞data[q-＞rear]=x;
(3);
return 1; /*入队完成*/
}
}
int Out_SeQueue( c_SeQueue *q, datatype *x)
{ if (q-＞num= =0) return 0; /*队空不能出队*/
else{
*x=(4); /*读出队首元素*/
q-＞front=(5);
q-＞num- -;
return 1; /*出队完成*/
}
}
正确答案：(1) q-＞num=0 (2) (q-＞rear+1) % MAXSIZE (3) q-＞num++ (4) q-＞data[q-＞front] (5) (q-＞front+1)%MAXSIZE
(1) q-＞num=0 (2) (q-＞rear+1) % MAXSIZE (3) q-＞num++ (4) q-＞data[q-＞front] (5) (q-＞front+1)%MAXSIZE 解析：(1)新建的队列中元素个数应为0；
(2)向循环队列中添加新元素后，队尾指针应向后移动一位；
(3)向循环队列中添加新元素后，队列中元素个数应增1；
(4)取出队首位置的元素；
(5)从循环队列中取出一个元素后，队首指针应向后移动一位。 -
第14题：
设数组data[O…m]作为循环队列sq的存储空间，front为队头指针，rear为队尾指针，则执行出队操作的语句为
A．sq↑．front：=sq↑．front+1；
B．sq↑．front：=(sq↑．front+1)%maxsize；
C．sq↑．rear：=(sq↑．rear+1)%maxsize；
D．sq↑．front：=(sq↑．front+1)%(maxsize+1)；
正确答案：B
解析：循环队列采用的方法是：假设向量sq↑．data[maxsize]是一个首尾相接的圆环，即sq↑．data[0]接在sq↑．data[maxsize-1]之后，我们将这种意义下的向量称循环向量，并将循环向量中的队列称为循环队列。若当前尾指针等于向量的上界，则再做人队列操作时，令尾指针等于向量的下界，这样就利用到已被删除的元素空间，克服假上溢现象。因此入队操作时，在循环意义下的尾指针加1操作可描述为：if(sq↑． rear＞=maxsize)sq↑．near：=0；else sq↑．rear++；如果利用“模运算”，上述循环意义下的尾指针加1操作，可以更简洁地描述为：sq↑．rear=(sq↑．rear+1)% maxsize。同样，出队操作时，在循环意义下的头指针加1操作，也可利用“模运算”来实现：sq↑． front：=(sp↑．front+1)% maxsize。 -
第15题：
某循环队列的容量为M，队头指针指向队头元素，队尾指针指向队尾元素之后，如下图所示(M＝8)，则队列中的元素数目为(41)(MOD表示整除取余运算)。
A．rear-front
B．front-rear
C．(rear-front+M)MODM
D．(front-rear+M)MOD M
正确答案：C
解析：本题考查数据结构中队列的础知识。队列是仅在表头删除元素、在表尾插入元素的操作受限的线性表，其特点是先入先出。应用中可以将队列看作容器。队列采用顺序存储结构(一维数组，顺序队列)时，为了降低运算的复杂度，元素入队时，只需修改队尾指针rear，(rear+1→rear)；元素出队时，只需修改队头指针front(front+1→front)。由于顺序队列的存储空间是提前设定的，所以队尾指针会有一个上限值，当队尾指针达到其上限时，就不能只通过修改队尾指针来实现新元素的入队操作了。此时，可将顺序队列假想成一个环状结构，称为循环队列。队列容量为M时，队头指针front和队尾指针rear的值循环地在0～M-1之间变化，当rear＞front时，队列中元素数目为rear-front；当rearfront时，队列中元素数目为rear-front +M。综上，队列中元素数目为(rear-front+M)MOD M。 -
第16题：
设循环队列的结构是： const int MaxSize=100； typedef int Data Type； typedef struct { DataType data[MaxSize]； int front, rear； }Queue； 若有一个Queue类型的队列Q，试问判断队列满的条件应是(33)。
A．Q.front＝Q.rear；
B．Q.front-Q.rear==MaxSize；
C．Q.front+Q.rear＝MaxSize；
D．Q.front==(Q.rear+1)%MaxSize；
正确答案：D
解析：循环队列尾指针加1用循环区长度取模后等于头指针则表示队列满。 -
第17题：
试题四（共 15 分）阅读以下说明和 C 函数，填补函数中的空缺，将解答填入答题纸的对应栏内。【说明】简单队列是符合先进先出规则的数据结构，下面用不含有头结点的单向循环链表表示简单队列。函数 enqueue（queue *q，KeyType new_elem） 的功能是将元素new_elem 加入队尾。函数 Dnqueue（queue *q，KeyType *elem）的功能使将非空队列的队头元素出队（从队列中删除），并通过参数带回刚出队的元素。用单向循环链表表示的队列如图 4-1 所示。
图 4-1 单向循环链表表示的队列示意图队列及链表结点等相关类型定义如下:enum {errOr， OK};typedef int KeyType;typedef struct qNode﹛KeyType data;Struct qNode*next;﹜qNode，*Linkqueue; Typedef struct﹛int size;Link:queue rear;}queue; 【C 函数】int enqueue（queue*q,KeyType new_elem）﹛ ／／元素 new_elem 入队列qNode*p;P=（qNode*）malloc（sizeof（qNode））;if（!p）return errOr;P->data=new_elem;if（q->rear）﹛P->next=q->rear->next;（）;﹜elseP->next=p;﹙﹚;q->size++;return OK;﹜ int Dequeue（queue*q,KeyType*elem）﹛ ／／出队列qNode*p;if（0＝＝q->size） ／／是空队列return errOr；P=（）; ／／令 p 指向队头元素结点*elem =p->data;q->rear->next=（）; ／／将队列元素结点从链表中去除if（（）） ／／被删除的队头结点是队列中唯一结点q->rear=NULL ／／变成空队列free（p）;q->size--;return OK;﹜答案：解析：（1）Q→rear→next=p（2）Q→rear=p（3）Q→rear→next（4）p→next（5）Q→rear==p 或 Q→rear→next==p→next 或 Q→size==1
【解析】
本题考察C语言指针与链表的知识，为入队列和删除队列问题。对于入队列，那么当队列Q不为空时，P的队尾t要指向原Q的队尾指向的元素，即：P->next=Q->rear->next，Q的队尾要指向p，即：Q→rear→next=p。当队列Q为空时，插入p元素，则p的队尾指向p自身，即：p→next=p，且整个队列Q的队尾也是p，即：Q→rear=p。对于队列删除元素p，先判断Q是否为空，为空队列则返回 ERROR;If(0＝＝q->size) //是空队列Return ERROR；另p指向队头元素结点，队头元素结点可用Q→rear→next表示。此时，p转化为头结点，p出列，则需要Q的队尾指向p的下一个元素，因此第4空填：p→next。最后，判断被删除的队头结点是否是队列中的唯一结点，可采用：Q→rear==p 或 Q→rear→next==p→next 或 Q→size==1 等表示方法。 -
第18题：
在数组表示的循环队列中，front、rear分别为队列的头、尾指针，maxSize为数组的最大长度，队满的条件是（）
- A、front=maxSize
- B、（rear+1）%maxSize=front
- C、rear=maxSize
- D、rear=front
正确答案:B -
第19题：
在循环队列中用数组A[0..m-1]存放队列元素，其队头和队尾指针分别为front和rear，则当前队列中的元素个数是（）
- A、（front-rear+1）%m
- B、（rear-front+1）%m
- C、（front-rear+m）%m
- D、（rear-front+m）%m
正确答案:D -
第20题：
循环队列sq中，用数组elem存放数据元素，sq．front指示队头元素的前一个位置，sq．rear指示队尾元素的当前位置，队列的最大容量为MAXSIZE，则队列满的条件为（）。
- A、sq．front= sq．rear
- B、sq．front= sq．rear+1
- C、（sq．front +1）mod MAXSIZE= sq．rear
- D、（sq．rear+1）mod MAXSIZE= sq．front
正确答案:D -
第21题：
循环队列的最大存储空间为MaxSize=8，采用少用一个元素空间以有效的判断栈空或栈满，若队头指针front=4，则当队尾指针rear=（）时，队列为空，当rear=（）时，队列有6个元素。
正确答案:4；2 -
第22题：
填空题循环队列的最大存储空间为MaxSize=8，采用少用一个元素空间以有效的判断栈空或栈满，若队头指针front=4，则当队尾指针rear=（）时，队列为空，当rear=（）时，队列有6个元素。正确答案： 4,2解析： 暂无解析 -
第23题：
单选题循环队列sq中，用数组elem存放数据元素，sq．front指示队头元素的前一个位置，sq．rear指示队尾元素的当前位置，队列的最大容量为MAXSIZE，则队列满的条件为（）。Asq．front= sq．rear
Bsq．front= sq．rear+1
C（sq．front +1）mod MAXSIZE= sq．rear
D（sq．rear+1）mod MAXSIZE= sq．front
正确答案： B解析： 暂无解析 -
第24题：
单选题循环队列sq中，用数组elem存放数据元素，sq．front指示队头元素的前一个位置，sq．rear指示队尾元素的当前位置，队列的最大容量为MAXSIZE，则在队列未满时元素x入队列的主要操作为（）。Asq．rear= （sq．rear+1）mod MAXSIZE； sq．elem[sq．rear]=x；
Bsq．elem[sq．rear]=x； sq．rear= （sq．rear+1）mod MAXSIZE；
Csq．front= （sq．front+1）mod MAXSIZE； sq．elem[sq．front]=x；
Dsq．elem[sq．front]=x； sq．front= sq．front+1；
正确答案： B解析： 暂无解析