#include <stdio.h> #include <process.h> #define SIZE 100 void sort(int a[],int size); int main() { FILE *fp; int a[SIZE]; int i=0,realsize; if((fp=fopen("c:\\TEST","w+"))!=NULL) { while(feof(fp)=='0') { fscanf(fp,"%d",a+i); i++; } realsize=i-1; sort(a,realsize); for(i=0;i<realsize;i++) fprintf(fp,"%d",*(a+i)); fclose(fp); } else { printf("\ncannot open the file\n"); exit(1); } return 0; }

这段代码的作用是打开一个名为"TEST"的文件，将文件中的整数读入数组a中，然后对数组a进行排序，并将排序后的结果写回到文件中。具体的实现流程如下：

1. 首先定义了一个名为"SIZE"的宏，用于表示数组a的长度。

2. 接着定义了一个名为"sort"的函数，用于对数组a进行排序。函数的实现方式没有给出，可能是使用冒泡排序、快速排序或其他排序算法。

3. 在主函数中，首先定义了一个名为"fp"的文件指针，用于打开名为"TEST"的文件。

4. 如果文件打开成功，则通过循环读取文件中的整数，并将它们存储到数组a中。循环的条件是文件没有结束，即feof(fp)的返回值不是0。每读取一个整数，就将数组下标i加1。

5. 循环结束后，通过i的值计算出实际读取到的整数个数realsize，并将其减1。因为在读取文件时，每读取一个整数都会将i加1，所以最后i的值比实际读取到的整数个数多1。

6. 调用函数sort对数组a进行排序。

7. 最后，使用循环将排序后的结果写回到文件中，并关闭文件。循环的条件是数组下标i小于realsize，每输出一个整数，就将i加1。注意，fprintf函数用于将整数输出到文件中，"%d"表示输出一个整数，*(a+i)表示数组a中下标为i的元素的值。

如果文件打开失败，则输出一条错误信息并退出程序。

相关问题

要求输入3个进程的信息，按照最高响应比优先的调度算法计算并输出每个进程的周转时间。(若两个进程的响应比相同，则优先选择先进入的进程。若两个进程的响应比相同，而且进入时刻也相同，则按照输入的顺序执行，如：P4和P6的响应比相同且进入时刻也相同，如P4先输入则选择P4先执行) 输入格式 程序要求输入3行，以回车符号作为分隔，每行有3个数据，以空格作为分隔。首先输入一个字符串（长度小于等于10），为进程名，第2个数据类型为整型，表示进程的进入时刻，第3个数据类型为整型，表示进程的运行时间。 输出格式 输出三个整数之间，整数之间用空格作为分隔，为每个进程的周转时间。 用C语言写

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

#define MAX_PROCESS 3

typedef struct Process {
    char name[11];
    int arrival_time;
    int burst_time;
    int turnaround_time;
    int response_ratio;
} Process;

void swap(Process *p1, Process *p2) {
    Process temp = *p1;
    *p1 = *p2;
    *p2 = temp;
}

void sort_by_response_ratio(Process *processes, int n) {
    for (int i = 0; i < n; i++) {
        processes[i].response_ratio = (processes[i].burst_time + processes[i].arrival_time) / processes[i].burst_time;
    }

    for (int i = 0; i < n - 1; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (processes[j].response_ratio < processes[j+1].response_ratio) {
                swap(&processes[j], &processes[j+1]);
            }
            else if (processes[j].response_ratio == processes[j+1].response_ratio && processes[j].arrival_time > processes[j+1].arrival_time) {
                swap(&processes[j], &processes[j+1]);
            }
        }
    }
}

void calculate_turnaround_time(Process *processes, int n) {
    int time = 0;
    for (int i = 0; i < n; i++) {
        time += processes[i].burst_time;
        processes[i].turnaround_time = time - processes[i].arrival_time;
    }
}

int main() {
    Process processes[MAX_PROCESS];

    for (int i = 0; i < MAX_PROCESS; i++) {
        scanf("%s %d %d", processes[i].name, &processes[i].arrival_time, &processes[i].burst_time);
    }

    sort_by_response_ratio(processes, MAX_PROCESS);
    calculate_turnaround_time(processes, MAX_PROCESS);

    for (int i = 0; i < MAX_PROCESS; i++) {
        printf("%d ", processes[i].turnaround_time);
    }

    return 0;
}

C语言编写多级反馈队列算法代码和最高响应比算法代码

多级反馈队列算法代码：

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

#define MAX 10

int front1 = -1, rear1 = -1; // Queue 1
int front2 = -1, rear2 = -1; // Queue 2
int front3 = -1, rear3 = -1; // Queue 3

int queue1[MAX], queue2[MAX], queue3[MAX];

void enQueue(int queue[], int *front, int *rear, int data) {
    if (*rear == MAX - 1) {
        printf("Queue is full!\n");
        return;
    }

    if (*front == -1) {
        *front = 0;
    }

    *rear += 1;
    queue[*rear] = data;
}

int deQueue(int queue[], int *front, int *rear) {
    if (*front == -1) {
        printf("Queue is empty!\n");
        return -1;
    }

    int data = queue[*front];

    if (*front == *rear) {
        *front = -1;
        *rear = -1;
    } else {
        *front += 1;
    }

    return data;
}

void executeProcess(int process, int time) {
    printf("Process %d executed for %d seconds\n", process, time);
}

void MLFQ(int processes[], int n) {
    int i, j;

    // Add all processes to queue 1
    for (i = 0; i < n; i++) {
        enQueue(queue1, &front1, &rear1, processes[i]);
    }

    // Execute processes in the queues until all queues are empty
    while (front1 != -1 || front2 != -1 || front3 != -1) {

        // Execute processes in queue 1
        while (front1 != -1) {
            int process = deQueue(queue1, &front1, &rear1);
            executeProcess(process, 1);

            // Move the process to queue 2
            enQueue(queue2, &front2, &rear2, process);
        }

        // Execute processes in queue 2
        while (front2 != -1) {
            int process = deQueue(queue2, &front2, &rear2);
            executeProcess(process, 2);

            // Move the process to queue 3
            enQueue(queue3, &front3, &rear3, process);
        }

        // Execute processes in queue 3
        while (front3 != -1) {
            int process = deQueue(queue3, &front3, &rear3);
            executeProcess(process, 3);

            // Move the process back to queue 3
            enQueue(queue3, &front3, &rear3, process);
        }
    }
}

int main() {
    int processes[] = {1, 2, 3, 4, 5};
    int n = sizeof(processes) / sizeof(processes[0]);

    MLFQ(processes, n);

    return 0;
}

最高响应比算法代码：

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

#define MAX 10

typedef struct {
    int process;
    int burstTime;
    int waitingTime;
    int responseTime;
    int turnaroundTime;
} Process;

void swap(Process *xp, Process *yp)
{
    Process temp = *xp;
    *xp = *yp;
    *yp = temp;
}

void sort(Process *processes, int n) {
    int i, j;
    for (i = 0; i < n - 1; i++) {
        for (j = 0; j < n - i - 1; j++) {
            if (processes[j].responseTime < processes[j + 1].responseTime) {
                swap(&processes[j], &processes[j + 1]);
            }
        }
    }
}

void executeProcess(Process process, int time) {
    printf("Process %d executed for %d seconds\n", process.process, time);
}

void HRRN(Process processes[], int n) {
    int i, j, currentTime = 0;

    // Calculate the response time for each process
    for (i = 0; i < n; i++) {
        processes[i].responseTime = currentTime;
        currentTime += processes[i].burstTime;
    }

    // Sort the processes by response time
    sort(processes, n);

    // Execute the processes
    for (i = 0; i < n; i++) {
        executeProcess(processes[i], processes[i].burstTime);
    }
}

int main() {
    Process processes[] = {
        {1, 10, 0, 0, 0},
        {2, 5, 0, 0, 0},
        {3, 8, 0, 0, 0},
        {4, 7, 0, 0, 0},
        {5, 6, 0, 0, 0},
    };
    int n = sizeof(processes) / sizeof(processes[0]);

    HRRN(processes, n);

    return 0;
}