数据结构链表自测题——2014-5-5

一元稀疏多项式以循环单链表按降幂排列，结点有三个域，系数域coef ，指数域exp和指针域next；现对链表求一阶导数，链表的头指针为ha，头结点的exp域为–1。
derivative(ha)
{ q=ha ; pa=ha->next;
while(（ （1） ）)
{ if ( （2）) { ( （3）); free(pa); pa= ( （4） ); }
else{ pa->coef ( （5） ); pa->exp( （6）); q=( （7） );}
pa=(（ （8） ）);
}
}
a. pa!=ha
b. pa->exp==0
c. pa->next
d. q->next=pa->next
e. --
f. q->next
g. =pa->coef*pa->exp
h. pa
将以上选项进行排序填入到“（）”中，以下选项正确的是（ ）。

• A. b a d c e g h f
• B. a b d f g e h c
• C. a b d c e g h f
• D. b a d f g e h c

L1与L2分别为两单链表头结点地址指针，且两表中数据结点的数据域均为一个字母。完成把L1中与L2中数据相同的连续结点顺序完全倒置的算法。
LinkedList PatternInvert（LinkedList L1，L2）
{ p=L1；
q=L1->next；
s=L2->next；
while（_____(1)__________）
if（q->data==s->data）{q=q->next;s=s->next;}
else {________(2)__________}
if（s==Null）
{ (3)__________
while（r!=q）；
{
s=r->next；
r->next=p->next；
p->next=r；
r=s；
}
}
else printf（“L2并未在L1中出现”）；
}
下列选项正确的是：（ ）。

• A. （1）为p!=Null && s!=Null
• B. （2）为p=p->next；q=p->next；
• C. （3）为r=p->next；p->next=q；s=L2->next；
• D. 以上说法都不对

请阅读下面的代码。此代码将一维数组space中各分量链成一个备用链表，space[0].cur 为头指针，“0”表示空指针。若备用空间链表非空，则返回分配的结点下标，否则返回0。
int Malloc_SL(SLinkList &space)
{
i=space[0].cur;
if(space[0].cur)_____________________
return i;
}//Malloc_SL
为保证代码正确运行，代码中下划线处的语句应是（ ）。

• A. space[i].cur=space[0].cur;
• B. space[0]=space[i];
• C. space[0].cur=space[i].cur;
• D. space[0].cur=space[i+1].cur;

已知f为单链表的表头指针，链表中存储的都是整型数据，链表的定义如下：
typedef struct LNode{
int data;
struct LNode *next;
}LNode,*LinkList;
下面函数的功能是递归求得链表中节点的总数：
1: int GetNumber(LinkList p){
2: if(!p->next)
3: return 1;
4: else
5: --请补充--;
6: }
则第5行应补充的代码是（ ）。

• A. return GetNumber(p->next)
• B. return 1+GetNumber(p->next)
• C. return GetNumber(p)
• D. 以上选项都不正确

给定(已生成)一个带表头结点的单链表，设head为头指针，结点的结构为(data,next),data为整型元素，next为指针，试完成算法:按递增次序输出单链表中各结点的数据元素，并释放结点所占的存储空间。
void MiniDelete（LinkedList head）
{
while（______（1）_______）
{
pre=head；
p=pre->next；
while（p->next!=Null）
{
if（______(2)_________）pre=p；
p=p->next；
}
printf（pre->next->data）；
u=pre->next；pre->next=u->next; free（u）；
}
free（head）；
}
下列选项正确的是：（ ）。

• A. （1）为p!=Null
• B. （2）为p->next->data>pre->next->data
• C. A和B都对
• D. A和B都不对

在一个递增有序的线性表中，有数值相同的元素存在。若存储方式为单链表，完成算法去掉数值相同的元素，使表中不再有重复的元素。例如：（7，10，10，21，30，42，42，42，51，70）将变作（7，10，21，30，42，51，70）。
LinkedList DelSame（LinkedList la）
{pre=la->next；
p=pre->next；
while（_____（1）_______）
if（p->data==pre->data）
{u=p；p=p->next；free（u）；}
else {________（2）________________ }
______（3）______________
}

下列选项正确的是：（ ）。

• A. （1）为p->next!=Null
• B. （2）为pre->next=p；pre=p；p=p->next；
• C. （3）为p=p->next；；
• D. 以上说法都不对

设 Listhead为一单链表的头指针，单链表的每个结点由一个整数域DATA和指针域NEXT组成，整数在单链表中是无序的。完成PASCAL过程，将 Listhead链中结点分成一个奇数链和一个偶数链，分别由P,Q指向，每个链中的数据按由小到大排列。程序中不得使用 NEW过程申请空间。
PROC discreat(VAR listhead,P,Q:linkedlist)
P:=NIL;Q:=NIL;
s:=listhead;
WHILE(s<>NIL)DO
[r:=s.NEXT;
IF s.DATA DIV 2=0
THEN IF P=NIL THEN[___（1）____________]
ELSE[pre:=P;
IF pre.DATA>s.DATA THEN[s.NEXT:=pre;P:=s;
ELSE[WHILE pre.NEXT<>NIL DO
IF pre.NEXT.DATA s.NEXT:=pre.NEXT;
pre.NEXT:=s;
]
]
ELSE
IF Q=NIL THEN[Q:=s;Q.NEXT:=NIL;]
ELSE[pre:=Q;
IF pre.DATA>s.DATA THEN[s.NEXT:=pre; Q:=s; ]
ELSE[WHILE pre^.NEXT<>NIL DO
IF _____（2）_______________THEN pre:=pre.NEXT;
s.NEXT:=pre.NEXT;
pre.NEXT:=s;
]
]
s:=r;
]
ENDP；

下列选项正确的是：（ ）。

• A. （1）为P:=s;P.NEXT:=NIL;
• B. （2）为pre.NEXT.DATA>s.DATA
• C. A和B都对
• D. A和B都不对

一个无头结点的线性链表(不循环)有两个域。数据域data，指针域 next，链首head，下面算法用read(num)读入数据，当num小于0时，输入结束。建立一个升序的链表。
PROC insert( head, x);
{在链首为head的表中按递增序插入x}
new(r);r.data:=x;
IF head=NIL
THEN[ head:=（1） ; r.next:= （2）（ ） ]
ELSE IF （3） THEN [r .next:=head; head:=r]
ELSE [p:=head;
WHILE （4） AND (p.next≠NIL ) DO[q:=p; （5） ];
IF （6） THEN [ q .next:=（7）; r.next:= （8）; ]
ELSE [p.next:=（9）; r.next:= （10）; ]
]
ENDP;
PROC creat(head);
head:= (11); read(num);
WHILE num>0 DO
[ insert(head,num); read(num) ]
ENDP;
a.r
b. p:=p^.next
c. NIL
d. p
e. x f. p^.data g. NIL
h. r
i. NIL
j. r
k. p^.data>=x;
将以上选项进行排序填入到“（）”中，以下选项正确的是（ ）。

• A. d c e f b k j a h g i
• B. d c e k b f j a h g i
• C. a c e f b k j d h g i
• D. a c e k b f j d h g i

对于给定的线性链表head，下面的程序过程实现了按结点值非降次序输出链表中的所有结点，在每次输出一个结点时，就把刚输出的结点从链表中删去。请在划线处填上适当的内容，使之成为一个完整的程序过程，每个空框只填一个语句。
TYPE nodeptr =^ nodetype；
nodetype = RECORD
data : integer；link : nodeptr
END;
VAR head : nodeptr；
PROCEDURE sort_output_delete (head : nodeptr);
VAR p,q,r,s: nodeptr;
BEGIN WHILE head <> NIL DO
BEGIN p:= NIL ；q:= head；r:= q ；s:=q^.link ；
WHILE s <> NIL DO
BEGIN IF s^.data < q^.data THEN BEGIN （1）; （2）END ；
r:= s ； （3）
END；
write(q^.data : 5) ；
IF p=NIL THEN （4） ELSE （5） ；
dispose (q) ；
END；
writeln
END；
a. p:=r;
b. p^link:=q^.link;
c. q:=s;
d. s:=s^.link
e. head:=head^.next;
f. s:=q.link
将以上选项进行排序填入到“（）”中，以下选项正确的是（ ）。

• A. a c d b e
• B. b c f a e
• C. b c f e a
• D. a c d e b

完成算法来交换单链表中指针P所指结点与其后继结点，HEAD是该链表的头指针，P指向该链表中某一结点。

LinkedList Exchange（LinkedList HEAD，p）
{
q=head->next;
pre=head;
while（______(1)________）{pre=q;q=q->next;}
if（p->next==Null）printf（“p无后继结点\n”）;
else
{
______(2)_____
}
}
下列选项正确的是：（ ）。

• A. （1）为q->next!=Null && q!=p
• B. （2）为q=p->next; pre->next=q; p->next=q->next;q->next=p;
• C. A和B都对
• D. A和B都不对

综合评价

• 本次测评题目总数10 。正确1 道，错误9 道，正确率10 %。 超过了49.10 %的用户。需要继续努力了。
• 本次测评用时22分18秒 ，答题速度超过了0 %的用户 。

知识点评价

• 考察知识点
• 题目总数
• 正确
• 错误
• 正确率

• 递归
• 1
• 0
• 1
• 0%

• 链表
• 10
• 1
• 9
• 10%