数据结构（五）：队列

        仅允许在表的一端进行插入，在另一端进行删除。删除的一端称为队头或队首，插入的一端称为队尾。插入元素称为进队或者入队，删除元素称为出队或离队。特点：先进先出表。

       队列的存储结构分为顺序存储结构和链式存储结构。

顺序存储结构

       需要用一个数组和两个整形变量来表示，利用数组存储所有元素，利用两个整形变量分别表示队首和队尾元素下标。 为了充分利用数组的存储空间，一般使用环形队，即把数组的后端和前端连接起来，形成一个环形的顺序表。

       在环形队列中，队首指针进 1：front = (front + 1) % MaxSize；队尾指针进1：rear = (rear + 1) % MaxSize.

队空条件为rear == front，队满条件也为rear == front

       如何判断队空和队满：通常阅读在进队时少用一个元素空间，即(rear + 1) % MaxSize == front即判断为队满。队空条件不变，为rear == front。

综上所述：顺序存储结构为：

public class SqQueue {
	private int front;
	private int rear;
	private int datas[];
	SqQueue(int datas[])
	{
		front = 0;
		rear = 0;
		this.datas = datas;
	}
	//setters and getters
		......
}

顺序存储结构下的基本运算：1.判断队列是否为空。2.入队。3.出队。

public class OperateSq {
	static int MaxSize = 20;
	
	public static void main(String args[])
	{
		int datas[] = new int[MaxSize];
		
		SqQueue sq = new SqQueue(datas);
		
		/*
		 * 判断队列是否为空
		 */
		if(QueueEmpty(sq))
			System.out.println("SqQueue is empty!");
		else
			System.out.println("SqQueue is not empty!");
		
		/*
		 * 入队
		 */
		enQueue(sq,3);
		
		/*
		 * 出队
		 */
		deQueue(sq);
			
	}
	
	public static boolean QueueEmpty(SqQueue sq)
	{
		if(sq.getFront() == sq.getRear())
			return true;
		else
			return false;
	}
	
	public static void enQueue(SqQueue sq,int num)
	{
		if( ( (sq.getRear() + 1) % MaxSize) == sq.getFront() )
			System.out.println("队列已满！");
		else
		{
			sq.setRear( (sq.getRear() + 1) % MaxSize);
			int datas[] = sq.getDatas();
			datas[sq.getRear()] = num;
		}
	}
	public static void deQueue(SqQueue sq)
	{
		if(QueueEmpty(sq))
			System.out.println("SqQueue is empty!");
		else
		{
			sq.setFront((sq.getFront() + 1) % MaxSize);
		}
	}
}

链式存储结构

只允许在单链表的表首进行删除操作和表尾进行插入操作。需要有两个指针front和rear指向队首和队尾

节点类型结构为：

public class Qnode {
	int data;
	Qnode next;
	Qnode(){}
	Qnode(int data)
	{
		this.data = data;
	}
	//getters and setters
		......
}

链队节点类型：

public class SqQueue1 {
	Qnode front;
	Qnode rear;
	SqQueue1()
	{
		front = null;
		rear = null;
	}
	//setters and getters
　　......
}

链式存储结构下的基本运算：1.判断队列是否为空。2.入队。3.出队。

public class OperateSq1 {
	public static void main(String args[])
	{
		SqQueue1  Sq = new SqQueue1();
		
		/*
		 * 判断队列是否为空
		 */
		if( QueueEmpty(Sq) )
			System.out.println("The queue is empty!");
		else
			System.out.println("The queue is not empty!");
		
		/*
		 * 入队
		 */
		enQueue(Sq,new Qnode(4));
		
		/*
		 * 出队
		 */
		deQueue(Sq);
	}
	
	public static boolean QueueEmpty(SqQueue1 Sq)
	{
		if(Sq.getRear() == null)
			return true;
		else
			return false;
	}
	
	public static void enQueue(SqQueue1 Sq,Qnode node)
	{
		if(Sq.getRear() == null)
		{
			Sq.setFront(node);
			Sq.setRear(node);
		}
		else
		{
			Sq.getRear().setNext(node);
			Sq.setRear(node);
		}
	}
	
	public static void deQueue(SqQueue1 Sq)
	{
		if(Sq.getRear() == null)
			System.out.println("Queue is empty!");
		else
		{
			Sq.setFront(Sq.getFront().getNext());
		}
	}
}