一．程序填空题
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;
}
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) ;
}
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) ;
}
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; }
参考程序
原文地址：http://www.cnblogs.com/cs-whut/p/16887881.html
