自定义队列（2）：循环队列

通过学习自定义队列，了解队列的数据结构。

首先写一个队列的接口，描述其具有的基本功能。Queue.java

然后写一个接口的实现类，这只是其中一种实现方式，为循环队列。LoopQueue.java

最后写一个测试类，测试自定义数组队列的效果。Test.java

 

在 自定义队列（1）：数组队列 这篇文章中，数组队列的dequeue（）方法的时间复杂度为O(n)，这是因为，数组队列中，每当取出队头元素，就意味着整个数组的前移。

而本篇的循环队列，对dequeue（）方法，只是将front指针后移，所以时间复杂度为O(1)。大大提高了效率。

 

 

知识点：

1.  头指针 front指向第一个元素。

2.尾指针tail指向最后一个元素的下一个位置。

3.判断队列为空的条件：tail=front

4.为防止队列满时，也出现tail=front的情况，所以循环队列会浪费一个空间，什么也不存储。

5.则判断队列是否满的条件为： (tail+1)% data.capacity=front.这里的data.capacity指队列的容量（不包括浪费的那一个空间）

6.由于是循环队列，一定要注意   （任意+1）% data.capacity 这种表达。
 

LoopQueue.java的代码中：

1.巧用： （任意+1）% data.capacity 这种表达！

2.在resize（）方法、toString（）方法中的两个for循环都是遍历循环数组的。是等价的。

 

Queue.java：

package Queue;

public interface Queue<E> {
	/**
	 * 获取队列中数据的大小
	 * @return
	 */
	int getSize();
	/**
	 * 判断队列是否为空
	 * @return
	 */
    boolean isEmpty();
    /**
     * 在队尾插入元素
     * @param e
     */
    void enqueue(E e);
    /**
     * 在队头删除元素
     * @return
     */
    E dequeue();
    /**
     * 查看队头元素
     * @return
     */
    E getFront();
}

 

LoopQueue.java：

package Queue;

public class LoopQueue<E> implements Queue<E>{
	private E[] data;
	private int front;//指向队头的指针
	private int tail;//指向队尾的下一个元素的指针
	private int size;//当前循环队列里数据的大小
	/**
	 * 带参构造函数，自定义初始容量
	 * @param capacity
	 */
	public LoopQueue(int capacity) {
		//之所以加1，是因为循环队列要浪费一个空间，以避免队列满时，头指针=尾指针。
		//因为这时，与队列为空的判断条件相等。
		//以下，所有加1的原因都是如此。
		data=(E[])new Object[capacity+1];
		front=0;
		tail=0;
		size=0;
	}
	/**
	 * 无参构造函数，初始容量为10
	 */
	public LoopQueue() {
		this(10);
	}
	/**
	 * 返回队列中数据的大小
	 */
	@Override
	public int getSize() {
		
		return size;
	}
	/**
	 * 自定义方法，返回循环队列的容量大小
	 * @return
	 */
	public int getCapacity() {
		return data.length-1;
	}
	/**
	 * 判断队列是否为空
	 */
	@Override
	public boolean isEmpty() {
		
		return front==tail;
	}
	/**
	 * 插入队尾
	 */
	@Override
	public void enqueue(E e) {
		if((tail+1)%data.length==front) {//判断队列是否满
			resize(getCapacity()*2);
		}
		data[tail]=e;
		tail=(tail+1)% data.length;
		size++;
	}
	/**
	 * 自定义方法。
	 * 动态扩容
	 * @param i
	 */
	private void resize(int newCapacity) {
		E[] newData=(E[]) new Object[newCapacity]; 
		//扩容后，从0位置填充。
		for(int i=0;i<size;i++) {
			newData[i]=data[(front+i)%data.length];
		}
		data=newData;
		front=0;
		tail=size;
		//size不变
	}
	/**
	 * 取出队头
	 */
	@Override
	public E dequeue() {
		if(isEmpty()) {
			throw new IllegalArgumentException("空队列，不可取出队头");
		}
		E e=data[front];
		front=(front+1)%data.length;
		size--;
		if(size==getCapacity()/4 && getCapacity()/2!=0) {
			resize(getCapacity()/2);
		}
		return e;
	}
	/**
	 * 查看队头
	 */
	@Override
	public E getFront() {
		if(isEmpty()) {
			throw new IllegalArgumentException("空队列，不可查看队头");
		}
		return data[front];
	}
	/**
	 * 重写Object的toString方法
	 */
	@Override
	public String toString() {
		StringBuilder sb=new StringBuilder();
		sb.append(String.format("Queue:size=%d,capacity=%d\n", size,getCapacity()));
		sb.append("front [");
		for(int i=front;i!=tail;i=(i+1)%data.length) {
			sb.append(data[i]);
			if((i+1)%data.length!=tail) {
				sb.append(",");
			}
			
		}
		sb.append("] tail");
		return sb.toString();
	}
	
}

Test.java:

package Queue;

public class Test {

	public static void main(String[] args) {
		Queue<Integer> queue=new LoopQueue<Integer>();
		for(int i=0;i<10;i++) {
			queue.enqueue(i);
			System.out.println(queue);
			if(i%3==2) {//每插入3个，则取出队头元素。
				queue.dequeue();
				System.out.println(queue);
			}
		}
		
	}

}

控制台输出：