java算法：FIFO队列

java算法：FIFO队列

FIFO队列是一个ADT，由两个基本操作构成：插入（放入）一个新项，删除（得到）最早插入的项。

例1：FIFO队列ADT接口

Java代码

1. interface intQueue{   
2.     intQueue(int q);   
3.     int empty();   
4.     void put(int q);   
5.     int get();   
6. }  

interface intQueue{
	intQueue(int q);
	int empty();
	void put(int q);
	int get();
}

使用数组或链表，在常数时间内实现FIFO队列ADT的get和put操作。

例2：FIFO队列的链表实现

Java代码

1. public class intQueue{   
2.     private class Node{   
3.         int item;   
4.         Node next;   
5.         Node(int item){   
6.             this.item = item;    
7.             next = null;   
8.         }   
9.     }   
10.     private Node head, tail;   
11.     intQueue(int max){   
12.         head = null;   
13.         tail = null;   
14.     }   
15.     boolean empty(){   
16.         return (head == null);   
17.     }   
18.     void put(int item){   
19.         Node t = tail;   
20.         tail = new Node(item);   
21.         if(empty()){   
22.             head = tail;       
23.         }else{   
24.             t.next = tail;   
25.         }   
26.     }   
27.     int get(){   
28.         int v = head.item;   
29.         Node t = head.next;   
30.         head = t;   
31.         return v;   
32.     }   
33. }  

public class intQueue{
	private class Node{
		int item;
		Node next;
		Node(int item){
			this.item = item; 
			next = null;
		}
	}
	private Node head, tail;
	intQueue(int max){
		head = null;
		tail = null;
	}
	boolean empty(){
		return (head == null);
	}
	void put(int item){
		Node t = tail;
		tail = new Node(item);
		if(empty()){
			head = tail;	
		}else{
			t.next = tail;
		}
	}
	int get(){
		int v = head.item;
		Node t = head.next;
		head = t;
		return v;
	}
}

数组要求自始自终都要为预计的最大的项数保留足够的空间，而链表表示使用的空间与数据结构中的元素个数成比例，但要为指针分配额外的空间，并且每个操作都要花分配和释放内存的额外时间。

例3：FIFO队列的数组实现

Java代码

1. public class intQueue{   
2.   
3.     private int[] q;   
4.     private int N, head, tail;   
5.   
6.     intQueue(int max){   
7.         q = new int[maxN + 1];   
8.         head = N;   
9.         tail = 0;   
10.     }   
11.     boolean empty(){   
12.         return (head%N == tail);   
13.     }   
14.     void put(int item){   
15.         q[tail++] = item;   
16.         tail = tail%N;   
17.     }   
18.     int get(){   
19.         head = head%N;   
20.         return q[head++];   
21.     }   
22. }  

public class intQueue{

	private int[] q;
	private int N, head, tail;

	intQueue(int max){
		q = new int[maxN + 1];
		head = N;
		tail = 0;
	}
	boolean empty(){
		return (head%N == tail);
	}
	void put(int item){
		q[tail++] = item;
		tail = tail%N;
	}
	int get(){
		head = head%N;
		return q[head++];
	}
}

拓展：双端队列，删除随机项队列（如果第一项则是FIFO队列，如果最后一项则是栈），或者删除关键字项，自定义项等。

来源：https://www.cnblogs.com/wuyida/archive/2012/10/26/6301150.html