利用C语言编写Linux系统时间片轮转算法程序，基本步骤如下： a) 每个PCB模块的基本信息：进程名称，需要运行的时间，已用CPU时间，进程状态，时间片。 b) 程序的基本模块： 1> 进程的创建 由create2（）函数完成。采用链表的方法创建五个进程，进程名和进程所需运行的时间，并初始化其状态为w(等待)，每个时间片的运行时间为2，且把就绪队列的第一个进程放入CPU运行，使就绪队列的头指针指向第二个进程。 2> 轮转法插入函数，当一个时间片的时间已到，而进程又未完成就需把进程插入到就绪队列的尾部，该模块由insert 函数完成。 3> 时间片轮转法的实现 由roundrun函数完成。程序记下进程的运行时间，并计算剩下需运行的时间。如果剩下需运行的时间变为0时就把它插到完成队列，设其运行状态为F（完成）。如果时间片的时间到了而进程还未完成，就把它插到就绪队列的队尾，同时把就绪队列的第一个进程投入运行。 4> 输出模块。包括标题的输出，进程的输出，运行过程的输出

以下是一个简单的时间片轮转算法程序的实现，包含了进程的创建、插入、轮转和输出模块：

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

// 进程控制块结构体
typedef struct PCB {
    char name[10];  // 进程名称
    int need_time;  // 需要运行的时间
    int used_time;  // 已用CPU时间
    char state;     // 进程状态
    int time_slice; // 时间片
    struct PCB *next; // 下一个进程
} PCB;

// 初始化进程控制块
void init_pcb(PCB *p, char *name, int need_time) {
    int i;
    for (i = 0; name[i]; i++) {
        p->name[i] = name[i];
    }
    p->name[i] = '\0';
    p->need_time = need_time;
    p->used_time = 0;
    p->state = 'w'; // 等待状态
    p->time_slice = 2;
    p->next = NULL;
}

// 创建进程
void create_processes(PCB **head) {
    int i;
    char name[5];
    int need_time;
    PCB *p, *tail;
    for (i = 0; i < 5; i++) {
        sprintf(name, "P%d", i); // 生成进程名
        printf("请输入进程 %s 需要运行的时间：", name);
        scanf("%d", &need_time);
        p = (PCB *)malloc(sizeof(PCB)); // 分配内存
        init_pcb(p, name, need_time); // 初始化进程控制块
        if (*head == NULL) {
            *head = p; // 链表头指针
        } else {
            tail->next = p; // 添加到链表尾部
        }
        tail = p;
    }
}

// 输出进程信息
void output_processes(PCB *head) {
    printf("进程名\t需要运行时间\t已用CPU时间\t状态\n");
    while (head) {
        printf("%s\t%d\t\t%d\t\t%c\n", head->name, head->need_time, head->used_time, head->state);
        head = head->next;
    }
}

// 时间片轮转调度
void round_robin(PCB **head, PCB **running, PCB **completed) {
    PCB *p, *tail;
    p = *head;
    tail = NULL;
    while (p) {
        // 如果进程在运行，更新已用CPU时间和剩余时间
        if (p == *running) {
            p->used_time += p->time_slice;
            p->need_time -= p->time_slice;
            // 如果进程已经完成，将其添加到完成队列
            if (p->need_time == 0) {
                p->state = 'F'; // 完成状态
                if (*completed == NULL) {
                    *completed = p;
                } else {
                    tail->next = p;
                }
                tail = p;
                *running = NULL; // 清空运行队列
            } else {
                // 如果进程没有完成，将其添加到就绪队列尾部
                p->state = 'r'; // 就绪状态
                if (tail == NULL) {
                    *head = p;
                } else {
                    tail->next = p;
                }
                tail = p;
                *running = (*running)->next; // 切换到下一个进程
            }
            break;
        }
        p = p->next;
    }
}

// 插入函数
void insert(PCB **head, PCB *p) {
    PCB *tail;
    if (*head == NULL) {
        *head = p;
    } else {
        tail = *head;
        while (tail->next) {
            tail = tail->next;
        }
        tail->next = p;
    }
}

int main() {
    PCB *head, *running, *completed;
    head = running = completed = NULL;
    create_processes(&head); // 创建进程
    running = head; // 将第一个进程加入运行队列
    head = head->next; // 将就绪队列的头指针指向第二个进程
    printf("进程创建完成！\n");
    output_processes(running); // 输出初始进程信息
    int i;
    for (i = 1; completed != NULL; i++) {
        printf("第%d次运行：\n", i);
        round_robin(&head, &running, &completed); // 时间片轮转调度
        if (running == NULL && head != NULL) {
            running = head;
            head = head->next;
        }
        output_processes(running); // 输出运行后的进程信息
        printf("已完成的进程：\n");
        output_processes(completed); // 输出已完成的进程信息
        printf("\n");
    }
    printf("所有进程已完成！\n");
    return 0;
}

这个程序将会创建5个进程，每个进程需要运行一定的时间。程序会按照时间片轮转算法的方式运行进程，并输出每次运行后的进程信息和已完成的进程信息。