时间片轮转调度算法，C语言程序，采用链表的方法创建五个进程，进程名和进程所需运行的时间，并初始化其状态为w(等待)，每个时间片的运行时间为2，且把就绪队列的第一个进程放入CPU运行，使就绪队列的头指针指向第二个进程。

以下是采用链表的方式创建五个进程，并实现时间片轮转调度算法的C语言程序，每个进程包括进程ID、需要的CPU时间和状态：

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

#define TIME_SLICE 2 // 时间片长度

typedef struct process {
    int pid; // 进程ID
    int burst_time; // 需要的CPU时间
    char state; // 进程状态（w:等待，r:运行，f:完成）
    struct process *next; // 下一个进程
} process;

int main() {
    process *head = NULL, *tail = NULL, *current, *next;
    int i, time = 0, turnaround_time = 0, waiting_time = 0, n = 5;

    // 创建五个进程，并初始化状态为等待
    for (i = 0; i < n; i++) {
        current = (process *)malloc(sizeof(process));
        current->pid = i + 1;
        printf("请输入进程%d需要的CPU时间：", current->pid);
        scanf("%d", &current->burst_time);
        current->state = 'w';
        current->next = NULL;
        if (head == NULL) {
            head = current;
        } else {
            tail->next = current;
        }
        tail = current;
    }

    // 时间片轮转调度算法
    while (1) {
        current = head;
        while (current != NULL) {
            if (current->state == 'r') {
                // 当前进程正在运行，减少剩余时间
                current->burst_time -= TIME_SLICE;
                time += TIME_SLICE;
                if (current->burst_time <= 0) {
                    // 当前进程完成
                    current->state = 'f';
                    turnaround_time += time;
                    waiting_time += time - TIME_SLICE * current->pid;
                }
            }
            if (current->state == 'w') {
                // 当前进程在等待状态，将其放入CPU运行
                current->state = 'r';
                if (current->next != NULL) {
                    // 将就绪队列的头指针指向下一个进程
                    next = current->next;
                    current->next = next->next;
                    next->next = head;
                    head = next;
                }
            }
            current = current->next;
        }
        if (head->state == 'f') {
            // 所有进程都完成
            break;
        }
    }

    // 输出每个进程的信息
    printf("\n进程ID\t需要的CPU时间\t响应时间\t等待时间\n");
    current = head;
    while (current != NULL) {
        printf("%d\t%d\t\t%d\t\t%d\n", current->pid, current->burst_time + TIME_SLICE * (current->state == 'f'), turnaround_time - TIME_SLICE * current->pid - (current->state == 'f'), waiting_time - TIME_SLICE * (current->pid - 1) - (current->state == 'f'));
        current = current->next;
    }

    // 输出平均响应时间和平均等待时间
    printf("\n平均响应时间 = %.2f\n", (float)turnaround_time / n);
    printf("平均等待时间 = %.2f\n", (float)waiting_time / n);

    // 释放进程链表的内存空间
    current = head;
    while (current != NULL) {
        next = current->next;
        free(current);
        current = next;
    }

    return 0;
}

注意，在这个程序中，我们使用了一个指向就绪队列头部的指针head，每次将就绪队列的头指针指向下一个进程，以实现时间片轮转调度算法。同时，我们还使用了一个状态变量state，表示进程的状态，其中w表示等待，r表示运行，f表示完成。