队列 java实现

package com.shine.queue;
/*
* 队列的接口
*/
public interface QQueue<T> {
boolean isEmpty();
void enqueue(T x);//入队操作
T dequeue(); //出队操作，返回队头元素
}




package com.shine.queue;
/*
* 顺序队列：
* 当队列为空时，设置队头、队尾下标front=rear=-1
* 当第一个元素入队时，front=rear=0,同时改变两个下标
* 进行入队出队操作时，front、rear随之变化
*
* 顺序队列的两个缺点：
* 1.假溢出，一次入队出队操作需要同时改变两个下标
* 2.顺序队列之所以会出现假溢出现象，就是因为顺序队列的存储单元没有重复使用机制。
*   解决的办法是将顺序队列设计成循环结构
*  
* 顺序循环队列：
* 1.队头队尾元素按照以下规律进行变化
*    front = (front+1)%length
*    rear = (rear+1)%length
* 2.约定rear及队列为空条件
*   约定rear为下一个入队元素的位置，队列为空的条件是front==rear。初始空队列为front==rear==0
*   入队操作只需要改变rear、出队操作只需要改变front。不需要同时改变两个下标
* 3.约定队列满的条件
*   约定队列满的条件是队列中仍有一个位置是空位置，front=(rear+1)%length
*  
*   以下是顺序循环队列类
*/
public class SeqQueue<T> implements QQueue<T> {
    private Object element[];
    private int front,rear;
    public SeqQueue(int length){
    if(length<64)
    length=64;
    this.element = new Object[Math.abs(length)];
    this.front=this.rear=0;
    }
    public SeqQueue(){
    this(64);
    }
@Override
public boolean isEmpty() {
return this.front==this.rear;
}

@Override
public void enqueue(T x) {
if(x==null)
return;
if(this.front==(this.rear+1)%this.element.length){//当队列已满时
Object[] temp = this.element;
this.element = new Object[temp.length*2];
    int i= this.front,j=0;
    while(i!=this.rear)//按照队列元素次序复制数组
    {
    this.element[i]=temp[i];
    i = (i+1)%temp.length;
    j++;
    }
    this.front = 0;
    this.rear = j;
}
this.element[this.rear] = x;
this.rear = (this.rear+1)%this.element.length;
}

@Override
public T dequeue() {
if(isEmpty())
return null;
T temp = (T)this.element[this.front];
this.front = (this.front+1)%this.element.length;
return temp;
}
    @Override
    public String toString() {
    String str = "(";
    if(!isEmpty()){
    str += this.element[this.front].toString();
    int i = (this.front+1)%this.element.length;
    while(i!=this.rear){
    str += ","+this.element[i].toString();
    i = (i+1)%this.element.length;
    }
    }
    return str;
    }
}




package com.shine.queue;

import com.shine.linearList.Node;
/*
* 链式队列：
* 以不带头结点的单链表表示链式队列。设指针front、rear分别指向队头和队尾节点，入队操作将节点连在队尾节点之后，并
* 使rear指向新的队尾节点；出队操作，当队列不空时，取得队头节点的值，删除该节点，并使front指向后继节点
* 初始空队列的条件是front==rear==null，队列空条件是front==null&&rear==null
*/
public class LinkedQueue<T> implements QQueue<T> {
    private Node<T> front,rear;
    public LinkedQueue(){
    this.front=this.rear=null;
    }
@Override
public boolean isEmpty() {
return this.front==null&&this.rear==null;
}

@Override
public void enqueue(T x) {
if(x==null)
return;
Node<T> q = new Node<T>(x,null);
if(this.front==null)//如果是空队列
this.front=q;
else this.rear.next = q;
this.rear = q;
}

@Override
public T dequeue() {
if(isEmpty())
return null;
T temp = this.front.data;
this.front = this.front.next;
if(this.front==null)
this.rear = null;
return temp;
}
}