已知带头结点的链队列指针Q，则该队列做新元素结点s进队操作的语句是（）A．Q-＞rear-＞next=s; Q-＞rear=s;B．s-＞next=Q-＞front-＞next; Q-＞front-＞next=s;C．Q-＞next=s;Q=s;D．s-＞next=Q-＞next ;Q-＞next=s;

在一个链队中，设f和r分别为队头和队尾指针，则插入s所指结点的操作为

______和r=s;(结点的指针域为next)。

A、front->next

B、rear->next

C、front==rear

D、front!=rear

此题为判断题。

判定“带头结点的链队列为空”的条件是(56)。

A．Q.front==NULL

B．Q.rear==NULL

C．Q.front==Q.rear

D．Q.front!=Q.rear

在一个链队列中，若f，r分别为队首、队尾指针，则插入s所指结点的操作为( )

A．f—＞next=c;f=s;

B．r—＞next=s;r=s;

C．s—＞next=r;r= s

D．s—＞next=f,f=s;

A.r=r->next

B.r->next=r

C.f=f->next

D.f->next=f

A、rear=front->next

B、rear=rear->next

C、front=front->next

D、front=rear->next

在一个有头结点的链队列中，假设f和r分别为队首和队尾指针，则插入s所指的结点的运算是()。

A.f->next=s;f=s;

B.r->next=s;r=s;

C.s->next=r;r=s;

D.s->next=f;f=s;

阅读下列函数说明和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;

}

}