用C语言对N个进程采用动态优先权算法的进程调度，2．每个用来标识进程的进程控制块PCB用结构描述，包括以下字段：进程标识数ID，进程优先数PRIORITY，进程以占用的CPU时间CPUTIME，进程还需占用的CPU时间ALLTIME，进程状态STATE等。 3．优先数改变的原则：进程在就绪队列中呆一个时间片，优先数增加1，进程每运行一个时间片优先数减3。 4．设置调度前的初始状态。 5．将每个时间片内的进程情况显示出来。

以下是动态优先权算法的进程调度的C语言实现，包括进程控制块的结构体定义和进程状态的枚举类型：

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

#define MAX_PROCESS 10 // 最大进程数
#define TIME_SLICE 1 // 时间片长度

// 进程状态
enum process_state {
    READY, // 就绪
    RUNNING, // 运行
    FINISHED // 完成
};

// 进程控制块结构体
struct pcb {
    int pid; // 进程标识数
    int priority; // 进程优先数
    int cpu_time; // 进程已占用的CPU时间
    int all_time; // 进程还需占用的CPU时间
    enum process_state state; // 进程状态
};

// 全局变量
struct pcb processes[MAX_PROCESS]; // 进程数组
int num_processes = 0; // 当前进程数

// 初始化进程数组
void init_processes() {
    int i;
    for (i = 0; i < MAX_PROCESS; i++) {
        processes[i].pid = -1;
        processes[i].priority = 0;
        processes[i].cpu_time = 0;
        processes[i].all_time = 0;
        processes[i].state = FINISHED;
    }
}

// 创建一个进程
void create_process(int pid, int priority, int all_time) {
    if (num_processes < MAX_PROCESS) {
        processes[num_processes].pid = pid;
        processes[num_processes].priority = priority;
        processes[num_processes].cpu_time = 0;
        processes[num_processes].all_time = all_time;
        processes[num_processes].state = READY;
        num_processes++;
    } else {
        printf("Reached maximum number of processes!\n");
    }
}

// 从进程数组中获取优先级最高的就绪进程
// 如果没有就绪进程，返回 -1
int get_highest_priority_process() {
    int i, highest_priority = -1, highest_priority_index = -1;
    for (i = 0; i < num_processes; i++) {
        if (processes[i].state == READY && processes[i].priority > highest_priority) {
            highest_priority = processes[i].priority;
            highest_priority_index = i;
        }
    }
    return highest_priority_index;
}

// 运行一个进程，返回运行的时间片长度
int run_process(int index) {
    int running_time = TIME_SLICE;
    if (processes[index].cpu_time + TIME_SLICE >= processes[index].all_time) {
        running_time = processes[index].all_time - processes[index].cpu_time;
        processes[index].state = FINISHED;
    } else {
        processes[index].state = READY;
    }
    processes[index].cpu_time += running_time;
    processes[index].priority -= 3;
    return running_time;
}

// 更新所有就绪进程的优先级
void update_priorities() {
    int i;
    for (i = 0; i < num_processes; i++) {
        if (processes[i].state == READY) {
            processes[i].priority++;
        }
    }
}

// 显示所有进程的状态
void show_processes() {
    int i;
    for (i = 0; i < num_processes; i++) {
        printf("Process %d: priority=%d, cpu_time=%d, all_time=%d, state=%d\n", 
               processes[i].pid, processes[i].priority, processes[i].cpu_time,
               processes[i].all_time, processes[i].state);
    }
}

int main() {
    // 初始化进程数组
    init_processes();

    // 创建进程
    create_process(1, 1, 3);
    create_process(2, 2, 4);
    create_process(3, 3, 5);

    // 进程调度
    int i, running_process_index;
    for (i = 0; i < 20; i++) {
        printf("Time slice %d:\n", i);

        // 获取优先级最高的就绪进程
        running_process_index = get_highest_priority_process();
        if (running_process_index == -1) {
            printf("No ready process.\n");
            update_priorities();
            continue;
        }

        // 运行进程
        printf("Running process %d.\n", processes[running_process_index].pid);
        run_process(running_process_index);
        show_processes();
        update_priorities();
    }

    return 0;
}

该程序模拟了一个简单的进程调度过程，每个进程都有一个固定的执行时间，然后就会结束。在每个时间片内，程序会查找优先级最高的就绪进程，并运行它一段时间。如果没有就绪进程，程序会更新所有就绪进程的优先级。