基于数组的循环队列和基于链表的队列

数据的插入和取出涉及对当前数据量nItems属性的修改，大量的插入、移除操作时，对nItems属性的操作可能影响性能，可参考不包含数据项个数属性的队列实现。

基于数组的循环队列

包含数据项个数属性

package datastructure.c4.queue.queuedef;

public class Queue {
	private int maxSize;
	private long[] queArray;
	private int front;
	private int rear;
	private int nItems;
	public Queue(int s){
		maxSize=s;
		queArray=new long[maxSize];
		front=0;
		rear=-1;
		nItems=0;
	}
	public void insert(long j){
		if(rear==maxSize-1){
			rear=-1;
		}
		queArray[++rear]=j;
		nItems++;
	}
	public long remove(){
		long temp=queArray[front++];
		if(front==maxSize){
			front=0;
		}
		nItems--;
		return temp;
	}
	public long peekFront(){
		return queArray[front];
	}
	public boolean isEmpty(){
		return (nItems==0);
	}
	public boolean isFull(){
		return (nItems==maxSize);
	}
	public int size(){
		return nItems;
	}
}

package datastructure.c4.queue.queuedef;

public class QueueApp {
	public static void main(String[] args) {
		Queue theQueue=new Queue(5);
		theQueue.insert(10);
		theQueue.insert(20);
		theQueue.insert(30);
		theQueue.insert(40);
		theQueue.remove();
		theQueue.remove();
		theQueue.remove();
		theQueue.insert(50);
		theQueue.insert(60);
		theQueue.insert(70);
		theQueue.insert(80);
		
		while(!theQueue.isEmpty()){
			long n = theQueue.remove();
			System.out.print(n);
			System.out.print("  ");
		}
		System.out.println("");
	}
}

不包含数据项个数属性

package datastructure.c4.queue.nonitems;

public class QueueWithoutN {
	private int maxSize;
	private long[] queArray;
	private int front;
	/**
	 * rear作为写值的标志，插入时会在rear的下一个位置写入新值，
	 * 当rear=maxSize-1，也就是rear指向的数组的最后一个值，
	 * 要将rear设为-1，形成循环队列
	 */
	private int rear;
	public QueueWithoutN(int s){
		maxSize=s+1;
		queArray=new long[maxSize];
		front=0;
		rear=-1;
	}
	/**
	 * 新值位于rear的后一个位置
	 * @param j
	 */
	public void insert(long j){
		if(rear==maxSize-1){
			rear=-1;
		}
		queArray[++rear]=j;
	}
	/**
	 * 取值时取front位置当前值，front后移一位
	 * 当front是数组最后一个元素时，后移一位后front=maxSize，
	 * 令front=0
	 * @return
	 */
	public long remove(){
		long temp=queArray[front++];
		if(front==maxSize){
			front=0;
		}
		return temp;
	}
	public long peek(){
		return queArray[front];
	}
	/**
	 * 1、rear+1==front说明下次写入值会覆盖front当前值，说明队列为空
	 * 2、front+maxSize-1==rear --> rear-front=maxSize-1（数组下标最大值），
	 * 只能rear=maxSize-1，front=0（front是数组第一个元素，rear是数组最后一个元素），
	 * 下次写入也会覆盖front当前值
	 * @return front与rear位置差1的所有情况返回true
	 */
	public boolean isEmpty(){
		return (rear+1==front || front+maxSize-1==rear);
	}
	/**
	 * 队列为空时rear位于front前一个位置，
	 * 写满时，rear位于front前两个位置
	 * @return front与rear位置差2的所有情况返回true
	 */
	public boolean isFull(){
		return (rear+2==front || front+maxSize-2==rear);
	}
	/**
	 * 1、rear>=front，说明未循环，元素数量为rear与front之间的元素数
	 * 2、rear<front，说明已循环插入，(maxSize-front)为front到数组最后的元素数，
	 * (rear+1)为数组开始（下标为0）到rear间的元素数
	 * @return
	 */
	public int size(){
		if(rear>=front){
			return rear-front+1;
		}else{
			return (maxSize-front)+(rear+1);
		}
	}
}

基于双端链表的队列

package datastructure.c5.linklist.linkqueue;

public class Link {
	public long dData;
	public Link next;
	public Link(long d){
		dData=d;
	}
	public void displayLink(){
		System.out.print(dData+"  ");
	}
}

package datastructure.c5.linklist.linkqueue;

public class FirstLastList {
	private Link first;
	private Link last;
	public FirstLastList(){
		first=null;
		last=null;
	}
	public boolean isEmpty(){
		return first==null;
	}
	public void insertLast(long dd){
		Link newLink =new Link(dd);
		if(isEmpty()){
			first=newLink;
		}else{
			last.next=newLink;
		}
		last=newLink;
	}
	public long deleteFirst(){
		long temp=first.dData;
		if(first.next==null){
			last=null;
		}
		first=first.next;
		return temp;
	}
	public void displayList(){
		Link current=first;
		while(current!=null){
			current.displayLink();
			current=current.next;
		}
		System.out.println("");
	}
}

package datastructure.c5.linklist.linkqueue;

public class LinkQueue {
	private FirstLastList theList;
	public LinkQueue(){
		theList=new FirstLastList();
	}
	public boolean isEmpty(){
		return theList.isEmpty();
	}
	public void insert(long j){
		theList.insertLast(j);
	}
	public long remove(){
		return theList.deleteFirst();
	}
	public void displayQueue(){
		System.out.print("Queue (front-->rear):");
		theList.displayList();
	}
}

package datastructure.c5.linklist.linkqueue;

public class LinkQueueApp {
	public static void main(String[] args) {
		LinkQueue theQueue=new LinkQueue();
		theQueue.insert(20);
		theQueue.insert(40);
		
		theQueue.displayQueue();
		
		theQueue.insert(60);
		theQueue.insert(80);
		
		theQueue.displayQueue();
		
		theQueue.remove();
		theQueue.remove();
		
		theQueue.displayQueue();
	}
}