通过统计各队列任务处理时间来动态地调整队列任务优先级，基于该场景，结合多级反馈队列调度算法和加权公平队列调度算法，C语言实现

首先，我们需要了解多级反馈队列调度算法和加权公平队列调度算法的基本思想。多级反馈队列调度算法将进程按照优先级划分为多个队列，每个队列都有一个优先级，优先级高的队列处理完任务后，才会处理优先级低的队列中的任务。加权公平队列调度算法则是根据各队列的权重来分配资源，权重越高的队列获得的资源越多。

基于以上思想，我们可以实现一个动态调整优先级的队列调度算法。具体实现步骤如下：

1. 定义一个队列结构体，包含队列名称、优先级、权重和任务处理时间等信息。

2. 定义一个任务结构体，包含任务名称和所属队列等信息。

3. 初始化所有队列，并设置各队列的优先级和权重。

4. 不断循环，从各队列中选择一个任务进行处理。

5. 根据当前队列的任务处理时间，动态调整队列的优先级。

6. 根据队列的权重，计算出各队列获得资源的比例，分配资源。

7. 根据队列的优先级，选择下一个要处理的任务。

8. 重复步骤4-7，直到所有任务处理完毕。

下面是一份简单的C语言代码实现：

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

#define MAX_QUEUE_NUM 10
#define MAX_TASK_NUM 100

typedef struct {
    char name[20];
    int priority;    // 优先级
    int weight;      // 权重
    int time;        // 任务处理时间
    int processed;   // 已处理时间
} Task;

typedef struct {
    char name[20];
    int priority;    // 优先级
    int weight;      // 权重
    int task_num;    // 队列中任务数
    Task *tasks[MAX_TASK_NUM];
} Queue;

int queue_num = 0;
Queue queues[MAX_QUEUE_NUM];

int get_next_task(Queue *queue);
void adjust_priority(Queue *queue);
void schedule();

int main() {
    // 初始化队列
    Queue queue1 = {"Queue1", 0, 5, 0};
    queues[0] = queue1;
    Queue queue2 = {"Queue2", 1, 3, 0};
    queues[1] = queue2;

    // 初始化任务
    Task task1 = {"Task1", 0, 0, 10, 0};
    queues[0].tasks[0] = &task1;
    queues[0].task_num++;
    Task task2 = {"Task2", 1, 0, 5, 0};
    queues[1].tasks[0] = &task2;
    queues[1].task_num++;

    schedule();

    return 0;
}

int get_next_task(Queue *queue) {
    // 选择下一个要处理的任务
    int i;
    Task *task = NULL;
    for (i = 0; i < queue->task_num; i++) {
        if (queue->tasks[i]->processed >= queue->tasks[i]->time) {
            // 任务已处理完，移除任务
            int j;
            for (j = i; j < queue->task_num - 1; j++) {
                queue->tasks[j] = queue->tasks[j+1];
            }
            queue->task_num--;
            continue;
        }
        if (task == NULL || task->priority < queue->tasks[i]->priority) {
            task = queue->tasks[i];
        }
    }
    return task == NULL ? -1 : task - queue->tasks[0];
}

void adjust_priority(Queue *queue) {
    // 动态调整队列优先级
    int i, processed_time = 0;
    for (i = 0; i < queue->task_num; i++) {
        processed_time += queue->tasks[i]->processed;
    }
    queue->priority = processed_time / queue->task_num / 2;
}

void schedule() {
    // 调度任务
    int i;
    while (1) {
        int total_weight = 0;
        for (i = 0; i < queue_num; i++) {
            total_weight += queues[i].weight;
        }
        int j, allocated_time = 10;  // 假设总共有10个时间单位可用
        for (i = 0; i < queue_num; i++) {
            int time = allocated_time * queues[i].weight / total_weight;
            for (j = 0; j < time; j++) {
                int task_index = get_next_task(&queues[i]);
                if (task_index == -1) {
                    break;
                }
                Task *task = queues[i].tasks[task_index];
                task->processed++;
                if (task->processed >= task->time) {
                    printf("Task %s finished.\n", task->name);
                }
            }
            adjust_priority(&queues[i]);
        }
        int finished = 1;
        for (i = 0; i < queue_num; i++) {
            if (queues[i].task_num > 0) {
                finished = 0;
                break;
            }
        }
        if (finished) {
            break;
        }
    }
}

在上面的代码实现中，我们只模拟了两个队列和两个任务，实际应用中需要根据具体场景进行调整。同时，我们也可以根据需要对队列的优先级调整算法和权重分配算法进行优化。