程序中已构成如下图所示的不带头结点的单向链表结构，指针变量s、p、q均已正确定义，并用于指向链表结点，指针变量s总是作为头指针向链表的第—个结点。

若有以下程序段 q=s; s=s-＞next; p=s; while(p-＞next) p=p-＞next; P-＞next=q; q-＞next=NULL; 该程序段实现的功能是______。

A．首结点成为尾结点

B．尾结点成为首结点

C．删除首结点

D．删除尾结点

以下程序中，能够通过调用函数fun，使main函数中的指针变量p指向一个合法的整型单元的是

A．main( ) { int *p; fun(p); ┆ } int fun(int *p) { int s; p=&s;}

B．main( ) { int *p; fun(&p); ┆ } int fun(int **p) { int s; *p=&s;}

C．#include＜stdlib.h＞ main( ) { int *p; fun(&p); ┆ } int fun(int **p) { *p=(int*)malloc(2);}

D．#include＜stdlib.h＞ main( ) { int *p; fun(p); ┆ } int fun(int *p) { p=(int*)malloc(sizeof(int));}

设线性链表中结点的结构为(data，next)。已知指针q所指结点是指针结点p的直接前驱，若在*q与*p之间插入结点*s，则应执行下列()操作。

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

B.q->next=s;s->next=p;

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

D.p->next=s;s->next=q;

以下程序段中，能够通过调用函数fun()，使main()函数中的指针变量p指向一个合法的整型单元的是( )。

A．main() {int*p; fun(p); … } int fun(int*p) {int s; p=&s; }

B．main {int*p fun(&p); … } iht fun(int**p) {int s; *p=&s;}

C．main() {int*p; fun(&p); } int fun(int**p) {*p=(int*)malloc(2);}

D．main() {int*p; fun(p); } int fun(int*p) {p=(int*)malloc(sizeo(int));}

以下程序段中，能够通过调用函数fun，使main函数中的指针变量p指向一个合法的整型单元的是______。

A．main() { int *p; fun(p); …… } int fun(int *p) {int s; p=&s;}

B．main() { int *p; fun(&p); …… } int fun(int **p) {int s; *p=&s;}

C．# include＜stdlib. h＞ main() {int *p; fun(&p); …… } int fun(int **p) {*p=(int *)malloc(2);}

D．# include＜stdlib. h＞ main() { int *p; fun(p); …… } int fun(int *p) {p=(int *)malloc(sizeof(int));}

在一个单链表中，若q结点是p结点的前驱结点，若在q与p之间插入结点s，则执行( )。

A．s→link=p→dink； p→link=s

B．p→link=s； s→link=q

C．p→link=s→4ink； s→link=p

D．q→link=s； s→link=p

在一个单链表中，q结点是p结点的前驱结点，若在q与p之间插入结点s，则执行(29)。

A．s→link=p→link；p→link=s；

B．p→link=s；s→link=q；

C．p→link=s→link；s→link=p；

D．q→link=s；s→link=p；

以下程序中，能够通过调用函数fun，使main函数中的指针变量p指向一个合法的整型单元的是

A．main() { int *p; fun(p); … } int fun(int *p) { ints; p=&s;}

B．main() { int *p; fun(&p); … } int fun(int **p) { int s; *p=&s;)

C．#include main() { int *p; fun(&p); … } int fun(int **p) *p=(int*)malloc(2);}

D．#include main() { iht *p; fun(p); … } iht fun(iht *p) { p=(int*)malloc(sizeof(int)); }

以下程序段中，能够通过调用函数fun，使main函数中的指针变量p指向一个合法的整型单元的是

A．main() { int*p； fun(p)； … } int fun(int*p) {int s; p＝&s; }

B．main { int *p; fun(&p)； … } int fun(int**p) {int s; *p=&s; }

C．#include ＜stdlib.h＞ main() { int *p; fun(&p); … } int fun(int**p) {*p=(int*)malloc(2); }

D．#include ＜stdlib.h＞ main() { int *p; fun(p)； … } int fun(int *p) {p=(int*)malloc(sizeof(int))；}