队列的顺序存储结构--循环队列

队列也是线性表的一种特殊形式，它只允许在线性表的一端进行插入，而在另一端进行删除，也就是所谓的先入先出

用顺序存储的结构实现队列，假如队列有n个元素，则必须建立大于n的数组，因为队列要求在一端插入，而在另一端删除，所以插入元素时，时间复杂度为O(1)，而在删除的时候，所有元素都得向前移动一个位置，时间复杂度为O(n)，为了更好的利用空间，所以提出了循环结构：

将原本的顺序存储结构进行首尾相接得到的队列就是循环队列

循环对列的存储结构{

data[]:用来存储数据的数组

front：头指针，指向队列的第一个元素

rear：尾指针：指向队列的下一个空位置

}

循环队列的代码实现：

package seqList;
/*
 * 顺序循环链表
 * 队头（front），队尾（rear）
 * 队空：front==rear
 * 队满：（rear+1）%queueSize==front
 * 队列的当前长度:(rear-front+queueSize)%queueSize
 */

public class SqQueue {
	private int DefaultSize=100;
	private int size;
	private Object[] Queue;
	private int front;
	private int rear;
	
	public SqQueue() {
		this.size=DefaultSize;
		initQueue(DefaultSize);
	}
	//有参构造函数
	public SqQueue(int size) {
		this.size=size;
		Queue=new Object[size];
		front=0;
		rear=0;
	}
	//无参构造函数
	public void initQueue(int size) {
		Queue=new Object[size];
		front=0;
		rear=0;
	}
	
	//入队列
	public void EnQueue(Object data) throws Exception {
		
		if((rear+1)%size==front) {
			throw new Exception("队列已满");
		}
		else {
			Queue[rear]=data;
			rear=(rear+1)%size;
		}
	}
	//出队列
	public Object deQueue() throws Exception {
		if(rear==front) {
			throw new Exception("队列为空");
		}
		else {
			Object x=Queue[front];
			front=(front+1)%size;
			return x;
		}
	}
	//获得队列的长度
	public int queueLength() {
		return (rear-front+size)%size;
	}
	public static void main(String[] args) throws Exception {
		SqQueue sq=new SqQueue(5);
		sq.EnQueue(1);
		sq.EnQueue(2);
		sq.EnQueue(3);
		System.out.println(sq.queueLength());
	    System.out.println(sq.deQueue());
	    System.out.println(sq.deQueue());
	    System.out.println(sq.deQueue());
	}

}

运行结果：