5、队列的顺序存储结构：循环队列、两种方法

队列的ADT：

package ren.laughing.datastructure.base;

import ren.laughing.datastructure.exception.QueueEmptyException;

/**
 * 队列Queue的ADT:先进先出
 * 在队列中把插入数据元素的一端称为 队尾(rear), 删除数据元素
 * 的一端称为 队首(front)。向队尾插入元素称为 进队或入队，
 * 新元素入队后成为新的队尾元素；从队列中删除元素称为 离队或出队，
 * 元素出队后，其后续元素成为新的队首元素。
 * @author Laughing_Lz
 * @time 2016年4月7日
 */
public interface Queue {
    //返回队列的大小
    public int getSize();
    //判断队列是否为空
    public boolean isEmpty();
    //数据元素 e 入队
    public void enqueue(Object e);
    //队首元素出队
    public Object dequeue() throws QueueEmptyException;
    //取队首元素
    public Object peek() throws QueueEmptyException;
    }

循环队列的顺序存储实现，采用少一存储空间的方法：

package ren.laughing.datastructure.baseImpl;

import ren.laughing.datastructure.base.Queue;
import ren.laughing.datastructure.exception.QueueEmptyException;
/**
 * 队列Queue的顺序存储,此处使用循环队列，逆时针，方法一
 * ★循环队列：难点在于如何判断队空和队满
 * 方法一：★少使用一个存储空间，即：当队尾指针的下一指针指向队首指针时，就停止入队。
 * 判决：队空：rear=front,队满：(rear+1)%capacity = float
 * 方法二：★增设一个标志size，以size？=MAX区别队满队空
 * 判决：队空：size = 0,队满：size = capacity
 * @author Laughing_Lz
 * @time 2016年4月7日
 */
public class QueueArray implements Queue{
    private static final int CAP=7;//队列默认容量大小
    private Object[] elements;
    private int capacity;//数组的实际大小 elements.length
    private int front;
    private int rear;
    
    public QueueArray() {
        this(CAP);
    }
    public QueueArray(int cap) {
        this.elements = new Object[capacity];
        this.capacity = cap+1;//这里数组实际大小capacity比队列容量cap大1
        this.front = 0;
        this.rear = 0;
    }
    //获取队列的容量
    @Override
    public int getSize() {
        return (rear-front+capacity)%capacity;//返回队列的实际容量，小于等于capacity-1
    }
    //判断是否队空
    @Override
    public boolean isEmpty() {
        if(rear == front){
            return true;
        }else{
            return false;
        }
    }
    //入队：相当于在insertAfter队尾
    @Override
    public void enqueue(Object e) {
//        if(getSize()==capacity-1){//同下，判断队列容量是否已满
        if((rear+1)%capacity == front){//判断是否队满
            expandSpace();//扩充队列的容量
        }
        elements[rear] = e;
        rear = (rear+1)%capacity;//rear有可能从capacity-1移动到0
    }
    //出队：相当于在remove队首
    @Override
    public Object dequeue() throws QueueEmptyException {
        if(rear == front){//判断是否队空
            throw new QueueEmptyException("错误：队列已空");
        }
        Object obj = elements[front];
        elements[front] = null;//置空
        front = (front+1)%capacity;//front有可能从capacity-1移动到0
        return obj;
    }
    //获取队首数据元素
    @Override
    public Object peek() throws QueueEmptyException {
        if(rear == front){//判断是否队空
            throw new QueueEmptyException("错误：队列已空");
        }
        return elements[front];
    }
    /**
     * ★扩充数组长度
     */
    private void expandSpace() {
        Object[] a = new Object[elements.length * 2];
        int i = front;
        int j = 0;
        while(i!=rear){//将从 front 开始到 rear 前一个存储单元的元素复制到新数组
            a[j++] = elements[i];
            i = (i+1)%capacity;
        }
        elements = a;
        capacity = elements.length;
        front  = 0;
        rear = j;//重新设置新的队首队尾指针
    }
}

循环队列的顺序存储实现，采用加标志size的方法：

package ren.laughing.datastructure.baseImpl;

import ren.laughing.datastructure.base.Queue;
import ren.laughing.datastructure.exception.QueueEmptyException;
/**
 * 队列Queue的顺序存储,此处使用循环队列，逆时针，方法二
 * ★循环队列：难点在于如何判断队空和队满
 * 方法一：★少使用一个存储空间，即：当队尾指针的下一指针指向队首指针时，就停止入队。
 * 判决：队空：rear=front,队满：(rear+1)%capacity = float
 * 方法二：★增设一个标志size，以size？=MAX区别队满队空
 * 判决：队空：size = 0,队满：size = capacity
 * @author Laughing_Lz
 * @time 2016年4月7日
 */
public class QueueArray2 implements Queue{
    private static final int CAP=8;//队列默认容量大小
    private Object[] elements;
    private int capacity;//数组的实际大小 elements.length
    private int size;//队列容量（空/满判断标志）
    private int front;
    private int rear;
    
    public QueueArray2() {
        this(CAP);
    }
    
    public QueueArray2(int cap) {
        this.elements = new Object[capacity];
        this.capacity = cap;//此处cap = capacity
        this.size = 0;//队列初始为空
        this.front = 0;
        this.rear = 0;
    }
    //获取队列的容量
    @Override
    public int getSize() {
        if(size == capacity){
            return capacity;
        }else{
            return (rear-front+capacity)%capacity;
        }
    }
    //判断是否队空
    @Override
    public boolean isEmpty() {
        if(rear == front&&size !=capacity){
            return true;
        }else{
            return false;
        }
    }
    //入队：相当于在insertAfter队尾
    @Override
    public void enqueue(Object e) {
        if(size  == capacity){//判断是否队满
            expandSpace();//扩充队列的容量
        }
        elements[rear] = e;
        rear = (rear+1)%capacity;//rear有可能从capacity-1移动到0
        size++;
    }
    //出队：相当于在remove队首
    @Override
    public Object dequeue() throws QueueEmptyException {
        if(rear == front&&size != capacity){//判断是否队空 (此时size为0)
            throw new QueueEmptyException("错误：队列已空");
        }
        Object obj = elements[front];
        elements[front] = null;//置空
        front = (front+1)%capacity;//front有可能从capacity-1移动到0
        size--;
        return obj;
    }
    //获取队首数据元素
    @Override
    public Object peek() throws QueueEmptyException {
        if(rear == front&&size != capacity){//判断是否队空 (此时size为0)
            throw new QueueEmptyException("错误：队列已空");
        }
        return elements[front];
    }
    /**
     * ★扩充数组长度
     */
    private void expandSpace() {
        Object[] a = new Object[elements.length * 2];
        int i = front;
        int j = 0;
        do{//将从 front 开始到 rear 前一个存储单元的元素复制到新数组
            a[j++] = elements[i];
            i = (i+1)%capacity;
        }while(i!=rear);//★
        elements = a;
        capacity = elements.length;
        front  = 0;
        rear = j;//重新设置新的队首队尾指针
    }
}