数据结构-Java实现队列的顺序存储和链式存储

队列的顺序存储

队列的性质：先进先出。
队列的顺序存储（环形队）：
采用一个数组和一个代表数组的下标的整型变量实现。

//环形队（顺序队会造成数组空间的浪费：如果不想造成空间的浪费
//       可以使用一个数组来实现，不需要头、尾指针，在进队时
//       重新创建一个数组保存原来的元素和进队的元素，然后将
//       新数组赋给旧数组，该写法不要对队的大小做限制。）
//下面是数据结构中的写法
//栈的顺序存储结构
public class MyQueue {
		private int[] data;//存放队中的元素
		private int front;//队头指针
		private int rear;//队尾指针
	
	public MyQueue(int size) {
		data = new int[size];
		front = 0;
		rear = 0;
	}
	
	/**
	 * 判断队是否已满
	 * @return 队满返回true,否则返回false
	 */
	public boolean queueIsFull() {
		if((rear+1) % data.length == front) {//队已满
			return true;
		}
		return false;
	}
	
	/**
	 * 判断队是否为空
	 * @return 队空返回true,否则false
	 */
	public boolean queueIsEmpty() {
		if(front == rear) {//队为空
			return true;
		}
		return false;
	}
	
	/**
	 * 进队
	 * @param element
	 * @return
	 */
	public boolean enQueue(int element) { 
		//判断队是否已满
		if(queueIsFull()) {//队满
			return false;
		}
		else {//入队
			rear = (rear + 1) % data.length;
			data[rear] = element;
			return true;
		}
	}
	
	/**
	 * 出队
	 * @return
	 */
	public int deQueue() throws RuntimeException{
		//判断队是否为空
		if(queueIsEmpty()) {//队空，抛出异常
			throw new RuntimeException("队为空");
		}
		else {//出队
			int result = data[front+1];
			front = (front + 1) % data.length;
			return result ;
		}
	}
}

测试

	@Test
	public void testQueue() {
		MyQueue queue = new MyQueue(5);
		try {
			queue.enQueue(1);
			queue.enQueue(2);
			queue.enQueue(3);
			queue.enQueue(4);

			System.out.println(queue.deQueue());
			System.out.println(queue.deQueue());
			System.out.println(queue.deQueue());
			System.out.println(queue.deQueue());
		} catch (Exception e) {
			System.out.println(e.getMessage());
		}
	}

队列的链式存储

//队列的链式存储结构
public class MyLinkQueue {

	class DataNode {
		int data;
		DataNode next;
	}

	private DataNode front;// 队首节点
	private DataNode rear;// 队尾节点，一直指向最后一个元素

	public MyLinkQueue() {
		front = new DataNode();
		front.next = null;
		rear = new DataNode();
		rear = null;
	}

	/**
	 * 判断节点是否为空
	 * @return
	 */
	public boolean isEmpty() {
		return rear == null;
	}

	/**
	 * 进队：采用未插入法，后进队的元素在后面
	 * @param element
	 * @return
	 */
	public boolean enQueue(int element) {
		DataNode data = new DataNode();
		data.data = element;
		if (isEmpty()) {// 如果队列为空，则首节点和尾节点都指向它
			front.next = data;
			rear = data;
			return true;
		} else {//否则，只将尾节点指向它
			// 将新增节点插入到链表的最后面
			rear.next = data;
			// 然后将rear尾节点指向最后一个元素
			rear = data;
			return true;
		}
	}
	
	/**
	 * 出队:出首节点的后节点，因为采用的是尾插入法
	 * @return
	 * @throws RuntimeException
	 */
	public int deQueue() throws RuntimeException{
		if(isEmpty()) {
			throw new RuntimeException("队列为空");
		}
		if(front.next == rear) {//如果队列中只要一个节点时
			int result = front.next.data;
			front.next = null;
			rear = null;
			return result;
		}
		else {
			int result = front.next.data;
			front.next = front.next.next;
			return result;
		}
	}
}

测试

	@Test
	public void queue() {
		try {
			MyLinkQueue queue = new MyLinkQueue();
			queue.enQueue(2);
			queue.enQueue(3);
			queue.enQueue(4);
			queue.enQueue(5);
			System.out.println(queue.deQueue());
			System.out.println(queue.deQueue());
			System.out.println(queue.deQueue());
			System.out.println(queue.deQueue());
			System.out.println(queue.deQueue());
		} catch (RuntimeException e) {
			// TODO Auto-generated catch block
			System.out.println(e.getMessage());
		}
	}