写一个编制时间片轮转调度算法，可自定义时间片的大小 ，编制静态优先级调度算法，优先级高低可自定义的C语言代码

好的，以下是使用C语言编写的时间片轮转调度算法和静态优先级调度算法，可以自定义时间片大小和优先级高低：

时间片轮转调度算法：

#include <stdio.h>

void time_slice_rr(int n, int processes[][2], int time_slice) {
    int queue[n][3];  // 进程队列
    int current_time = 0;  // 当前时间
    int total_time = 0;  // 运行总时间
    int index = 0;  // 当前执行的进程在队列中的位置

    // 将所有进程按照到达时间顺序加入队列
    for (int i = 0; i < n; i++) {
        queue[i][0] = processes[i][0];  // 进程编号
        queue[i][1] = processes[i][1];  // 剩余运行时间
        queue[i][2] = processes[i][0];  // 到达时间
    }

    while (1) {
        // 选择下一个要执行的进程
        if (n == 0) {
            break;
        }
        int current_process[3] = {queue[index][0], queue[index][1], queue[index][2]};
        // 执行进程
        if (current_process[1] > time_slice) {
            current_process[1] -= time_slice;
            current_time += time_slice;
            total_time += time_slice;
            // 将该进程放回队列末尾
            for (int i = index; i < n - 1; i++) {
                queue[i][0] = queue[i+1][0];
                queue[i][1] = queue[i+1][1];
                queue[i][2] = queue[i+1][2];
            }
            queue[n-1][0] = current_process[0];
            queue[n-1][1] = current_process[1];
            queue[n-1][2] = current_process[2];
        } else {
            current_time += current_process[1];
            total_time += current_process[1];
            current_process[1] = 0;
            queue[index][1] = 0;
            processes[current_process[0]][2] = current_time;  // 记录结束时间
            // 将已完成的进程从队列中删除
            for (int i = index; i < n - 1; i++) {
                queue[i][0] = queue[i+1][0];
                queue[i][1] = queue[i+1][1];
                queue[i][2] = queue[i+1][2];
            }
            n--;
        }

        // 更新 index
        index++;
        if (index >= n) {
            index = 0;
        }

    }
}

int cmp(const void *a, const void *b) {
    int *pa = *(int **)a;
    int *pb = *(int **)b;
    return pb[2] - pa[2];
}

void static_priority(int n, int processes[][2], int priority_list[]) {
    int queue[n][3];  // 进程队列
    int current_time = 0;  // 当前时间
    int total_time = 0;  // 运行总时间

    // 将所有进程按照优先级顺序加入队列
    int *temp[n];
    for (int i = 0; i < n; i++) {
        temp[i] = processes[i];
    }
    qsort(temp, n, sizeof(int *), cmp);
    for (int i = 0; i < n; i++) {
        int index = temp[i][0];
        queue[i][0] = index;  // 进程编号
        queue[i][1] = processes[index][1];  // 剩余运行时间
        queue[i][2] = processes[index][0];  // 到达时间
    }

    while (1) {
        // 选择优先级最高的进程
        if (n == 0) {
            break;
        }
        int current_process[3] = {queue[0][0], queue[0][1], queue[0][2]};
        // 执行进程
        current_time += current_process[1];
        total_time += current_process[1];
        current_process[1] = 0;
        queue[0][1] = 0;
        processes[current_process[0]][2] = current_time;  // 记录结束时间
        // 将已完成的进程从队列中删除
        for (int i = 0; i < n - 1; i++) {
            queue[i][0] = queue[i+1][0];
            queue[i][1] = queue[i+1][1];
            queue[i][2] = queue[i+1][2];
        }
        n--;
    }
}

int main() {
    // 测试时间片轮转调度算法
    int processes[5][2] = {
        {0, 20},
        {1, 25},
        {2, 10},
        {3, 15},
        {4, 30}
    };
    time_slice_rr(5, processes, 10);
    for (int i = 0; i < 5; i++) {
        printf("Process %d: start_time=%d, end_time=%d\n", i, processes[i][2] - processes[i][1], processes[i][2]);
    }

    // 测试静态优先级调度算法
    int processes2[5][2] = {
        {0, 20},
        {1, 25},
        {2, 10},
        {3, 15},
        {4, 30}
    };
    int priority_list[5] = {4, 1, 3, 0, 2};
    static_priority(5, processes2, priority_list);
    for (int i = 0; i < 5; i++) {
        printf("Process %d: start_time=%d, end_time=%d\n", i, processes2[i][2] - processes2[i][1], processes2[i][2]);
    }

    return 0;
}

以上代码仅供参考，具体实现还需要根据实际需求进行修改。