广东工业大学 Anyviewce C语言 习题九
广东工业大学 Anyviewce C语言 第九章
仅供参考
广东工业大学 Anyviewce C语言 习题七.
广东工业大学 Anyviewce C语言 习题八.
广东工业大学 Anyviewce C语言 习题九.
广东工业大学 Anyviewce C语言 习题十.
广东工业大学 Anyviewce C语言 习题十一.
/**********
【习题9.023】结构体类型定义如下：
struct date{int year; int month; int day;}; //定义日期结构体类型
struct student
{ char name[20];
struct date birth; //出生日期
};
结构体数组s存储了n个人的名字和出生日期。写一函数，求这n个人中年龄最大（即出生日期最小）者的姓名。
**********/
char *oldest(student s[], int n)
{
int i,t=0;
for(i=0;i<n;i++)
{
if(s[i].birth.year>s[t].birth.year)
continue;
else if(s[i].birth.year<s[t].birth.year)
t=i;
else
{
if(s[i].birth.month>s[t].birth.month)
continue;
else if(s[i].birth.month<s[t].birth.month)
t=i;
else
{
if(s[i].birth.day>s[t].birth.day)
continue;
else if(s[i].birth.day<s[t].birth.day)
t=i;
}
}
}
return s[t].name;
}
/**********
【习题9.025】结构体类型定义如下：
struct date{int year; int month; int day;}; //定义日期结构体类型
struct student
{ char id[10]; //学号
char name[20]; //姓名
struct date birth; //出生日期
};
结构体数组s存储了n个人的学号、名字和出生日期。写一函数，以结构体的形式返回这n个人中年龄最大（即出生日期最小）者的信息。
**********/
struct student oldest(struct student s[], int n)
{
int i,t=0;
for(i=0;i<n;i++)
{
if(s[i].birth.year>s[t].birth.year)
continue;
else if(s[i].birth.year<s[t].birth.year)
t=i;
else
{
if(s[i].birth.month>s[t].birth.month)
continue;
else if(s[i].birth.month<s[t].birth.month)
t=i;
else
{
if(s[i].birth.day>s[t].birth.day)
continue;
else if(s[i].birth.day<s[t].birth.day)
t=i;
}
}
}
return s[t];
}
/**********
【习题9.027】结构体类型定义如下：
struct student
{ char id[10]; //学号
char name[10]; //姓名
int score[5]; //各门课成绩
};
结构体数组s存储了n个学生的学号、名字和各门课成绩。编写函数，返回这n个人中第i门课成绩最高者的学号。
**********/
char *best(struct student s[], int n, int i)
{
int j,t=0;
for(j=0;j<n;j++)
{
if(s[j].score[i]>s[t].score[i])
{
t=j;
}
}
return s[t].id;
}
/**********
【习题9.029】结构体类型定义如下：
struct student
{ char id[10]; //学号
char name[10]; //姓名
int score[5]; //各门课成绩
};
结构体数组s存储了n个学生的学号、名字及其5门课成绩。编写函数，返回这n个人中5门课成绩总分最高者的学号。
**********/
char *best(struct student s[], int n)
{
int i,j,t,sum_i,sum_t;
for(i=0,t=0;i<n;i++)
{
for(j=0,sum_i=0,sum_t=0;j<5;j++)
{
sum_i+=s[i].score[j];
sum_t+=s[t].score[j];
}
if(sum_i>sum_t)
t=i;
}
return s[t].id;
}
/**********
【习题9.033】日期和链表结点的结构体类型定义如下：
struct date{int year; int month; int day;}; //日期结构体类型
struct studentNode //链表结点的结构体类型
{ char name[10]; //人名
struct date birth; //出生日期
struct studentNode *next;
};
结构体链表L存储了n个人的名字和出生日期。写一函数，求这n个人中年龄最大（即出生日期最小）者的名字。
**********/
char *oldest(struct studentNode *L)
/* 若L是空表，则返回空指针null
否则返回表中年龄最大者的名字
*/
{
struct studentNode *p;
if(L==NULL)
return NULL;//若L是空表，则返回空指针null
for(p=L->next;p!=NULL;p=p->next)//使p指向L的下一个人的内容
{
if(L->birth.year>p->birth.year)
L=p;//L指向第一个人的年份,p指向第二个人的年份
else if(L->birth.year==p->birth.year)
{
if(L->birth.month>p->birth.month)
L=p;
else if(L->birth.month==p->birth.month)
{
if(L->birth.day>p->birth.day)
L=p;
}
}
}
return L->name;
}
/**********
【习题9.053】结构体类型定义如下：
struct person
{ int id; //员工号
char name[10]; //姓名
int age; //年龄
char sex; //性别
};
结构体数组personnel[n]存储了n位员工的信息。写一函数，返回年龄在a及以上的员工数。
**********/
int count(struct person personnel[], int n, int a)
{
int i,j;
for(i=0,j=0;i<n;i++)
{
if(personnel[i].age>=a)
j++;
}
return j;
}
/**********
【习题9.055】结构体类型定义如下：
struct person
{ int id; //员工号
char name[10]; //姓名
int age; //年龄
char sex; //性别
};
结构体数组personnel[n]存储了n位员工的信息。写一函数，返回年龄在a及以上的x性别的员工数。
**********/
int count(struct person personnel[], int n, int a, char x)
{
int i,j;
for(i=0,j=0;i<n;i++)
{
if(personnel[i].age>=a&&personnel[i].sex==x)
j++;
}
return j;
}
/**********
【习题9.063】结构体类型定义如下：
struct course
{ int cID; //课程号，取值0~99
char name[10]; //课程名
float credit; //学分，取值0~5
int semester; //学期，取值1~8
};
结构体数组c存储了n门课程的信息。写一函数，求学期s的总学分。
**********/
float creditSum(struct course c[], int n, int s)
{
int i;
float sum;
for(i=0,sum=0;i<n;i++)
{
if(c[i].semester==s)
sum+=c[i].credit;
}
return sum;
}
/**********
【习题9.073】课程链表结点的结构体类型定义如下：
struct courseNode //课程链表结点的结构体类型
{ int cID; //课程号，取值0~99
char name[10]; //课程名
float credit; //学分，取值0~5
int semester; //学期，取值1~8
struct courseNode *next;
};
结构体链表Lc存储了各学期多门课程的信息。写一函数，求学期s的总学分。
**********/
float creditSum(struct courseNode *Lc, int s)
/* 若Lc是空表，则返回0;
否则返回学期s的总学分
*/
{
struct courseNode *p;
float sum;
if(Lc==NULL)
return 0.0;
else
for(p=Lc;p!=NULL;p=p->next)
{
if(p->semester==s)
sum+=p->credit;
}
return sum;
}
/**********
【习题9.133】日期和结构体类型定义如下：
struct date{int year; int month; int day;}; //日期结构体类型
struct student //结构体类型
{ char name[10]; //人名
struct date birth; //出生日期
};
结构体数组s存储了n个人的名字和出生日期。写一函数，由数组s中n个人的信息及其顺序构造相应的链表。链表的结点的结构体类型定义如下：
struct studentNode //结构体类型
{ char name[10]; //人名
struct date birth; //出生日期
struct studentNode *next
};
**********/
#define LEN sizeof(struct studentNode)
struct studentNode *CreateLinkList(struct student s[], int n)
{
struct studentNode *head,*p1,*p2;
int i=0;
head=NULL;
p1=p2=(struct studentNode*)malloc(LEN);
if(n!=0)
{
strcpy(p1->name,s[0].name);
p1->birth=s[0].birth;
p2=head=p1;
p1=(struct studentNode*)malloc(LEN);
for(i=1;i<n;i++)
{
strcpy(p1->name,s[i].name);
p1->birth=s[i].birth;
p2->next=p1;
p2=p1;
p1=(struct studentNode*)malloc(LEN);
}
p2->next=NULL;
}
return head;
}
/**********
【习题9.173】课程链表结点的结构体类型定义如下：
struct courseNode //课程链表结点的结构体类型
{ int cID; //课程号，取值0~99
char name[10]; //课程名
float credit; //学分，取值0~5
int semester; //学期，取值1~8
struct courseNode *next;
};
结构体链表Lc存储了多门课程的信息。写一函数，将课程号为c的课程的学分修改为t。
**********/
struct courseNode *creditChange(struct courseNode *Lc, int c, float t)
/* 若课程c不存在，则修改不成功，返回null;
否则修改该课程的学分为t，返回指向该课程结点的指针。
*/
{
struct courseNode*p;
p=Lc;
while(p!=NULL)
{
if(p->cID==c)
{
p->credit=t;
return p;
}
p=p->next;
}
return NULL;
}
/**********
【习题9.183】课程链表结点的结构体类型定义如下：
struct courseNode //课程链表结点的结构体类型
{ int cID; //课程号，取值0~99
char name[10]; //课程名
float credit; //学分，取值0~5
int semester; //学期，取值1~8
struct courseNode *next;
};
结构体链表Lc存储了多门课程的信息。写一函数，将课程号为c的课程结点删除。
**********/
struct courseNode *deleteCourse(struct courseNode **Lc, int c)
/* 若在链表Lc中课程c不存在，则删除不成功，返回null;
否则从链表Lc中删除该课程结点，并返回指向该课程结点的指针。
*/
{
struct courseNode *p1,*p2;
p1=p2=*Lc;
if(p2->next==NULL)
{
p1->next=p2->next;
*Lc=NULL;
return p2;
}
while(p2!=NULL)
{
if(p2->cID==c)
{
p1->next=p2->next;
return p2;
}
p1=p2;
p2=p2->next;
}
return NULL;
}
/**********
【习题9.302】单向链表的结点类型定义如下：
struct node{
char ch;
struct node *next;
};
编写函数，对单向链表L实现就地逆置，即将所有结点的指针反向，原链头当作链尾，原链尾当作链头，并返回逆置后链表的头指针。
**********/
struct node *inverse(struct node *L)
{
struct node *p1,*p2,*p3;
p1=L;
p2=p1->next;
p3=p2->next;
p1->next=NULL;
while(p2!=NULL)
{
p2->next=p1;
p1=p2;
p2=p3;
p3=p3->next;
}
p2->next=p1;
L=p1;
return L;
}
/**********
【习题9.352】单向链表的结点类型定义如下：
struct node{
char ch;
struct node *next;
};
编写函数，对单向链表L实现排序，即按结点的ch值，从小到大重构链表L，并返回排序后的链表的头指针。
**********/
struct node *sorting(struct node *L)
/* 对单向链表L实现从小到大排序，
并返回重构后的链表的头指针。
*/
{
struct node *pb,*pf,temp;
pf=L;
if(L==NULL)//链表为空
{
return L;
}
if(L->next==NULL)//链表有1个节点
{
return L;
}
while(pf->next!=NULL)//以pf指向的节点为基准节点
{
pb=pf->next;//pb从基准点的下一个节点开始
while(pb!=NULL)
{
if(pf->ch>pb->ch)
{
temp=*pf;
*pf=*pb;
*pb=temp;
temp.next=pf->next;
pf->next=pb->next;
pb->next=temp.next;
}
pb=pb->next;
}
pf=pf->next;
}
return L;
}