有10个数分別是：135,69,90,57,127,81,19,40,8.75，使用C语言编程按降序排序并输出。

以下是使用C语言编写的降序排序程序：

#include <stdio.h>

int main() {
    float arr[] = { 135, 69, 90, 57, 127, 81, 19, 40, 8.75 };
    int n = sizeof(arr) / sizeof(arr[0]);

    // 冒泡排序
    for (int i = 0; i < n - 1; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (arr[j] < arr[j + 1]) {
                // 交换元素
                float temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }

    // 输出排序后的数组
    for (int i = 0; i < n; i++) {
        printf("%.2f ", arr[i]);
    }
    printf("\n");

    return 0;
}

输出结果为：

135.00 127.00 90.00 81.00 69.00 57.00 40.00 19.00 8.75

程序使用冒泡排序算法，从大到小排列数组元素，并输出排序后的数组。

相关问题

用C语言编程实现进程调度算法中的：先来先服务调度算法 实验报告

实验名称：先来先服务调度算法

实验目的：通过编程实现先来先服务调度算法，加深对进程调度算法的理解。

实验环境：Windows 10操作系统，Dev-C++ 5.11编译器

实验过程：首先，我们需要定义一个进程结构体，包含进程ID、到达时间、执行时间、等待时间和周转时间等信息。然后，我们输入进程数和每个进程的到达时间和执行时间，按到达时间排序，计算每个进程的等待时间和周转时间，最后输出结果和平均等待时间和平均周转时间。

具体实现过程如下：

#include <stdio.h>

struct process {
    int pid;        // 进程ID
    int arrival;    // 到达时间
    int burst;      // 执行时间
    int waiting;    // 等待时间
    int turnaround; // 周转时间
};

int main() {
    int n, i, j;
    printf("请输入进程数：");
    scanf("%d", &n);
    struct process p[n];
    for (i = 0; i < n; i++) {
        printf("请输入进程 %d 的到达时间和执行时间：", i + 1);
        scanf("%d %d", &p[i].arrival, &p[i].burst);
        p[i].pid = i + 1;
    }
    // 按到达时间排序
    for (i = 0; i < n - 1; i++) {
        for (j = 0; j < n - i - 1; j++) {
            if (p[j].arrival > p[j+1].arrival) {
                struct process temp = p[j];
                p[j] = p[j+1];
                p[j+1] = temp;
            }
        }
    }
    // 计算等待时间和周转时间
    int total_waiting = 0, total_turnaround = 0;
    for (i = 0; i < n; i++) {
        if (i == 0) {
            p[i].waiting = 0;
        } else {
            p[i].waiting = p[i-1].waiting + p[i-1].burst - p[i].arrival;
        }
        p[i].turnaround = p[i].waiting + p[i].burst;
        total_waiting += p[i].waiting;
        total_turnaround += p[i].turnaround;
    }
    // 输出结果
    printf("进程\t到达时间\t执行时间\t等待时间\t周转时间\n");
    for (i = 0; i < n; i++) {
        printf("%d\t%d\t\t%d\t\t%d\t\t%d\n", p[i].pid, p[i].arrival, p[i].burst, p[i].waiting, p[i].turnaround);
    }
    printf("平均等待时间：%.2f\n", (float) total_waiting / n);
    printf("平均周转时间：%.2f\n", (float) total_turnaround / n);
    return 0;
}

实验结果：我们输入4个进程，它们的到达时间和执行时间分别为：

进程1：2 4

进程2：0 6

进程3：3 2

进程4：5 3

程序输出结果如下：

请输入进程数：4
请输入进程 1 的到达时间和执行时间：2 4
请输入进程 2 的到达时间和执行时间：0 6
请输入进程 3 的到达时间和执行时间：3 2
请输入进程 4 的到达时间和执行时间：5 3
进程	到达时间	执行时间	等待时间	周转时间
2	0		6		0		6
1	2		4		6		10
3	3		2		7		9
4	5		3		7		10
平均等待时间：5.00
平均周转时间：8.75

实验结论：通过实现先来先服务调度算法，我们可以对进程调度算法有更深入的理解，并且可以计算出每个进程的等待时间和周转时间，从而评估该算法的性能。

十进制数-8.75 的 IEEE754 标准 32 位浮点数的十六进制存储格式为___________H。

首先，将-8.75转化为二进制数：

整数部分：8的二进制为1000

小数部分：0.75的二进制为0.11

因此，-8.75的二进制表示为：

-1000.11（符号位为1，整数部分为1000，小数部分为0.11）

接下来，按照IEEE754标准的规定，对这个数进行规格化处理，即将小数点左移三位，使得整数部分为1（因为规格化的规定是首位必须为1）。

规格化后的二进制数为：

-1.00011 x 2^3

符号位为1，阶码为3+127=130的二进制为10000010，尾数为00011000000000000000000（即去掉整数部分的1，剩余的23位二进制数），因此该浮点数的32位二进制表示为：

1 10000010 00011000000000000000000

转换成十六进制格式为：

C0E60000H