队列的不同存储结构及JAVA实现

队列：队列是指允许在一端进行插入操作，在另一端进行删除操作的线性表。允许插入的一端称为队尾，允许删除的一端称为对头。

             队列中的元素除了具有线性关系外，还具有先进先出的特性。

1.队列的顺序存储结构及实现——循环队列

 将存储队列的数组看成是头尾相接的循环结构，即允许队列直接从数组中下标最大的位置延续到下标最小的位置。这样通过取模操作很容易实现，队列的这种头尾相接的顺序存储结构称为循环对列。      需要设置队头，对尾指针，并且约定:队头指针front指向队头元素的前一个位置，队尾指针rear指向队尾元素。

 

package data.queue;
/**
 * 实现循环队列
 * @author zhouhai
 *
 */
public class QueueArray<T> {
Object [] a;//对象数组
int capacity;//数组的长度
int front;//队首下标
int rear;//队尾下表
/**
 * 默认数组长度为10,构造空队列
 */
public QueueArray(){
	capacity=10;
	front=0;
	front=0;
	a=new Object[capacity];
	
}
/**
 * 以一个初始元素来构造循环队列
 */
public QueueArray(T element){
  this();
  a[0]=capacity;
  rear++;
}
/**
 *以一个初始化元素来构造指定长度的循环队列 
 */
public QueueArray(T element,int size){	
	capacity=size;
	a=new Object[capacity];
	a[0]=element;
	rear++;
}
/**
 * 返回队列长度
 */
public int length(){
	if(isEmpty()){
		return 0;
	}
	return rear>front?rear-front:capacity-(front-rear);
}
/**
 * 入队操作
 */
public void Enqueue(T element){
	if(rear==front&&a[rear]!=null) {
		throw new IndexOutOfBoundsException("队列已满");
	}
	a[rear++]=element;
	rear=rear==capacity?0:rear;//如果rear到头，那么就转头
}
/**
 * 出队操作
 */
public T DeQueue(){
	if(isEmpty()){
		throw new IndexOutOfBoundsException("空对列");
	}
	T value=(T) a[front];
	a[front++]=null;
	front=front==capacity?0:front;
	return value;
}
/**
 * 判断队列是否为空
 */
public boolean isEmpty(){
	return rear==front&&a[rear]==null;
}
}


2.队列的链接存储结构及实现
  队列的链接存储结构——链队列
  链队列是在单链的基础上做了简单的修改，为了使空队列和非空队列的操作一致，链队列也加上了头结点，根据队列的先进先出特性，设置头指针指向链队列的头结点，尾指针指向终端结点。
  
package data.queue;
/**
 * 
 * @author zhouhai

 */
public class LinkQueue<T> {
  private class Node{
	  private T data;//数据域
	  private Node next;//指向下一结点的引用
	  Node(){
		  
	  }
	  Node(T data,Node next){
		  this.data=data;
		  this.next=next;
	  }
  }
  private Node front;//保存队列的头结点
  private Node rear; //保存队列的尾结点
  private int size;  //队列中所含的结点树
  
  public LinkQueue(){
	  front=null;
	  rear=null;
  }
  /**
   * 以指定元素来创建链队列，该队列只有一个结点
   * @param element
   */
  public  LinkQueue(T element){
	  front=new Node(element,null);
	  rear=front;
	  size++;
  }
  /**
   * 返回对垒的长度
   *@Title: length     
   *@throws
   */
  public int length(){
	  return size;
  }
  /**
   * 将新元素加入队列
   */
  public void EnQueue(T element){
	  if(front==null){
		 front=new Node(element,null);
		 rear=front;
	  }else{
	    Node node=new Node();
	    node.data=element;
	    rear.next=node;//让原来的尾结点的next指向node
	    rear=node;//node设为新的尾结点
	  }
	  size++;
  }
  /**
   * 头结点出队列
   */
  public  T DeQueue(T element){
	  if(front==null){
		  throw new ArrayIndexOutOfBoundsException("空栈队列");
	  }else{
		  Node node=front;
		  front=front.next;
		  node.next=null;
		  size--;
		  return node.data;
	  }
  }
  /**
   * 清空栈
   */
  public void clear(){
	  front=rear=null;
	  size=0;
  }
}