对哈，那难道是小于等于？

下一个进程到达时间小于等于前一个刚执行完的CPU占用时间，然后进入队列？这样呢？

揪心...

我写吧，count是干嘛的？
int prio;         
int round;         
int cputime;      
int needtime;
int gettime;   
int count;     //?????????   
char state;        
struct node *next

慢慢写，我明天6点起来看，我是真憋在这了，Thank you，gentle man。

一会我们也断网了，明天再传吧，感觉用循环链表会容易一些，我试试！

我今天早上要用

呵呵，现在来的几步？

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

typedef struct Data
{
    char name[10];
//    int  prio;  没用到、、、
    int  round;
    int  cputime;
    int  needtime;
    int  gettime;
//    int  count;
    char state;  //添加了一个未到达的状态：'N'
}Data;

typedef struct Node
{
    int data[100];
    int front, rear;
}QueueLink;

int N, need;    //N为进程总数, need为时间片
int Time = 0;    //一共要用的时间
Data all[10];
QueueLink run;

/*
把所有的进程存入all数组，按到达时间排序

队列中存入的是该进程在all数组中对应的下标

再依据时间推进，将已到达的进程入队列，再将未执行完的进程入队列

另外round和cputime分别指什么？他们的值完全一样，或许我理解错了吧
*/

int cmp(const void *a, const void *b)
{
    Data *m = (Data *)a;
    Data *n = (Data *)b;
    return m->gettime - n->gettime;
}

void Output(int time)
{
    int i;
    getchar();
    if (time >= 0)    printf("\n当前时间为：%dms\n", time);

    puts("进程名  到达的时间  占用cpu时间 到完成还要得时间 轮转时间片  状态");
    for (i = 0;i < N;++i)
    {
        printf("  %s         %d             %d            %d             %d        %c\n",
            all[i].name, all[i].gettime, all[i].cputime, all[i].needtime, all[i].round, all[i].state);
    }
    printf("\n");
}

void init()
{
    int i;

    memset(all, 0, sizeof(all));

    printf("输入进程的个数：");
    scanf("%d", &N);

    for (i = 0;i < N;++i)
    {
        puts("输入进程名,到达时间及其需要运行的时间：");
        scanf("%s%d%d", all[i].name, &all[i].gettime, &all[i].needtime);
        Time += all[i].needtime;
        all[i].state = 'N';
    }
    qsort(all, N, sizeof(Data), cmp);

    Output(-1);

    printf("请输入时间片长度:");
    scanf("%d", &need);
    printf("输入时间片长度为: %d\n", need);
}

void DeQueue(int *a)
{    //出队列
    *a = run.data[run.front++];
}

void EnQueue(int a)
{    //入队列
    run.data[run.rear++] = a;
}

void fun()
{
    int i, time = 0, now = 0;
    while (time < Time)
    {
        //将未执行进程入队列
        for (i = 0;i < N;++i)
        {
            if (all[i].gettime <= time && all[i].state == 'N')
            {
                EnQueue(i);
                all[i].state = 'W';
            }
        }
        //将未完成的进程入队列
        for (i = 0;i < run.front;++i)
        {
            if (all[i].state != 'F')
            {
                EnQueue(run.data[i]);
            }
        }
        
        //出队列
        DeQueue(&now);
        if (all[now].state == 'F')
        {    //已经完成进程
            continue;
        }

        all[now].state = 'R';    //将当前设定为运行态
        Output(time);

        if (all[now].needtime > need)
        {
            all[now].needtime -= need;
            all[now].round += need;
            all[now].cputime += need;
            all[now].state = 'W';
            time += need;
        }
        else
        {
            time += all[now].needtime;
            all[now].round += all[now].needtime;
            all[now].cputime += all[now].needtime;
            all[now].needtime = 0;
            all[now].state = 'F';
        }
    }
    Output(time);
}

int main( void )
{
    init();
    fun();
    return 0;
}

早安，来得及，好给力啊！