用C、C++、Java语言编程实现对5个进程采用动态优先权调度算法进行调度的过程。数据如下： 5个进程的到达时刻和服务时间见下表，忽略I/O以及其它开销时间，使用动态优先权算法进行调度，优先权初始值为100，请输出各个进程的完成时刻、周转时间、带权周转时间。

好的，以下是使用C语言编写的动态优先权调度程序，可以计算每个进程的完成时间、周转时间和带权周转时间：

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

#define MAX_PROCESS 5

typedef struct {
    int process_id;
    int arrival_time;
    int burst_time;
    int priority;
    int waiting_time;
    int turnaround_time;
    int remaining_time;
} Process;

void dynamic_priority(Process *processes, int n) {
    int current_time = 0;
    int completed = 0;
    float total_waiting_time = 0;
    float total_turnaround_time = 0;

    // Calculate initial waiting time and remaining time for each process
    for (int i = 0; i < n; i++) {
        processes[i].waiting_time = 0;
        processes[i].remaining_time = processes[i].burst_time;
    }

    printf("Process Execution Order: ");

    while (completed != n) {
        // Find process with highest priority and remaining time
        int highest_priority = -1;
        int highest_priority_process = -1;
        for (int i = 0; i < n; i++) {
            if (processes[i].arrival_time <= current_time &&
                processes[i].remaining_time > 0 &&
                (highest_priority == -1 || processes[i].priority < highest_priority)) {
                highest_priority = processes[i].priority;
                highest_priority_process = i;
            }
        }

        // If no process is available at current time, increase time
        if (highest_priority_process == -1) {
            current_time++;
            continue;
        }

        // Execute the process with highest priority and remaining time
        Process *current_process = &processes[highest_priority_process];
        current_process->remaining_time--;
        current_time++;

        // Print execution order
        printf("P%d ", current_process->process_id);

        // If process is completed, calculate waiting and turnaround time
        if (current_process->remaining_time == 0) {
            completed++;
            current_process->waiting_time = current_time - current_process->arrival_time -
                                             current_process->burst_time;
            current_process->turnaround_time = current_process->waiting_time +
                                               current_process->burst_time;
            total_waiting_time += current_process->waiting_time;
            total_turnaround_time += current_process->turnaround_time;
        }

        // Update priority of remaining processes
        for (int i = 0; i < n; i++) {
            if (processes[i].arrival_time <= current_time &&
                processes[i].remaining_time > 0 &&
                i != highest_priority_process) {
                processes[i].priority += 1;
            }
        }
    }

    // Calculate average waiting and turnaround time
    float avg_waiting_time = total_waiting_time / n;
    float avg_turnaround_time = total_turnaround_time / n;

    printf("\n\nAverage Waiting Time: %.2f\n", avg_waiting_time);
    printf("Average Turnaround Time: %.2f\n", avg_turnaround_time);

    // Print process details
    printf("\nProcess Details:\n");
    printf("Process ID\tArrival Time\tBurst Time\tPriority\tWaiting Time\tTurnaround Time\tWeighted Turnaround Time\n");
    for (int i = 0; i < n; i++) {
        Process *current_process = &processes[i];
        printf("%d\t\t%d\t\t%d\t\t%d\t\t%d\t\t%d\t\t\t%.2f\n",
               current_process->process_id,
               current_process->arrival_time,
               current_process->burst_time,
               current_process->priority,
               current_process->waiting_time,
               current_process->turnaround_time,
               (float)current_process->turnaround_time / current_process->burst_time);
    }
}

int main() {
    Process processes[MAX_PROCESS] = {
        {1, 0, 6, 100},
        {2, 2, 4, 100},
        {3, 4, 2, 100},
        {4, 6, 4, 100},
        {5, 8, 6, 100}
    };

    // Run dynamic priority scheduling algorithm
    dynamic_priority(processes, MAX_PROCESS);

    return 0;
}

在此示例中，我们使用了一个结构体来存储每个进程的信息，包括进程ID、到达时间、服务时间、优先级、等待时间、周转时间和剩余时间。我们还实现了动态优先权调度算法，并计算了每个进程的等待时间、周转时间和带权周转时间。您可以直接运行此程序并查看输出结果。