头歌链表6

第6关:创建一维动态数组,顺序存放输入的一批学生数据,然后输出这批学生中分数最高的学生信息

300

  • 任务要求
  • 参考答案
  • 评论3

任务描述

本关任务:创建动态数组,顺序存放输入的一批学生数据,然后输出这批学生中分数最高的学生信息。要求定义函数分别完成动态数组的创建,学生数据输入输出和查找。

相关知识

  定义函数分别完成动态数组的创建,关键是怎么将在函数体里申请数组的首地址和数组的长度带到函数体外。   定义学生数据类型及输入输出函数如下:

 
  1. typedef struct date
  2. {
  3. int year;
  4. int month;
  5. int day;
  6. }DATE;
  7. typedef struct student
  8. {
  9. int num;
  10. char name[20];
  11. char sex;
  12. DATE birthday;
  13. float score;
  14. }STUDENT;
  15. void input(STUDENT *s)
  16. {
  17. //printf("请输入学生学号:");
  18. scanf("%d",&(s->num));
  19. //printf("请输入学生姓名:");
  20. scanf("%s", s->name);
  21. //printf("请输入学生性别:");
  22. scanf(" %c",&( (*s) . sex));
  23. //printf("请输入学生出生日期:");
  24. scanf("%d%d%d",&s->birthday.year, &s->birthday.month, &s-> birthday.day);
  25. //printf("请输入学生成绩:");
  26. scanf("%f",&(s-> score));
  27. }
  28. void output(STUDENT s)
  29. {
  30. printf("学号:%d\t姓名:%s\t性别:%c\t", s.num,s.name,s.sex);
  31. printf("出生日期:%d-%d-%d \t", s.birthday.year,s.birthday.month, s.birthday.day);
  32. printf("成绩:%.1f\n", s.score);
  33. }

  动态数组的输入输出处理都可以模块化,我们希望定义函数创建动态数组,关键是怎么将在函数体里申请的数组的首地址数组的长度带到函数体外。   定义创建动态数组的函数如下:

 
  1. void createarr(STUDENT **s,int *n)
  2. {
  3. scanf("%d",n);
  4. *s=( STUDENT *) malloc( (*n) * sizeof (STUDENT) );
  5. if( *s == NULL)
  6. {
  7. printf("不能成功分配存储空间。\n");
  8. exit(1);
  9. }
  10. }

编程要求

根据提示,在右侧编辑器 Begin-End 区间补充代码,创建动态数组,顺序存放输入的一批学生数据,然后输出这批学生中分数最高的学生信息。具体要求如下:

  • 定义函数 input(),从后台获取数据,实现单个学生信息的输入;
  • 定义函数 inputarr(),调用函数 input(),实现所有学生信息的输入;
  • 定义函数 maxscore(),找出这批学生中分数最高的学生,并返回位置结果;
  • 定义函数 output(),根据测试说明的预期输出格式输出二维数组;
  • 定义函数 outputarr(),调用函数 output(),输出所有学生的信息;
  • 定义函数 createarr(),创建动态数组。

测试说明

平台会对你编写的代码进行测试。

测试输入: 5 10010 Liyi M 2000 5 23 45 10020 Lier M 2001 2 3 62.5 10030 Lisan F 2000 10 14 92.5 10040 Lisi F 2002 7 23 87 10050 Liwu M 1999 8 6 78

输入说明: 第一行为输入学生的个数; 第一行后面的数据为学生的具体信息。

预期输出: 本班共5个学生学生信息:

学号:10010 姓名:Liyi 性别:M 出生日期:2000-5-23 成绩:45.0

学号:10020 姓名:Lier 性别:M 出生日期:2001-2-3 成绩:62.5

学号:10030 姓名:Lisan 性别:F 出生日期:2000-10-14 成绩:92.5

学号:10040 姓名:Lisi 性别:F 出生日期:2002-7-23 成绩:87.0

学号:10050 姓名:Liwu 性别:M 出生日期:1999-8-6 成绩:78.0

本班5个学生中的分数最高的学生是第3个学生:

学号:10030 姓名:Lisan 性别:F 出生日期:2000-10-14 成绩:92.5

#include<stdio.h>
#include<stdlib.h>
#include<string.h>   	

typedef struct date
{  
	int year;
    int month;
    int day;
}DATE;
typedef struct student
{
     int num;
     char name[20];
     char sex;
     DATE birthday;
     float score;
}STUDENT;

void input(STUDENT *s);
void output(STUDENT s);
void createarr(STUDENT **s,int *n);
void inputarr(STUDENT *s, int n);
int maxscore(STUDENT *s, int n);
void outputarr(STUDENT *s, int n);

int main()
{   
    int i,max,n;
    STUDENT *ps;
    createarr(&ps,&n);
    inputarr (ps,n);
    printf("本班共%d个学生学生信息:\n",n);
    outputarr (ps,n);
    max= maxscore(ps, n);
    printf("本班%d个学生中的分数最高的学生是第%d个学生:\n",n,max+1);
    output(ps[max]);
    printf("\n");
    free(ps);
}
/********** Begin **********/ 
void input(STUDENT *s)
{
    scanf("%d",&(s->num));
    scanf("%s",s->name);
    scanf(" %c",&((*s).sex));
    scanf("%d%d%d",&s->birthday.year,&s->birthday.month,&s->birthday.day);
    scanf("%f",&(s->score));
}

void output(STUDENT s)
{
    printf("学号:%d\t姓名:%s\t性别:%c\t出生日期:%d-%d-%d \t成绩:%.1f\n",s.num,s.name,s.sex,s.birthday.year,s.birthday.month,s.birthday.day,s.score);
 
}

void inputarr(STUDENT s[ ], int n)
{ 
    for(int i=0;i<n;i++)
    {
        input(s+i);
    }
}
void outputarr(STUDENT s[],int n)
{
    for(int i=0;i<n;i++)
    {
        output(*(s+i));
    }
}

void createarr(STUDENT **s,int *n)
{    
    scanf("%d",n);
    *s=(STUDENT*)malloc((*n)*sizeof(STUDENT));
    if(*s==NULL)
    {
        printf("error");
        exit(1);
    }
}

int maxscore(STUDENT *s, int n)
{
    int max=0;
	for(int i=0;i<n;i++)
    {
        if(s[max].score<s[i].score)
        max=i; 
    }
   return max;
}
/********** End **********/

单向链表排序可以通过不同的排序算法来实现,比如冒泡排序、插入排序、选择排序、归并排序和快速排序等。下面以冒泡排序为例进行说明。 冒泡排序是一种简单的排序算法,它重复地遍历链表,并通过两个相邻节点的比较来交换节点的位置,直到整个链表有序为止。具体实现步骤如下: 1. 设置两个指针,一个指向链表的头节点,另一个指向头节点的下一个节点。 2. 遍历链表,比较当前节点和下一个节点的值,如果需要交换位置则交换。 3. 继续遍历链表,直到指针指向链表的尾节点。 4. 如果有任何节点交换了位置,则重新开始遍历链表,直到没有节点需要交换位置为止。 5. 链表排序完成。 下面是使用C语言实现的单向链表排序代码: ```c #include <stdio.h> // 定义链表节点结构 struct ListNode { int val; struct ListNode *next; }; // 冒泡排序函数 void bubbleSort(struct ListNode *head) { if (head == NULL || head->next == NULL) { return; } int swapped; struct ListNode *ptr1; struct ListNode *lptr = NULL; do { swapped = 0; ptr1 = head; while (ptr1->next != lptr) { if (ptr1->val > ptr1->next->val) { // 交换节点位置 int tmp = ptr1->val; ptr1->val = ptr1->next->val; ptr1->next->val = tmp; swapped = 1; } ptr1 = ptr1->next; } lptr = ptr1; } while (swapped); } // 测试用例 int main() { // 创建链表 struct ListNode n1, n2, n3, n4; n1.val = 4; n2.val = 2; n3.val = 1; n4.val = 3; n1.next = &n2; n2.next = &n3; n3.next = &n4; n4.next = NULL; // 排序链表 bubbleSort(&n1); // 输出排序结果 struct ListNode *ptr = &n1; while (ptr != NULL) { printf("%d ", ptr->val); ptr = ptr->next; } return 0; } ``` 以上代码中,我们首先定义了一个链表节点结构 `struct ListNode`,包含一个整数值 `val` 和一个指向下一个节点的指针 `next`。然后我们使用冒泡排序算法实现了 `bubbleSort` 函数,最后在 `main` 函数中创建了一个测试用例并进行排序输出。输出结果为 `1 2 3 4`,表示链表已经按照从小到大的顺序进行了排序。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值