6-2 结构体数组排序-根据成绩高低将学生记录排序

### 回答1：
可以使用冒泡排序或快速排序等算法对结构体数组进行排序，具体实现方法如下：

1. 冒泡排序

冒泡排序是一种简单的排序算法，它的基本思想是通过不断交换相邻的元素，将最大的元素逐步“冒泡”到数组的末尾。对于结构体数组，可以按照成绩高低的顺序进行排序，具体实现代码如下：

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

typedef struct student {
    char name[20];
    int score;
} Student;

void bubble_sort(Student arr[], int n) {
    int i, j;
    Student tmp;
    for (i = 0; i < n - 1; i++) {
        for (j = 0; j < n - i - 1; j++) {
            if (arr[j].score < arr[j + 1].score) {
                tmp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = tmp;
            }
        }
    }
}

int main() {
    Student arr[5] = {
        {"Tom", 80},
        {"Jerry", 90},
        {"Alice", 70},
        {"Bob", 85},
        {"David", 75}
    };
    int n = sizeof(arr) / sizeof(arr[0]);
    bubble_sort(arr, n);
    int i;
    for (i = 0; i < n; i++) {
        printf("%s %d\n", arr[i].name, arr[i].score);
    }
    return 0;
}

2. 快速排序

快速排序是一种高效的排序算法，它的基本思想是通过一趟排序将待排序的数据分割成独立的两部分，其中一部分的所有元素都比另一部分的所有元素小，然后再按照同样的方法对这两部分数据分别进行快速排序，直到整个序列有序为止。对于结构体数组，可以按照成绩高低的顺序进行排序，具体实现代码如下：

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

typedef struct student {
    char name[20];
    int score;
} Student;

int partition(Student arr[], int left, int right) {
    int i = left, j = right;
    Student tmp = arr[left];
    while (i < j) {
        while (i < j && arr[j].score <= tmp.score) {
            j--;
        }
        if (i < j) {
            arr[i++] = arr[j];
        }
        while (i < j && arr[i].score >= tmp.score) {
            i++;
        }
        if (i < j) {
            arr[j--] = arr[i];
        }
    }
    arr[i] = tmp;
    return i;
}

void quick_sort(Student arr[], int left, int right) {
    if (left < right) {
        int pivot = partition(arr, left, right);
        quick_sort(arr, left, pivot - 1);
        quick_sort(arr, pivot + 1, right);
    }
}

int main() {
    Student arr[5] = {
        {"Tom", 80},
        {"Jerry", 90},
        {"Alice", 70},
        {"Bob", 85},
        {"David", 75}
    };
    int n = sizeof(arr) / sizeof(arr[0]);
    quick_sort(arr, 0, n - 1);
    int i;
    for (i = 0; i < n; i++) {
        printf("%s %d\n", arr[i].name, arr[i].score);
    }
    return 0;
}

### 回答2：
结构体数组是将结构体类型的元素保存在数组中，方便对这些元素进行处理和操作。对于学生记录这样的结构体，我们可以根据不同的需求对其进行排序。本题需要将学生记录按照成绩高低进行排序，因此我们可以使用快速排序来解决问题。

快速排序的基本思想是选择一个基准数，将小于等于基准数的元素放到基准数左边，将大于基准数的元素放到基准数右边，然后分别对左右两边的元素进行递归排序。在本题中，我们可以将学生成绩作为基准数，将小于等于基准数的记录放到左边，将大于基准数的记录放到右边。

接下来是具体的实现步骤：

1. 定义一个学生记录的结构体，包括学生姓名和成绩两个字段。

2. 定义一个结构体数组，将多个学生记录保存到数组中。

3. 编写一个快速排序函数，实现根据成绩从大到小对学生记录进行排序。函数的参数包括一个结构体数组、左边界和右边界。

4. 在快速排序函数中实现分治算法，将小于等于基准数的记录放到左边，将大于基准数的记录放到右边，然后递归对左右两边的记录进行排序。

5. 在函数外部调用快速排序函数，对学生记录进行排序。

6. 输出排序后的学生记录。

下面是对应的代码实现：

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

// 定义学生记录结构体
typedef struct student
{
    char name[20];
    int score;
} Student;

// 定义快速排序函数
void quickSort(Student *arr, int left, int right)
{
    int i, j;
    Student pivot, temp;

    if (left < right)
    {
        // 初始化基准数和左右指针
        pivot = arr[left];
        i = left;
        j = right;

        while (i < j)
        {
            // 从后往前找到第一个比基准数小的记录
            while (i < j && arr[j].score <= pivot.score)
                j--;
            if (i < j)
            {
                temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }

            // 从前往后找到第一个比基准数大的记录
            while (i < j && arr[i].score >= pivot.score)
                i++;
            if (i < j)
            {
                temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }

        // 将基准数放到正确的位置
        arr[left] = arr[i];
        arr[i] = pivot;

        // 递归排序左右两边的记录
        quickSort(arr, left, i - 1);
        quickSort(arr, i + 1, right);
    }
}

int main(void)
{
    int n, i;
    Student *arr;

    printf("请输入学生人数：");
    scanf("%d", &n);

    // 动态分配结构体数组内存空间
    arr = (Student *)malloc(sizeof(Student) * n);
    if (arr == NULL)
    {
        printf("内存分配失败！\n");
        return -1;
    }

    // 输入学生记录
    printf("请依次输入学生姓名和成绩：\n");
    for (i = 0; i < n; i++)
    {
        scanf("%s%d", arr[i].name, &arr[i].score);
    }

    // 对学生记录进行排序
    quickSort(arr, 0, n - 1);

    // 输出排序后的学生记录
    printf("\n按成绩从高到低排序后的学生记录如下：\n");
    printf("姓名\t成绩\n");
    for (i = 0; i < n; i++)
    {
        printf("%s\t%d\n", arr[i].name, arr[i].score);
    }

    // 释放内存空间
    free(arr);

    return 0;
}

### 回答3：
要根据成绩高低将学生记录排序，我们可以使用结构体数组排序。结构体数组排序的一般思路是：先定义一个结构体数组，然后使用排序算法对其进行排序，最后输出排序后的结果。

具体实现过程分为以下几个步骤：

1. 定义结构体数组

结构体数组是由多个结构体元素组成的复合数据类型，每个元素包含多个字段。在本例中，结构体元素是学生记录，每个学生记录包含姓名和成绩两个字段，因此定义结构体如下:

struct Student{
char name[20];
int score;
}stu[5]; //定义了一个由5个学生记录组成的结构体数组

2.输入学生记录

在程序中输入5位学生的姓名和成绩。输入可以采用循环结构，逐个输入学生记录。

for(int i=0;i<5;i++){
printf("请输入第%d个学生的姓名和成绩：",i+1);
scanf("%s%d",stu[i].name,&stu[i].score);
}

3.排序算法

对学生记录进行排序，可以使用冒泡排序、快速排序、选择排序等多种排序算法。在本例中，我们使用冒泡排序对学生记录按照成绩从高到低排序，先对成绩进行比较，再交换对应的姓名。

void bubbleSort(struct Student *stu,int n){
for(int i=0;i<n-1;i++){
for(int j=0;j<n-i-1;j++){
if(stu[j].score<stu[j+1].score){
struct Student temp;
temp=stu[j];
stu[j]=stu[j+1];
stu[j+1]=temp;
}
}
}
}

4.输出排序结果

最后，要输出按照成绩从高到低排序后的学生记录。可以使用循环结构遍历结构体数组。

for(int i=0;i<5;i++){
printf("第%d名学生：%s %d\n",i+1,stu[i].name,stu[i].score);
}

这样，就可以实现根据成绩高低将学生记录排序的功能了。