Java数据结构-线性表之队列

队列(Queue)的定义：只允许在一端进行插入另一端进行删除操作的线性表。允许插入的一端称为队尾(rear) ，允许删除的一端称为队头(front)。 具有“先进先出”特点。

队列也是线性表，所以也存在顺序结构和链式结构。

顺序队列：

对于队列，入队操作的解释为：
(是在队尾追加一个元素，不需要移动任何元素，因此时间复杂度为0(1)。)

1. 判断队列是否已满；
2. 如果没满则先给队尾元素赋值;
3. 然后将队尾指针后移一位（对队尾指针赋值，Q->rear = Q->rear+1 )。

出队操作解释为：
(队列中的所有元素都得向前移动，以保证队列的队头（也就是下标为0的位置）不为空，此时的时间复杂度为0(n)。)

1. 判断队列是否为空；
2. 若不为空则将对首元素取出用来返回；
3. 然后将对首指针后移一位（对队首指针赋值，Q->front = Q->front+1 )。
4. 队列是否为空判断：队首指针和队尾指针进行判断是否相等。

队列的实际长度：队尾指针-对首指针；也可以通过设定一个变量来进行存储。

下面是我的顺序队列的Java实现：

package com.phn.queue;
/**
 * @author 潘海南
 * @Email [email protected]
 * @TODO 顺序队列
 * @date 2015年7月20日
 */
public class FOArrayQueue {
    //默认队列容量
    private static final int DEFUALT_CAPACITY = 100;
    //队列存储数据元素的数组
    private Object[] data = null;
    //队列的实际大小
    private int size;
    //队列的对首索引
    private int front;
    //队列的队尾索引
    private int rear;
    //队列的实际容量
    private int capacity;
    /**
     * @TODO 无参构造函数，初始化队列
     */
    public FOArrayQueue() {
        this(DEFUALT_CAPACITY);
    }
    /**
     * @param initialCapacity 队列初始化容量
     */
    public FOArrayQueue(int initialCapacity) {
        this.data = new Object[initialCapacity];
        this.front = 0;
        this.rear = 0;
        this.size = 0;
        this.capacity = initialCapacity;
    }
    /**
     * @TODO 队列入队操作
     * @param e 需要入队的数据元素
     * @return true
     */
    public boolean enQueue(E e){
        if(this.isFull()){
            throw new RuntimeException("队列已满！最大容量="+this.capacity);
        }
        this.data[this.rear] = e;
//      this.rear = (this.rear+1)%(this.capacity);
        this.rear = this.rear+1;
        this.size++;
        return true;
    }
    /**
     * @TODO 队列的出队操作
     * @return e 位于对首的数据元素
     */
    public E deQueue(){
        if(this.isEmpty()){
            throw new RuntimeException("队列为空！");
        }
        E e = (E)this.data[this.front];
//      this.front = (this.front+1)%(this.capacity);
        this.front = this.front+1;
        this.size--;
        return e;
    }
    /**
     * @TODO 判断队列是否为空
     * @return true空 or false不为空
     */
    public boolean isEmpty(){
        if(this.front==this.size){
            return true;
        }
        return false;
    }
    /**
     * @TODO 判断队列是否已满
     * @return true满 or false未满
     */
    public boolean isFull(){
        //这里不能用size来进行判断，用size会出现假溢出的情况
        if(this.rear==this.capacity-1){
            return true;
        }
        return false;
    }
    /**
     * @TODO 获取队列的长度
     * @return size
     */
    public int size(){
        return this.size;
    }
    @Override
    public String toString() {
        StringBuffer sb = new StringBuffer("[");
        if(this.data[this.front]!=null){
            sb.append(this.data[this.front]);
            for (int i = this.front+1; i < this.rear; i++) {
                sb.append(", "+this.data[i]);
            }
        }
        sb.append("]");
        return sb.toString();
    }
}

下面是我的测试代码：

public static void main(String[] args) {
    FOArrayQueue foaq = new FOArrayQueue();
    for (int i = 1; i <= 6; i++) {
        foaq.enQueue("元素"+i);
    }
    System.out.println(foaq);
    System.out.println(foaq.size());
    System.out.println(foaq.deQueue());;
    System.out.println(foaq);
    System.out.println(foaq.size());
}

测试截图：

  由于队列的入队和出队操作的结果导致队列容易出现“假溢出”，于是乎出现了循环队列。

循环队列需要注意的地方如下：

• 执行入队操作后，队尾指针的变化：Q->rear = (Q->rear+1)% capacity。
• 执行出队操作后，对首指针的变化：Q->front= (Q->front+1)% capacity。
• 判断是否为空的情况：Q->front=Q->rear。
• 判断队列是否为满的情况，需要放弃队列一个位置来区分开来队列是否为空是否为满，这样判断条件为：Q->front= (Q->rear + 1)% capacity。
• 队列实际长度：（队尾指针-对首指针+数组长度）% 数组长度；或者可以通过设定一个变量来进行存储；或者都通过Q->front=Q->rear外加一个flag变量进行判断。

好了，循环队列也就介绍这些。

链队列：
定义：队列的链式存储结构，其实就是线性表的单链表，只不过它只能尾进头出而已，我们把它简称为链队列。
  为了方便操作，将队头指针指向链队列的头结点，而队尾指针指向终端结点。
  当队列为空时，front和rear都指向头结点。

  正如链队就类似于单链表，这里链队的入队、出队、判断为空等操作也基本类似，这里就不描述了，详情请参考之前的单链表。

  其实看了之前的再看这里其实很容易的，不懂的话还可以参考这个网址：http://www.nowamagic.net/librarys/veda/detail/2357

循环队列和链队列的比较。

1. 时间上：它们的基本操作都是常数时间O(1)，这里还有点细微的差别（循环队列是事先申请好空间，使用期间不释放，而对于链队列，每次申请和释放结点也会存在一些时间开销，如果入队出队频繁，则两者还是有细微差异）。
2. 空间上：循环队列的长度固定，因此有了空间浪费的问题；而链队列不存在这个问题，但是每个节点需要一个指针域，这是需要消耗一定的空间。相对来说，链队列更加灵活。

总结：
  在确定队列长度最大值的情况，建议使用循环队列；否则请使用链队列。“循环队列”最大优点就是节省空间和少分配空间，而链队列多了一点点地址存储开销。