编写和调试一个进程调度程序，实现基于优先权的进度调度算法和基于时间片轮转调度算法

这是一个比较大的项目，需要涉及到操作系统的相关知识。以下是一个简单的实现示例，仅供参考。

首先，我们需要定义进程的结构体和队列：

typedef struct process{
    int pid; // 进程ID
    int priority; // 优先级
    int burst; // 运行时间
    int remaining; // 剩余时间
    int wait; // 等待时间
    int turnaround; // 周转时间
}PROCESS;

typedef struct queue{
    PROCESS* data[MAX_PROCESS];
    int front, rear;
}QUEUE;

其中，`MAX_PROCESS`是进程队列的最大长度。接下来是基于优先权的进程调度算法的主要代码：

void priorityScheduling(PROCESS* processes[], int n){
    QUEUE* q = createQueue();
    int currentTime = 0; // 当前时间
    int completed = 0; // 已完成的进程数
    
    while(completed < n){
        // 将到达时间小于等于当前时间的进程加入队列
        for(int i = 0; i < n; i++){
            if(processes[i]->burst > 0 && processes[i]->remaining == processes[i]->burst && processes[i]->arrival <= currentTime){
                enqueue(q, processes[i]);
            }
        }
        
        // 如果队列为空，则时间跳到下一个进程到达的时间
        if(isEmpty(q)){
            int minArrival = INT_MAX;
            for(int i = 0; i < n; i++){
                if(processes[i]->burst > 0 && processes[i]->remaining == processes[i]->burst && processes[i]->arrival < minArrival){
                    minArrival = processes[i]->arrival;
                }
            }
            currentTime = minArrival;
            continue;
        }
        
        // 从队列中选择优先级最高的进程运行
        PROCESS* p = dequeue(q);
        p->wait += currentTime - p->turnaround;
        p->remaining--;
        currentTime++;
        
        // 如果进程已完成，则计算周转时间
        if(p->remaining == 0){
            completed++;
            p->turnaround = currentTime - p->arrival;
        }
        else{
            // 如果还有剩余时间，则将进程重新加入队列
            enqueue(q, p);
        }
    }
    
    // 输出结果
    printResult(processes, n);
}

在上述代码中，`createQueue()`、`enqueue()` 和 `dequeue()` 函数均为队列相关的操作函数。`printResult()` 函数用于输出各个进程的等待时间、周转时间等统计信息。接下来是基于时间片轮转调度算法的主要代码：

void roundRobinScheduling(PROCESS* processes[], int n, int timeQuantum){
    QUEUE* q = createQueue();
    int currentTime = 0; // 当前时间
    int completed = 0; // 已完成的进程数
    
    while(completed < n){
        // 将到达时间小于等于当前时间的进程加入队列
        for(int i = 0; i < n; i++){
            if(processes[i]->burst > 0 && processes[i]->remaining == processes[i]->burst && processes[i]->arrival <= currentTime){
                enqueue(q, processes[i]);
            }
        }
        
        // 如果队列为空，则时间跳到下一个进程到达的时间
        if(isEmpty(q)){
            int minArrival = INT_MAX;
            for(int i = 0; i < n; i++){
                if(processes[i]->burst > 0 && processes[i]->remaining == processes[i]->burst && processes[i]->arrival < minArrival){
                    minArrival = processes[i]->arrival;
                }
            }
            currentTime = minArrival;
            continue;
        }
        
        // 从队列头开始，每次运行一个时间片
        PROCESS* p = dequeue(q);
        p->wait += currentTime - p->turnaround;
        p->remaining -= timeQuantum;
        currentTime += timeQuantum;
        
        // 如果进程已完成，则计算周转时间
        if(p->remaining <= 0){
            completed++;
            p->turnaround = currentTime - p->arrival + p->remaining;
        }
        else{
            // 如果还有剩余时间，则将进程重新加入队列
            enqueue(q, p);
        }
    }
    
    // 输出结果
    printResult(processes, n);
}

在上述代码中，`timeQuantum` 表示每个进程运行的时间片长度。需要注意的是，如果 `timeQuantum` 过小，会增加上下文切换的开销；如果 `timeQuantum` 过大，会导致响应时间较长。因此，选择合适的时间片长度是很重要的。