编写C程序模拟实现单处理机系统中的进程调度算法，实现对多个进程的调度模拟，要求采用常见进程调度算法（如先来先服务、时间片轮转和优先级调度等算法）进行模拟调度。

好的，我可以为您提供一份基于先来先服务，时间片轮转和优先级调度的进程调度算法的C语言实现示例。

首先，我们需要定义进程的数据结构：

typedef struct Process {
    int id;        // 进程ID
    int priority;  // 优先级
    int burst;     // 进程执行时间
    int arrival;   // 到达时间
    int remaining; // 剩余执行时间
    int waiting;   // 等待时间
} Process;

其中，id为进程的唯一标识符，priority为进程的优先级，burst为进程需要执行的时间，arrival为进程的到达时间，remaining为剩余执行时间，waiting为等待时间。

接下来，我们可以定义三种不同的调度算法：先来先服务、时间片轮转和优先级调度。

1. 先来先服务（FCFS）

void fcfs(Process *processes, int n) {
    int time = 0;
    int i, j;
    float avg_waiting = 0, avg_turnaround = 0;

    // 按照到达时间排序
    for (i = 0; i < n - 1; i++) {
        for (j = 0; j < n - i - 1; j++) {
            if (processes[j].arrival > processes[j + 1].arrival) {
                Process temp = processes[j];
                processes[j] = processes[j + 1];
                processes[j + 1] = temp;
            }
        }
    }

    // 执行进程
    for (i = 0; i < n; i++) {
        // 等待时间为前面所有进程的执行时间之和
        processes[i].waiting = time - processes[i].arrival;
        if (processes[i].waiting < 0) {
            processes[i].waiting = 0;
            time = processes[i].arrival;
        }
        time += processes[i].burst;
        // 周转时间为等待时间加上执行时间
        avg_turnaround += time - processes[i].arrival;
    }

    // 计算平均等待时间和平均周转时间
    avg_waiting = avg_turnaround / n;
    avg_turnaround /= n;

    // 输出结果
    printf("先来先服务（FCFS）\n");
    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", processes[i].id, processes[i].arrival, processes[i].burst, processes[i].waiting, time - processes[i].arrival);
    }
    printf("平均等待时间：%.2f\n", avg_waiting);
    printf("平均周转时间：%.2f\n", avg_turnaround);
}

2. 时间片轮转（RR）

void rr(Process *processes, int n, int quantum) {
    int time = 0;
    int i, j;
    float avg_waiting = 0, avg_turnaround = 0;

    // 按照到达时间排序
    for (i = 0; i < n - 1; i++) {
        for (j = 0; j < n - i - 1; j++) {
            if (processes[j].arrival > processes[j + 1].arrival) {
                Process temp = processes[j];
                processes[j] = processes[j + 1];
                processes[j + 1] = temp;
            }
        }
    }

    // 执行进程
    int *remaining_times = (int *)malloc(sizeof(int) * n);
    for (i = 0; i < n; i++) {
        remaining_times[i] = processes[i].burst;
    }
    while (1) {
        int done = 1;
        for (i = 0; i < n; i++) {
            if (remaining_times[i] > 0) {
                done = 0;
                if (remaining_times[i] > quantum) {
                    time += quantum;
                    remaining_times[i] -= quantum;
                } else {
                    time += remaining_times[i];
                    processes[i].waiting = time - processes[i].burst - processes[i].arrival;
                    remaining_times[i] = 0;
                    // 周转时间为等待时间加上执行时间
                    avg_turnaround += time - processes[i].arrival;
                }
            }
        }
        if (done == 1) {
            break;
        }
    }

    // 计算平均等待时间和平均周转时间
    avg_waiting = avg_turnaround / n - quantum;
    avg_turnaround /= n;

    // 输出结果
    printf("时间片轮转（RR）\n");
    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", processes[i].id, processes[i].arrival, processes[i].burst, processes[i].waiting, time - processes[i].arrival);
    }
    printf("平均等待时间：%.2f\n", avg_waiting);
    printf("平均周转时间：%.2f\n", avg_turnaround);
}

3. 优先级调度（Priority Scheduling）

void priority(Process *processes, int n) {
    int time = 0;
    int i, j;
    float avg_waiting = 0, avg_turnaround = 0;

    // 按照到达时间排序
    for (i = 0; i < n - 1; i++) {
        for (j = 0; j < n - i - 1; j++) {
            if (processes[j].arrival > processes[j + 1].arrival) {
                Process temp = processes[j];
                processes[j] = processes[j + 1];
                processes[j + 1] = temp;
            }
        }
    }

    // 执行进程
    int *remaining_times = (int *)malloc(sizeof(int) * n);
    for (i = 0; i < n; i++) {
        remaining_times[i] = processes[i].burst;
    }
    int *completed = (int *)malloc(sizeof(int) * n);
    memset(completed, 0, sizeof(int) * n);
    while (1) {
        int highest_priority = -1;
        int highest_priority_index = -1;
        for (i = 0; i < n; i++) {
            if (processes[i].arrival <= time && completed[i] == 0) {
                if (processes[i].priority > highest_priority) {
                    highest_priority = processes[i].priority;
                    highest_priority_index = i;
                }
            }
        }
        if (highest_priority_index == -1) {
            time++;
            continue;
        }
        remaining_times[highest_priority_index]--;
        time++;
        if (remaining_times[highest_priority_index] == 0) {
            processes[highest_priority_index].waiting = time - processes[highest_priority_index].burst - processes[highest_priority_index].arrival;
            // 周转时间为等待时间加上执行时间
            avg_turnaround += time - processes[highest_priority_index].arrival;
            completed[highest_priority_index] = 1;
        }
        if (completed_all(completed, n)) {
            break;
        }
    }

    // 计算平均等待时间和平均周转时间
    avg_waiting = avg_turnaround / n;
    avg_turnaround /= n;

    // 输出结果
    printf("优先级调度（Priority Scheduling）\n");
    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", processes[i].id, processes[i].arrival, processes[i].burst, processes[i].waiting, time - processes[i].arrival);
    }
    printf("平均等待时间：%.2f\n", avg_waiting);
    printf("平均周转时间：%.2f\n", avg_turnaround);
}

int completed_all(int *completed, int n) {
    int i;
    for (i = 0; i < n; i++) {
        if (completed[i] == 0) {
            return 0;
        }
    }
    return 1;
}

最后，我们可以在main函数中调用这三种算法来模拟进程调度：

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

    fcfs(processes, n);
    printf("\n");
    rr(processes, n, 2);
    printf("\n");
    priority(processes, n);

    return 0;
}

这里我们模拟了一个包含6个进程的系统，并分别对其进行了先来先服务、时间片轮转和优先级调度三种算法的模拟。您可以自行更改进程的参数，比如到达时间、执行时间和优先级等，来观察不同算法的效果和对应的调度结果。