计算机等级考试二级C语言程序设计专项训练题——单链表
一.程序填空题
1.给定程序的主函数中,已给出由结构体构成的链表结点a、b、c,各结点的数据域中均存入字符,函数fun的功能是:将a、b、c三个结点链接成一个单向链表,并输出链表结点中的数据。
请在下划线处填入正确的内容并将下划线删除,使程序得出正确的结果。
注意:不得增行或删行,也不得更改程序的结构!
#include <stdio.h>
typedef struct list
{
char data;
struct list *next;
}Q;
void fun(Q *pa, Q *pb, Q *pc)
{
Q *p;
/**********found**********/
pa->next=___1___;
pb->next=pc;
p=pa;
while( p )
{
/**********found**********/
printf(" %c",____2_____);
/**********found**********/
p=____3____;
}
printf("\n");
}
int main()
{
Q a, b, c;
a.data='E'; b.data='F'; c.data='G'; c.next=NULL;
fun( &a, &b, &c );
return 0;
}
2.给定程序中,函数fun的功能是:统计出带有头结点的单向链表中结点的个数,存放在形参n所指的存储单元中。
请在下划线处填入正确的内容并将下划线删除,使程序得出正确的结果。
注意:不得增行或删行,也不得更改程序的结构!
#include <stdio.h>
#include <stdlib.h>
#define N 8
typedef struct list
{
int data;
struct list *next;
} SLIST;
SLIST *creatlist(int *a);
void outlist(SLIST *);
void fun( SLIST *h, int *n)
{
SLIST *p;
/**********found**********/
___1___=0;
p=h->next;
while(p)
{
(*n)++;
/**********found**********/
p=p->___2___;
}
}
int main()
{
SLIST *head;
int a[N]={12,87,45,32,91,16,20,48}, num;
head=creatlist(a);
outlist(head);
/**********found**********/
fun(___3___, &num);
printf("\nnumber=%d\n",num);
return 0;
}
SLIST *creatlist(int a[])
{
SLIST *h,*p,*q;
int i;
h=p=(SLIST *)malloc(sizeof(SLIST));
for(i=0; i<N; i++)
{
q=(SLIST *)malloc(sizeof(SLIST));
q->data=a[i]; p->next=q; p=q;
}
p->next=0;
return h;
}
void outlist(SLIST *h)
{
SLIST *p;
p=h->next;
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");
}
}
3.给定程序中,函数fun的功能是:计算出带头结点的单向链表中各结点数据域之和作为函数值返回。
请在下划线处填入正确的内容并将下划线删除,使程序得出正确的结果。
注意:不得增行或删行,也不得更改程序的结构!
#include <stdio.h>
#include <stdlib.h>
#define N 8
typedef struct list
{
int data;
struct list *next;
} SLIST;
SLIST *creatlist(int *);
void outlist(SLIST *);
int fun(SLIST *h)
{
SLIST *p;
int s=0;
p=h->next;
while(p)
{
/**********found**********/
s+= p->___1___;
/**********found**********/
p=p->___2___;
}
return s;
}
int main()
{
SLIST *head;
int a[N]={12,87,45,32,91,16,20,48};
head=creatlist(a);
outlist(head);
/**********found**********/
printf("\nsum=%d\n", fun(___3___));
return 0;
}
SLIST *creatlist(int a[])
{
SLIST *h,*p,*q;
int i;
h=p=(SLIST *)malloc(sizeof(SLIST));
for(i=0; i<N; i++)
{
q=(SLIST *)malloc(sizeof(SLIST));
q->data=a[i]; p->next=q; p=q;
}
p->next=0;
return h;
}
void outlist(SLIST *h)
{
SLIST *p;
p=h->next;
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");
}
}
4.给定程序中已建立一个带有头结点的单向链表,链表中的各结点按数据域递增有序链接。函数fun的功能是:删除链表中数据域值相同的结点,使之只保留一个。
请在下划线处填入正确的内容并将下划线删除,使程序得出正确的结果。
注意:不得增行或删行,也不得更改程序的结构!
#include <stdio.h>
#include <stdlib.h>
#define N 8
typedef struct list
{
int data;
struct list *next;
} SLIST;
void fun(SLIST *h)
{
SLIST *p, *q;
p=h->next;
if (p!=NULL)
{
q=p->next;
while(q!=NULL)
{
if (p->data==q->data)
{
p->next=q->next;
/**********found**********/
free(___1___);
/**********found**********/
q=p->___2___;
}
else
{
p=q;
/**********found**********/
q=q->___3___;
}
}
}
}
SLIST *creatlist(int *a)
{
SLIST *h,*p,*q;
int i;
h=p=(SLIST *)malloc(sizeof(SLIST));
for(i=0; i<N; i++)
{
q=(SLIST *)malloc(sizeof(SLIST));
q->data=a[i]; p->next=q; p=q;
}
p->next=0;
return h;
}
void outlist(SLIST *h)
{
SLIST *p;
p=h->next;
if (p==NULL) printf("\nThe list is NULL!\n");
else
{
printf("\nHead");
do {
printf("->%d",p->data);
p=p->next;
} while(p!=NULL);
printf("->End\n");
}
}
int main( )
{
SLIST *head;
int a[N]={1,2,2,3,4,4,4,5};
head=creatlist(a);
printf("\nThe list before deleting :\n");
outlist(head);
fun(head);
printf("\nThe list after deleting :\n");
outlist(head);
return 0;
}
5.给定程序中,函数fun的功能是:在带头结点的单向链表中,查找数据域中值为ch的结点。找到后通过函数值返回该结点在链表中所处的顺序号;若不存在值为ch的结点,函数返回值为0。
请在下划线处填入正确的内容并将下划线删除,使程序得出正确的结果。
注意:不得增行或删行,也不得更改程序的结构!
#include <stdio.h>
#include <stdlib.h>
#define N 8
typedef struct list
{
int data;
struct list *next;
} SLIST;
SLIST *creatlist(char *);
void outlist(SLIST *);
int fun(SLIST *h, char ch)
{
SLIST *p;
int n=0;
p=h->next;
/**********found**********/
while(p!=___1___)
{
n++;
/**********found**********/
if (p->data==ch) return ___2___;
else p=p->next;
}
return 0;
}
int main()
{
SLIST *head;
int k;
char ch;
char a[N]={'m','p','g','a','w','x','r','d'};
head=creatlist(a);
outlist(head);
printf("Enter a letter:");
scanf("%c",&ch);
/**********found**********/
k=fun(___3___);
if (k==0) printf("\nNot found!\n");
else printf("The sequence number is : %d\n",k);
return 0;
}
SLIST *creatlist(char *a)
{
SLIST *h,*p,*q;
int i;
h=p=(SLIST *)malloc(sizeof(SLIST));
for(i=0; i<N; i++)
{
q=(SLIST *)malloc(sizeof(SLIST));
q->data=a[i]; p->next=q; p=q;
}
p->next=0;
return h;
}
void outlist(SLIST *h)
{
SLIST *p;
p=h->next;
if (p==NULL) printf("\nThe list is NULL!\n");
else
{
printf("\nHead");
do {
printf("->%c",p->data);
p=p->next;
} while(p!=NULL);
printf("->End\n");
}
}
6.给定程序中已建立一个带头结点的单向链表,在main函数中将多次调用函数fun,每调用一次fun函数,输出链表尾部结点中的数据,并释放该结点,使链表缩短。
请在下划线处填入正确的内容并将下划线删除,使程序得出正确的结果。
注意:不得增行或删行,也不得更改程序的结构!
#include <stdio.h>
#include <stdlib.h>
#define N 8
typedef struct list
{
int data;
struct list *next;
} SLIST;
void fun(SLIST *p)
{
SLIST *t, *s;
t=p->next;
s=p;
while(t->next != NULL)
{
s=t;
/**********found**********/
t=t->___1___;
}
/**********found**********/
printf(" %d ",___2___);
s->next=NULL;
/**********found**********/
free(___3___);
}
SLIST *creatlist(int *a)
{
SLIST *h,*p,*q;
int i;
h=p=(SLIST *)malloc(sizeof(SLIST));
for(i=0; i<N; i++)
{
q=(SLIST *)malloc(sizeof(SLIST));
q->data=a[i]; p->next=q; p=q;
}
p->next=0;
return h;
}
void outlist(SLIST *h)
{
SLIST *p;
p=h->next;
if (p==NULL) printf("\nThe list is NULL!\n");
else
{
printf("\nHead");
do {
printf("->%d",p->data);
p=p->next;
} while(p!=NULL);
printf("->End\n");
}
}
int main()
{
SLIST *head;
int a[N]={11,12,15,18,19,22,25,29};
head=creatlist(a);
printf("\nOutput from head:\n");
outlist(head);
printf("\nOutput from tail: \n");
while (head->next != NULL)
{
fun(head);
printf("\n\n");
printf("\nOutput from head again :\n");
outlist(head);
}
return 0;
}
7.给定程序中已建立一个带头结点的单向链表,链表中各结点按结点数据域中的数据从小到大顺序链接。函数fun的功能是:把形参x的值放入一个新结点并插入到链表中,插入后各结点仍保持从小到大顺序排列。
请在下划线处填入正确的内容并将下划线删除,使程序得出正确的结果。
注意:不得增行或删行,也不得更改程序的结构!
#include <stdio.h>
#include <stdlib.h>
#define N 8
typedef struct list
{
int data;
struct list *next;
} SLIST;
void fun(SLIST *h, int x)
{
SLIST *p, *q, *s;
s=(SLIST *)malloc(sizeof(SLIST));
/**********found**********/
s->data=___1___;
q=h;
p=h->next;
while(p!=NULL && x>p->data)
{
/**********found**********/
q=___2___;
p=p->next;
}
s->next=p;
/**********found**********/
q->next=___3___;
}
SLIST *creatlist(int *a)
{
SLIST *h,*p,*q;
int i;
h=p=(SLIST *)malloc(sizeof(SLIST));
for(i=0; i<N; i++)
{
q=(SLIST *)malloc(sizeof(SLIST));
q->data=a[i]; p->next=q; p=q;
}
p->next=0;
return h;
}
void outlist(SLIST *h)
{
SLIST *p;
p=h->next;
if (p==NULL) printf("\nThe list is NULL!\n");
else
{
printf("\nHead");
do {
printf("->%d",p->data);
p=p->next;
} while(p!=NULL);
printf("->End\n");
}
}
int main()
{
SLIST *head;
int x;
int a[N]={11,12,15,18,19,22,25,29};
head=creatlist(a);
printf("\nThe list before inserting:\n");
outlist(head);
printf("\nEnter a number : ");
scanf("%d",&x);
fun(head,x);
printf("\nThe list after inserting:\n");
outlist(head);
return 0;
}
8.给定程序中,函数fun的功能是:将带头结点的单链表逆置。
若原链表中从头至尾结点数据域依次为:2、4、6、8、10,逆置后,从头到尾结点数据域依次为:10、8、6、4、2。
请在下划线处填入正确的内容并将下划线删除,使程序得出正确的结果。
注意:不得增行或删行,也不得更改程序的结构!
#include <stdio.h>
#include <stdlib.h>
#define N 5
typedef struct node
{
int data;
struct node *next;
} NODE;
void fun(NODE *h)
{
NODE *p, *q, *r;
/**********found**********/
p = h->__1__;
/**********found**********/
if (p==__2__) return;
q = p->next;
p->next = NULL;
while (q)
{
r = q->next; q->next = p;
/**********found**********/
p = q; q = __3__;
}
h->next = p;
}
NODE *creatlist(int a[])
{
NODE *h,*p,*q;
int i;
h = (NODE *)malloc(sizeof(NODE));
h->next = NULL;
for(i=0; i<N; i++)
{
q=(NODE *)malloc(sizeof(NODE));
q->data=a[i];
q->next = NULL;
if (h->next == NULL) h->next = p = q;
else { p->next = q; p = q; }
}
return h;
}
void outlist(NODE *h)
{
NODE *p;
p = h->next;
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");
}
}
int main()
{
NODE *head;
int a[N]={2,4,6,8,10};
head=creatlist(a);
printf("\nThe original list:\n");
outlist(head);
fun(head);
printf("\nThe list after inverting :\n");
outlist(head);
return 0;
}
9.给定程序中,函数fun的功能是将不带头结点的单向链表逆置。即若原链表从头至尾结点数据域依次为:2、4、6、8、10,逆置后,从头至尾结点数据域依次为:10、8、6、4、2。
请在下划线处填入正确的内容并将下划线删除,使程序得出正确的结果。
注意:不得增行或删行,也不得更改程序的结构!
#include <stdio.h>
#include <stdlib.h>
#define N 5
typedef struct node
{
int data;
struct node *next;
} NODE;
/**********found**********/
__1__ fun(NODE *h)
{
NODE *p, *q, *r;
p = h;
if (p == NULL)
return NULL;
q = p->next;
p->next = NULL;
/**********found**********/
while (__2__)
{
r = q->next;
q->next = p;
p = q;
/**********found**********/
q = __3__ ;
}
return p;
}
NODE *creatlist(int a[])
{
NODE *h,*p,*q;
int i;
h=NULL;
for(i=0; i<N; i++)
{
q=(NODE *)malloc(sizeof(NODE));
q->data=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");
}
}
int main()
{
NODE *head;
int a[N]={2,4,6,8,10};
head=creatlist(a);
printf("\nThe original list:\n");
outlist(head);
head=fun(head);
printf("\nThe list after inverting :\n");
outlist(head);
return 0;
}
10.给定程序中,函数fun的功能是:将带头结点的单向链表结点数据域中的数据从小到大排序。即若原链表从头至尾结点数据域依次为:10、4、2、8、6,排序后,从头至尾结点数据域依次为:2、4、6、8、10。
请在下划线处填入正确的内容并将下划线删除,使程序得出正确的结果。
注意:不得增行或删行,也不得更改程序的结构!
#include <stdio.h>
#include <stdlib.h>
#define N 6
typedef struct node
{
int data;
struct node *next;
} NODE;
void fun(NODE *h)
{
NODE *p, *q;
int t;
/**********found**********/
p = __1__ ;
while (p)
{
/**********found**********/
q = __2__ ;
while (q)
{
/**********found**********/
if (p->data __3__ q->data)
{ t=p->data; p->data=q->data; q->data=t;}
q = q->next;
}
p = p->next;
}
}
NODE *creatlist(int a[])
{
NODE *h,*p,*q;
int i;
h = (NODE *)malloc(sizeof(NODE));
h->next = NULL;
for(i=0; i<N; i++)
{
q=(NODE *)malloc(sizeof(NODE));
q->data=a[i];
q->next = NULL;
if (h->next==NULL) h->next=p=q;
else { p->next = q; p = q; }
}
return h;
}
void outlist(NODE *h)
{
NODE *p;
p = h->next;
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");
}
}
int main()
{
NODE *head;
int a[N]= {0, 10, 4, 2, 8, 6 };
head=creatlist(a);
printf("\nThe original list:\n");
outlist(head);
fun(head);
printf("\nThe list after sorting :\n");
outlist(head);
return 0;
}
11.给定程序中,函数fun的功能是:将不带头结点的单向链表结点数据域中的数据从小到大排序。即若原链表从头至尾结点数据域依次为:10、4、2、8、6,排序后,从头至尾结点数据域依次为:2、4、6、8、10。
请在下划线处填入正确的内容并将下划线删除,使程序得出正确的结果。
注意:不得增行或删行,也不得更改程序的结构!
#include <stdio.h>
#include <stdlib.h>
#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)
{
/**********found**********/
q = __1__ ;
/**********found**********/
while (__2__)
{
if (p->data > q->data)
{ t=p->data; p->data=q->data; q->data=t; }
q = q->next;
}
/**********found**********/
p = __3__ ;
}
}
NODE *creatlist(int a[])
{
NODE *h,*p,*q;
int i;
h=NULL;
for(i=0; i<N; i++)
{
q=(NODE *)malloc(sizeof(NODE));
q->data=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");
}
}
int main()
{
NODE *head;
int a[N]= {0, 10, 4, 2, 8, 6 };
head=creatlist(a);
printf("\nThe original list:\n");
outlist(head);
fun(head);
printf("\nThe list after inverting :\n");
outlist(head);
return 0;
}
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
1.(1)pb (2)p->data (3)p->data 2.(1)*n (2)next (3)head 3.(1)data (2)next (3)head 4.(1)q (2)next (3)next 5.(1)NULL (2)n (3)head,ch 6.(1)next (2)t->data (3)t 7.(1)x (2)p (3)s 8.(1)next (2)NULL (3)r 9.(1)NODE * (2)q!=NULL (3)r 10.(1)h->next (2)p->next (3)> 11.(1)p->next (2)q (3)p->next
二.程序设计题
1.N名学生的成绩已在主函数中放入一个带头结点的链表中,h指向链表的头结点。编写函数fun,它的功能是:求出平均分,由函数值返回。
例如,若学生的成绩是:85,,7,69,85,91,72,64,87,则平均分为:78.625。
注意:请勿改动主函数main和其他函数中的任何内容,仅在函数fun的花括号中填入你编写的若干语句。
#include <stdio.h>
#include <stdlib.h>
#define N 8
void NONO(void);
struct slist
{
double s;
struct slist *next;
};
typedef struct slist STREC;
double fun(STREC *h)
{
}
STREC * creat(double *s)
{
STREC *h,*p,*q;
int i=0;
h=p=(STREC*)malloc(sizeof(STREC));p->s=0;
while(i<N)
{
q=(STREC*)malloc(sizeof(STREC));
q->s=s[i]; i++; p->next=q; p=q;
}
p->next=0;
return h;
}
void outlist(STREC *h)
{
STREC *p;
p=h->next; printf("head");
do
{
printf("->%4.1f",p->s);
p=p->next;
} while(p!=0);
printf("\n\n");
}
int main()
{
double s[N]={85,76,69,85,91,72,64,87},ave;
STREC *h;
h=creat( s );
outlist(h);
ave=fun( h );
printf("ave= %6.3f\n",ave);
NONO();
return 0;
}
void NONO(void)
{/* 本函数用于打开文件,输入数据,调用函数,输出数据,关闭文件。 */
FILE *in, *out ;
int i,j ; double s[N],ave;
STREC *h ;
in = fopen("in.dat","r") ;
out = fopen("out.dat","w") ;
for(i = 0 ; i < 10 ; i++)
{
for(j=0 ; j<N; j++) fscanf(in,"%lf,",&s[j]);
h=creat( s );
ave=fun( h );
fprintf(out, "%6.3lf\n", ave) ;
}
fclose(in) ;
fclose(out) ;
}
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
double fun(STREC *h) { int n=0; double sum=0.0; STREC *p; p=h->next; while (p!=NULL) { sum+=p->s; n++; p=p->next; } return sum/n; }
2.N名学生的成绩已在主函数中放入一个带头结点的单向链表中,h指向链表的头结点。编写函数fun,它的功能是:找出学生的最高分,由函数值返回。
注意:请勿改动主函数main和其他函数中的任何内容,仅在函数fun的花括号中填入你编写的若干语句。
#include <stdio.h>
#include <stdlib.h>
#define N 8
void NONO(void);
struct slist
{
double s;
struct slist *next;
};
typedef struct slist STREC;
double fun(STREC *h)
{
}
STREC * creat(double *s)
{
STREC *h,*p,*q;
int i=0;
h=p=(STREC*)malloc(sizeof(STREC));
p->s=0;
while(i<N)
{
q=(STREC*)malloc(sizeof(STREC));
q->s=s[i]; i++; p->next=q; p=q;
}
p->next=0;
return h;
}
void outlist(STREC *h)
{
STREC *p;
p=h->next;
printf("head");
do
{
printf("->%2.0f",p->s);
p=p->next;
} while(p!=0);
printf("\n\n");
}
int main()
{
double s[N]={85,76,69,85,91,72,64,87},max;
STREC *h;
h=creat( s );
outlist(h);
max=fun(h);
printf("max=%6.1f\n",max);
NONO();
return 0;
}
void NONO(void)
{/* 本函数用于打开文件,输入数据,调用函数,输出数据,关闭文件。 */
FILE *in, *out ;
int i,j ;
double s[N],max;
STREC *h ;
in = fopen("in.dat","r") ;
out = fopen("out.dat","w") ;
for(i = 0 ; i < 10 ; i++)
{
for(j=0 ; j < N; j++)
fscanf(in, "%lf,", &s[j]);
h=creat( s );
max=fun( h );
fprintf(out, "%6.1lf\n", max);
}
fclose(in) ;
fclose(out) ;
}
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
double fun(STREC *h) { double max=-1; STREC *p; p=h->next; while (p) { if (max<p->s) max=p->s; p=p->next; } return max; }