java队列实现(数组，链式，双端)

数组实现循环队列

数组实现循环队列 判断队满 两种方式：
1. 额外增加一个变量，size记录队列元素数量。或者放一个标记flag，记录元素是出队还是入队
2. （rear + 1）% maxSize = front

package Queue;

public class ArrayQueue<E>{
	private E []arrayQueue;		//创建一个数组
	private int maxSize;		//数组长度
	private int rear,front;		//头指针 尾指针
	private int size;			//记录队列中元素个数
	
	public ArrayQueue(int maxSize) {		//初始化
		arrayQueue = (E[]) new Object[maxSize];
		this.maxSize = maxSize;
		rear = 0;
		front = 0;
		size = 0;
	}
	public boolean addLast(E data) {		//入队
		if(size < maxSize) {
			arrayQueue[rear % maxSize] = data;
			rear++;
			size++;
			return true;
		}else {
			System.out.println("队列满了");
			return false;
		}
	}
	public E outFirst() {					//出队
		E data = null;
		if (size != 0) {
			data = arrayQueue[front % maxSize];
			front++;
			size--;
		}else {
			System.out.println("队列空了");
			return data;
		}		
		return data;
	}
}

链式队列

package Queue;

public class LinkedQueue<E>{
	class Node<E>{					//结点信息
		private Node next;			//next 指针
		private E data;				//数据域
		public Node() {				//结点信息初始化
			next = null;
		}
	}
	private Node front,rear;		//队列 头指针 尾指针
	public LinkedQueue() {			//初始化
		front = rear = null;
	}
	public void addLast(E data) {			//末尾入队
		Node<E> node = new Node<>();
		node.data = data;
		if (front == null) {
			front = rear = node;
		}else {
			rear.next = node;
			rear = node;
		}
	}
	public E popFirst() {					//头部出队
		E data = null;
		if(front == null) {
			System.out.println("队列空了");
			return data;
		}else {
			data = (E) front.data;
			front = front.next;
		}
		return data;
	}
}

双端队列

package Queue;


/*
 * 
 */
public class Deque<E> {
	class Node<E> {							//结点信息
		private Node prev;					//指向前一个结点的指针
		private Node next;					//指向后一个结点的指针
		private E data;						//数据域

		public Node(E data) {				//结点信息初始化
			prev = null;
			next = null;
			this.data = data;
		}
	}

	private Node front;						//队头指针
	private Node rear;						//队尾指针
	public Deque() {						//初始化信息
		front = null;
		rear = null;
	}

	public boolean isEmpty() {				//队列判空
		if (front == rear && front == null) {
			return true;
		}
		return false;
	}

	public void addFirst(E data) {			//队头入队
		Node<E> node = new Node<E>(data);
		if (isEmpty() == true) {
			front = rear = node;
		} else {
			node.next = front;
			front.prev = node;
			front = node;
		}
	}

	public void addLast(E data) {			//队尾入队
		Node<E> node = new Node<E>(data);
		if (isEmpty() == true) {
			front = rear = node;
		} else {
			rear.next = node;
			node.prev = rear;
			rear = rear.next;
		}
	}

	public E removeFirst() {				//队头出队
		E data = null;
		if (isEmpty() == true) {
			System.out.println("队列空的");
		} else {
			data = (E) front.data;
			if (front == rear) {
				front = rear = null;
			} else {
				front = front.next;
				front.prev = null;
			}

		}
		return data;
	}

	public E removeLast() {					//队尾出队
		E data = null;
		if (isEmpty() == true) {
			System.out.println("队列空的");
		} else {
			data = (E) rear.data;
			if (front == rear) {
				front = rear = null;
			} else {
				rear = rear.prev;
				rear.next = null;
			}
		}
		return data;
	}
	
	public E peekFirst() {					//取队头元素 不出队
		E data = null;
		if (isEmpty() == true) {
			System.out.println("队列为空");
			return data;
		}
		return (E) front.data;
	}

	public E peekLast() {					//取队尾元素 不出队
		E data = null;
		if (isEmpty() == true) {
			System.out.println("队列为空");
			return data;
		}
		return (E) rear.data;
	}
}