[单项选择]单向链表的每一个节点都有一个指向它的后续节点的指针link，现有节点P和q，要将q插入节点p的后面，正确的操作应该是
A. q↑.link: =p↑.link; p↑.link: =q;
B. q: =p↑.link; p↑.link:=q↑.link;
C. q↑.link: =p; p↑.link: =q;
D. q:=p↑.link; p:=q↑.link;

[单项选择]单向链表的每一个节点都有一个指向它的后续节点的指针link，现有节点p和q，节点q在节点p的前面，要删除节点p，正确的操作应该是
A. q↑．link：=p↑．link；
B. p↑．link：=q↑．link；
C. q↑．link：=p；p↑．link：=q；
D. q：=p↑．link；p↑．link：=q↑．link；

[单项选择]单向链表的每一个节点都有一个指向它的后续节点的指针link，现有节点p和q，要将q插入节点p的后面，正确的操作应该是
A. q↑．link：=p↑．link；p↑．link：=q；
B. q：=p↑．link；p↑．link：=q↑．link；
C. q↑．link：=p；p↑．link：=q；
D. q：=p↑．link；p：=q↑．link；

[单项选择]单向链表的每一个结点都有一个指向它的后续结点的指针link，现有结点p和q，结点q在结点p的前面，要删除结点P，正确的操作应该是（）
A. q↑.link：=p↑.link；
B. p↑.link：=q↑.link；
C. q↑.link：=p；p↑.link：=q；
D. q：=p↑.link；p↑.link：=q↑.link；

[单项选择]单向链表的每一个结点都有一个指向它的后继结点的指针link，现有结点p和q，结点q在结点p的前面，要删除结点p，正确的操作应该是( )。
A. q↑．link：=p↑．link；
B. p ↑．link：=q ↑．link；
C. q ↑．link：=p；p ↑．link：=q；
D. q：=q ↑．1ink；p ↑．link：=q ↑．link；

[填空题]以下函数creat用来建立一个带头结点的单向链表，新产生的结点是插在链表头的
末尾。单向链表的头指针作为函数值返回。请填空。
# include＜stdio．h＞
struct list
char data；
struct list * next；
；
struct list * creat；
struct list * h，* p，* q；
char ch；
h＝(______)malloc ( sizeof(struct list))；
p＝q＝h；
ch＝getchar（　）；
while(ch!＝’’)
p＝(______)mallco(sizeof(struct list))；
p-＞data＝ch；
q-＞next＝p；
q＝p；
ch＝getchar（　）；

p-＞next＝’/0’；
______；

[单项选择]与单向链表相比，双向链表（）
A. 需要较少的存储空间
B. 遍历元素需要的时间较短
C. 较易于访问相邻结点
D. 较易于插入和删除元素

[填空题]以下程序段用于构成一个简单的单向链表。请填空。
struet STRU
int x，y；
float rate；
【14】 p；
a，b；
a．x＝0; a.y＝0；a.rate＝0；a.p=&b；
b．x＝0；b.y=0；b.rate=0；b.p＝NULL；

[简答题]给定程序中,函数fun的功能是将不带头节点的单向链表结点数据域中的数据从小到大排序。即若原链表结点数据域从头至尾的数据为：10、4、2、8、6，排序后链表结点数据域从头至尾的数据为：2、4、6、8、10。 请在程序的下划线处填入正确的内容并把下划线删除, 使程序得出正确的结果。 注意：源程序存放在考生文件夹下的BLANK1.C中。不得增行或删行，也不得更改程序的结构！ 给定源程序： #include #include #define N 6 typedef struct node { int data; struct node *next; } NODE; void fun(NODE *h) { NODE *p, *q; int t; p = h; while (p) { q = __1__ ; while (__2__) { if (p->data > q->data) { t = p->data; p->data = q->data; q->data = t; } q = q->next; } p = __3__ ; } } NODE *creatlist(int a[]) { NODE *h,*p,*q; int i; h=NULL; for(i=0; idata=a[i]; q->next = NULL; if (h == NULL) h = p = q; else { p->next = q; p = q; } } return h; } void outlist(NODE *h) { NODE *p; p=h; if (p==NULL) printf("The list is NULL!/n"); else { printf("/nHead "); do { printf("->%d", p->data); p=p->next; } while(p!=NULL); printf("->End/n"); } } main（　） {

[简答题]已知一个单向链表结点的数据结构定义如下： struct node { char data; struct node *next; }; 函数struct node *cre (char *s)的功能是：根据s指向的字符串建立一个结点类型为struct node头指针为h的单向链表,使h链表中各结点的数据域分别存储s指向字符串中所有大写字母的编码,函数返回h链表首结点的地址．例如,若s指向的字符串为"3Aa26Bx5Y9",则h指向的链表如下图所示。 #include #include struct node { char data; struct node *next; }; struct node *cre(char *s) { struct node *p,*p1,*h; if (___(27)___) return NULL; h=p1=p=(struct node *)malloc(sizeof(struct node)) ; p->data=*s ; s++; while (*s) { if(*s>=’A’ && *s<=’Z’) { p= (struct node *) malloc (sizeof (struct node)) ; p->data=*s ; ___(28)____ = p; p1=p ; } s++; } ___ (29)___ =NULL; ___(30)___; } void print(struct node *h) { struct node *p=h; while (p!=NULL) { printf ("%3c", p->d

[简答题]

下列给定程序是建立一个带头结点的单向链表，并用随机函数为各结点赋值。函数fun（　）的功能是：将单向链表结点(不包括头结点)数据域为偶数的值累加起来，并作为函数值返回。
其累加和通过函数值返回main（　）函数。例如，若n=5，则应输出8.391667。
请改正程序中的错误，使它能得到正确结果。
[注意] 不要改动main函数，不得增行或删行，也不得更改程序的结构。
[试题源程序]
#include＜stdio.h＞
#include＜stdiib.h＞
typedef struct aa

int data;
struct aa *next;
NODE;
int fun(NODE *h)

int sum=0;
NODE *P;
/**********found**********/
p=h;
while(P-＞next)

if(p-＞data%2==0)
sum+=p-＞data;
/**********found**********/
p=h-＞next;

return sum;

NODE *creatlink(int n)

NODE *h, *p, *s, *q；
int i, x;
h=p=(NODE *)malloc(si zeof(NODE));
for(i=1; i＜=n; i++)

s=(NODE *)malloc(sizeof(NODE));
s-＞data=rand（　）%16;
s-＞next=p-＞next;
p-＞next=s;
p=p->next;

p-＞next=NULL;
return h;

outlink(NODE *h, FILE *Pf)

[填空题]以下程序建立一个带有头结点的单向链表，链表结点中的数据通过键盘输入，当输入数据为-1时，表示输入结束(键表头结点的data域不放数据，表空的条件是ph-＞next==NULL)，请填空。
#include＜stdio.h＞
struct list int data；struct list*next；；
struct list*creatlist（　）
struct list*p，*q，*ph；int a；ph=(struct list*)malloc(sizeof(struct list))；
p=q=ph；printf("Input an integer number；entre-1 to end：/n")；
scanf("%d"，&a)；
while(a!=-1)
p=(struct list*)malloc(sizeof(struct list))；
【19】 =a；q-＞next=p； 【20】 =p；scanf("%d"，&a)；
p-＞next=’/0’；return(ph)；
main（　）
struct list * head；head=creatlist（　）；

[单项选择]单向链表中往往含有一个头结点，该结点不存储数据元素，一般令链表的头指针指向该结点，而该结点指针域的值为第一个元素结点的指针。以下关于单链表头结点的叙述中，错误的是（）。
A. 若在头结点中存入链表长度值，则求链表长度运算的时间复杂度为O(1)
B. 在链表的任何一个元素前后进行插入和删除操作可用一致的方式进行处理
C. 加入头结点后，代表链表的头指针不因为链表为空而改变
D. 加入头结点后，在链表中进行查找运算的时间复杂度为O(1)

[单项选择]

以下程序的功能是：建立一个带有头结点的单向链表，并将存储在数组中的字符依次转储到链表的各个结点中，请从与下划线处号码对应的一组选若中选择出正确的选项。#include
stuct node{ char data; struct node *next;}; (1） CreatLis(char *s){
struct node *h,*p,*q); h=(struct node *）malloc(sizeof(struct node));
p=q=h; while(*s!=’/0’) { p=(struct node
*）malloc(sizeof(struct node));   p->data= (2） ; 
q->next=p;   q= (3） ;   s++; }
p->next=’/0’; return h;}main（　）{ char str[]="link list";
struct node *head; head=CreatLis(str); ...}

1（）
A. char *
B. struct node
C. struct node*
D. char

[单项选择]以下程序的功能是：建立一个带有头结点的单向链表，并将存储在数组中的字符依次转存到链表的各个结点中，请为下划线处选择正确的选项。（）
#include ＜ stdlib. h ＞
stuct node
char data; struct node * next; ;
( ) CreatList(char * s)
struet node * h, * p, * q;
h = (struet node * ) ma]loc(sizeof(struct node) );
p=q=h;
while( * s! ='/0')
p = ( struct node * ) ma]loc ( sizeof( struct node) );
p- ＞data= *s; q- ＞next=p; q=p;
s++;

p- ＞ next ='/0';
return h
main( )
char str[ ] = "link list";
struet node * head;
head = CreatList (str);
A. char *
B. struet node
C. struct node *
D. char

[填空题]已知h1和h2为两个单向链表的头指针,h1指向的链表不为空链表。add函数的功能是将h2指向的链表(简称h2链表)中全部结点插入到h1指向的链表(简称h1链表)中第n个结点(n>0)之后,如果h2链表为空链表,则函数直接返回h1链表首结点的地址。如果h1链表中不存在第n个结点,则将h2链表中全部结点添加到h1链表的末尾,函数返回h1链表首结点地址.链表结点采用如下形式的数据结构: struct node { int data; struct node *next; }; #include struct node *add(struct node *h1,struct node *h2,int n) {struct node *p1=h1,*q=h2,*p2; int i=0; if(h2==___(27)___) return h1; p2=h1; while(p1&&inext; ___(28)___; } if(inext=q; else { ___(29)___=q; while(q->next) q=q->next; q->next=___(30)___; } return h1; }

[简答题]下列给定程序中，是建立一个带头结点的单向链表，并用随机函数为各结点数据域赋值。函数fun的作用是求出单向链表结点(不包括头结点)数据域中的最大值，并且作为函数值返回。
请改正程序指定部位的错误，使它能得到正确结果。
[注意] 不要改动main函数，不得增行或删行，也不得更改程序的结构。
[试题源程序]
#include＜stdio.h＞
#include＜stdlib.h＞
typedef struct aa

int data;
struct aa *next;
NODE;
fun(NODE *h)

int max=-1;
NODE *p;
/***********found************/
p=h;
while(p)

if(p-＞data＞max)
max=p-＞data;
/************found************/
p=h-＞next;

return max;

outresult(int s, FILE *Pf)

fprintf(pf, "/nThe max in link: %d/n", s);

NODE *creatlink(int n, int m)

NODE *h, *p, *s, *q;
int i, x;
h=p=(NODE *)malloc(sizeof(NODE));
h-＞data=9999;
for(i=1; i＜=n; i++)

s=(NODE *)malloc(sizeof(NODE));
s-＞data=rand（　）%m; s-＞next=p-＞next;
p-＞next=s; p=p-＞next;

p-＞next=NULL;
return h;

outlink(NODE *h, FILE *pf)