使用java队列算法,网站有第三方实现jar.
你也可以自己简单实现一个,可以同数组模拟,也可以用List模拟.
在java中有java.util.Queue接口,你可以详细查看一下java的API相关的说明后在使用.
import java.util.Vector;
@SuppressWarnings({ "unchecked", "serial" })
public class Stat extends Vector {
public void push(Object x) {
super.add(x); // 向队尾添加组件
}
public Object pop() { // 队首元素出队(从队列删除)
Object x = super.elementAt(0); // 返回指定索引处的组件
super.removeElementAt(0); // 删除指定索引处的组件
return x;
public void remove() {
super.removeAllElements(); // removeAllElements()移除全部组件,并将其大小设置为零
public static void main(String[] args) throws java.io.IOException {
Stat s = new Stat();
System.out.println(s.pop());
import?java.util.LinkedList;
public?class?Demo01?{
private?LinkedListObject?linkedList;
public?Demo01()?{
linkedList?=?new?LinkedListObject();
public?void?put(Object?object)?{
linkedList.add(object);
public?Object?get()?{
Object?object?=?null;
if?(linkedList.size()?!=?0)?{
object?=?linkedList.get(0);
linkedList.remove(0);
return?object;
public?boolean?isEmpty()?{
return?true;
}?else?{
return?false;
public?static?void?main(String[]?args)?{
Demo01?demo01?=?new?Demo01();
demo01.put("1");
System.out.println(demo01.get());
System.out.println(demo01.isEmpty());
结果：
false
没java的 发段源代码给你 有兴趣自己慢慢理解
#include time.h
#include dos.h
#include math.h
#include conio.h
#include stdio.h
#include stdlib.h
#include graphics.h
#define ESC 0x1b
#define ENTER 0x0d
#define TRUE 1
#define FALSE 0
/*每隔TIME秒就变换一次优先级*/
/*数据结构*/
/****************************************************************/
enum _Status/*进程状态枚举*/
{
READY =0,/*就绪*/
RUN,/*执行中*/
SUSPEND,/*挂起*/
};
typedef enum _Status Status;
struct _Pcb/*进程结构*/
int PID;/*进程ID,ID为负数的进程为系统后备队列的作业*/
int Time;/*进程运行需要的时间*/
int Prior;/*进程的优先级,越大越优先*/
Status Sts;/*状态*/
struct _Pcb *Next;/*指向本进程队列中下个进程的PCB*/
typedef struct _Pcb PCB;
struct _Batch/*多道处理中的道结构*/
PCB *pcb;/*该道当前正在处理的进程*/
struct _Batch *Next;/*下一道*/
typedef struct _Batch Batch;
/*多道系统相关全局变量*/
PCB *ProcQueue = NULL;/*进程链表,按优先级从大到小排列*/
Batch *BatchQueue = NULL;/*系统多道链表*/
/*动态优先权抢占式调度算法及相关函数声明*/
int InitBatchs(int n);/*初始化多道系统,n为道数*/
int InsertProc(int prior, int time);/*向进程链表中按优先级大小插入一个新进程*/
int InsertIDLE();/*向进程队列中加入后备进程,当系统空闲时将被调入*/
int SortProcQueue();/*将进程链表按优先级从大到小排列*/
int AddBatch();/*增加系统道数*/
int DeleteBatch();/*减少系统道数*/
int UnSuspendProc(int id);/*解除ID为id的进程的挂起状态*/
int UpdateBatchs();/*多道系统根据进程链表进行更新,并将执行完毕的进程删除*/
int PassSeconds(int n);/*系统经过n秒后计算数据并进行优先级调度*/
/*各函数的定义*/
int InitBatchs(int n)
int i;
for (i=0; in; ++i)
AddBatch();
return (UpdateBatchs());
int InsertProc(int prior, int time)
static int sysid = 0;/*该系统已经加入过多少进程,此值将是新进程的ID*/
PCB *last,*now,*pcb;
pcb = (PCB*)malloc(sizeof(PCB));
if (pcb == NULL) return FALSE;
pcb-Prior = prior;
pcb-Time = time;
pcb-PID = (++sysid);
pcb-Sts = READY;
if (ProcQueue == NULL)/*如果进程队列为空*/
ProcQueue = pcb;
pcb-Next = NULL;
return TRUE;
last = ProcQueue;
now = last-Next;
if (pcb-Prior last-Prior)/*pcb将排在队头*/
pcb-Next = ProcQueue;
while ((now != NULL) (pcb-Prior now-Prior))/*寻找插入位置*/
last = now;
last-Next = pcb;
pcb-Next = now;
int InsertIDLE()
PCB *now = ProcQueue;
PCB *idle = (PCB*)malloc(sizeof(PCB));
if (idle == NULL) return FALSE;
idle-PID = -1;
idle-Prior = -1;
idle-Sts = SUSPEND;
idle-Time = -1;
idle-Next = NULL;
if (ProcQueue == NULL)
ProcQueue = idle;
while(now-Next != NULL)
now = now-Next;
now-Next = idle;
int SortProcQueue()
{ /*冒泡排序*/
PCB *last, *now;
int b = FALSE;/*上次遍历是否无交换产生*/
if (ProcQueue==NULL || ProcQueue-Next==NULL)/*如果链表中无进程或只有一个进程*/
return FALSE;
while (!b)
b = TRUE;
last=ProcQueue;
now=last-Next;
if (last-Prior now-Prior)
ProcQueue = now;
last-Next = now-Next;
now-Next = last;
b = FALSE;
while (now-Next!=NULL)
if ((now-Prior)(now-Next-Prior))
now-Next = now-Next-Next;
last-Next-Next = now;
else
last = last-Next;
int AddBatch()
Batch *bt = (Batch*)malloc(sizeof(Batch));
if (bt==NULL) return FALSE;
bt-Next = BatchQueue;
BatchQueue = bt;
bt-pcb = NULL;
return (InsertIDLE());
int DeleteBatch()
Batch *bt = BatchQueue;
if (BatchQueue==NULL || BatchQueue-Next==NULL)/*如果只剩最后一道则不删除*/
if (ProcQueue==NULL || ProcQueue-Next==NULL)/*如果只有最后一个后备空闲进程*/
return FALSE;/**/
while (now-Next != NULL)/*查找到最后一个进程,该进程必定是后备空闲进程*/
if (now==NULL || now-PID=0)/*未查找到后备进程*/
free(now);
last-Next = NULL;
BatchQueue = BatchQueue-Next;
free(bt);
int UnSuspendProc(int id)
if (ProcQueue==NULL) return FALSE;
while (now != NULL)
if (now-PID == id)
now-Sts = READY;
int UpdateBatchs()
PCB *last = ProcQueue, *now;
while (bt != NULL)
bt = bt-Next;
if (ProcQueue == NULL) return TRUE;
while (last-Sts==RUN last-PID=0 last-Time=0)
ProcQueue = ProcQueue-Next;
free(last);
if (now-Sts==RUN now-PID=0 now-Time=0)/*如果该进程是运行中的一般进程并已执行完毕*/
bt = BatchQueue;
now = ProcQueue;
while (bt != NULL now != NULL)
bt-pcb = now;
now-Sts = RUN;
if (now-Sts == RUN)
now-Sts = SUSPEND;
int PassSeconds(int n)
static int time = 0;
int i=0, ProcEnd = FALSE;
PCB *pcb = ProcQueue;
if (bt == NULL) return FALSE;
time += n;
if (time=TIME)
i = time/TIME;/*经过多少时间段*/
time = time%TIME;
while (bt != NULL)/*更新进程运行时间*/
if (bt-pcb-PID=0)
bt-pcb-Time -= n;
if (bt-pcb-Time = 0)/*进程结束*/
ProcEnd = TRUE;
if (i 0)
while (pcb != NULL)/*更新进程优先权（动态优先权）*/
if (pcb-Sts == RUN pcb-PID=0)/*运行的进程优先权降低*/
pcb-Prior -= i;
if (pcb-Prior 0)
pcb-Prior = 0;
else if (pcb-Sts == SUSPEND pcb-PID=0)/*挂起的进程优先权升高*/
pcb-Prior += i;
pcb = pcb-Next;
if (i0)
SortProcQueue();/*如果优先级有变动则重新排序*/
if (ProcEnd || i0)
UpdateBatchs();/*更新多道进程*/
/*图形界面相关函数*/
/*表格的单位宽度和高度*/
void *black=NULL;/*背景色方格,使用它擦出表格中的图形*/
int InitGraph()/*初始化图形界面*/
int GraphDriver; /* The Graphics device driver */
int GraphMode; /* The Graphics mode value */
int ErrorCode;
GraphDriver = DETECT; /* Request auto-detection */
initgraph( GraphDriver, GraphMode, "" );
ErrorCode = graphresult(); /* Read result of initialization*/
if( ErrorCode != grOk )
{ /* Error occured during init */
printf(" Graphics System Error: %s\n", grapherrormsg( ErrorCode ) );
getch();
cleardevice();
black = (void*)malloc(imagesize(1,1,WIDTH-1,HEIGHT-1));
getimage(1,1,WIDTH-1,HEIGHT-1,black);
DrawFrame();
DrawData();
int DrawFrame()/*画边框和表头*/
settextjustify(CENTER_TEXT, CENTER_TEXT);
settextjustify(LEFT_TEXT, TOP_TEXT);
moveto(0,HEIGHT);
lineto(0,HEIGHT);
int DrawData()/*绘制系统数据*/
int numRun=0, numSus=0, numRed=0;/*运行挂起和就绪的进程各有多少*/
PCB* now = ProcQueue;
int x=0, y=0;
switch(now-Sts)
case RUN:
x = WIDTH*1;
break;
case SUSPEND:
case READY:
if (now-Sts==RUN)/*该进程为正在运行的进程*/
putimage(x-WIDTH+1,y+1,black,COPY_PUT);
if (now-PID=0)/*该进程不是后备进程*/
putimage(x+1,y+1,black,COPY_PUT);
putimage(x+1+WIDTH,y+1,black,COPY_PUT);
int DlgGetNum(char *buf,int l,int t,int r,int b,int gettime)
char ch;
int pos=0;
bar(l,t,r,b);
if (gettime)
while (1)
ch = getch();
if (ch == ENTER)/*如果输入了回车键*/
if(pos!=0)/*如果位置不在第一位(回车键不准第一个输入)*/
buf[pos]='\0';
buf[pos++]=ch;
else if (ch == ESC)
else/*其他按键均按BackSpace处理*/
--pos;
if (pos0)
{ pos=0; buf[pos]='\0';}
int NewProcDlg()
PCB *pcb;
void* bg = (void*)malloc(imagesize(l,t,r,b));
getimage(l,t,r,b,bg);
flushall();
/*******输入优先级**********/
if (!DlgGetNum(buf,l,t,r,b,FALSE))
goto exit;
prior = atoi(buf);
/*******输入时间**********/
pos=0;
if (!DlgGetNum(buf,l,t,r,b,TRUE))
time = atoi(buf);
InsertProc(prior, time);
exit:
putimage(l,t,bg,COPY_PUT);
free(bg);
int gprintf( int xloc, int yloc, char *fmt, ... )/*图形系统中的格式输出*/
va_list argptr; /* Argument list pointer */
int cnt; /* Result of SPRINTF for return */
va_start( argptr, format ); /* Initialize va_ functions */
cnt = vsprintf( str, fmt, argptr ); /* prints string to buffer */
outtextxy( xloc, yloc, str ); /* Send string in graphics mode */
va_end( argptr ); /* Close va_ functions */
return( cnt ); /* Return the conversion count */
/*main函数*/
int main()
clock_t start=0, end=0;
char kb;
InitGraph();
start = end = clock();
while (!kbhit())
start = clock();
PassSeconds(1);
kb = getch();
switch (kb)
case ESC:
closegraph();
return 0;
case 'w':
UpdateBatchs();
case 's':
DeleteBatch();
case 'i':
NewProcDlg();
以上就是土嘎嘎小编为大家整理的先进先出java算法代码相关主题介绍,如果您觉得小编更新的文章只要能对粉丝们有用,就是我们最大的鼓励和动力,不要忘记讲本站分享给您身边的朋友哦！！