一、循环队列的定义
为了克服顺序队列中假溢出,通常将一维数组Queue[0]到Queue[MAXSIZE - 1]看成是一个首
尾相连接的圆环,即Queue[0]与Queue[MAXSIZE - 1]相连接在一起,将这样形式的队列成为循环
队列。
二、基本结构
由两个指针(此处的指针并非是真正的指针而是角标)构成分别是front,rear;rear指的是末尾
元素的下一个;
三、对应的方法实现
(1)入队操作;
a、首先判断队是否满状态;因为尾指针指向末尾元素+1;所以当(rear + 1) % data.length ==
front时为满状态,因为是循环的所以要对 通过data.length取余。
b、如果满则进行扩容,扩容的长度为data.length*2-1因为尾指针元素为空所以乘以2倍就多了
两个空因此减一。
c、如果不满则直接将进队的元素赋给头指针;
@Override
public void offer(E element) {
//满了没
if ((rear + 1) % data.length == front) {
resize(data.length * 2 - 1);
}
data[rear] = element;
rear = (rear + 1) % data.length;
size++;
}
(2)出队操作
a、先判空,若不为则获取front指针的元素,将front指针向后移一个;size--;
b、出队时考虑缩容问题,当size <= (data.length - 1) / 4 && data.length - 1 >
DEFAULT_CAPACITY(默认长度);data.length变为原来长度的1/2+1;
c.将获取的值返回 ;
@Override
public E poll() {
//空不空
if (isEmpty()) {
throw new IllegalArgumentException("queue is null");
}
E ret = data[front];
front = (front + 1) % data.length;
size--;
if (size <= (data.length - 1) / 4 && data.length - 1 > DEFAULT_CAPACITY) {
resize(data.length / 2 + 1);
}
return ret;
}
(3)判空操作
因为尾指针指向的是空,所以当头指针==尾指针是就可以认为队列为空;
@Override
public boolean isEmpty() {
return front == rear;
}
(4)清空队列
将底层数组置空,front,rear,size置为0;
@Override
public int size() {
return size;
}
(5)输出队列
通过实现toString()方法利用StringBuilder将队列元素进行拼接并输出,首先对队列进行判空操
作,如果为空则仅需要输出“[]”;如果不为空则进行元素遍历并拼接在“[]”中;
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append('[');
if (isEmpty()) {
sb.append(']');
return sb.toString();
}
for (int i = front; i != rear; i = (i + 1) % data.length) {
sb.append(data[i]);
if ((i + 1) % data.length == rear) {
sb.append(']');
} else {
sb.append(',');
sb.append(' ');
}
}
return sb.toString();
}
四、代码实现;
通过实现Queue接口实现循序队列;
Queue接口:
package p1.接口;
public interface Queue<E> extends Iterable<E> {
public void offer(E element); //入队
public E poll(); //出队
public E element(); //查看队首元素
public boolean isEmpty();
public void clear();
public int size();
}
主程序;
package p2.线性结构;
import p1.接口.Queue;
import java.util.Iterator;
//循环队列
public class ArrayLoopQueue<E> implements Queue<E> {
private E[] data; //存储数据的容器
private int front; //队首指针(实际上就是数组中的索引角标)
private int rear; //队尾指针
private int size; //元素的个数 (f < r r-f ; r < f r+L-f)
private static int DEFAULT_CAPACITY = 10; //默认容量
public ArrayLoopQueue() {
data = (E[]) new Object[DEFAULT_CAPACITY + 1];
front = 0;
rear = 0;
size = 0;
}
@Override
public void offer(E element) {
//满了没
if ((rear + 1) % data.length == front) {
resize(data.length * 2 - 1);
}
data[rear] = element;
rear = (rear + 1) % data.length;
size++;
}
@Override
public E poll() {
//空不空
if (isEmpty()) {
throw new IllegalArgumentException("queue is null");
}
E ret = data[front];
front = (front + 1) % data.length;
size--;
if (size <= (data.length - 1) / 4 && data.length - 1 > DEFAULT_CAPACITY) {
resize(data.length / 2 + 1);
}
return ret;
}
private void resize(int newLen) {
E[] newData = (E[]) new Object[newLen];
int index = 0;
for (int i = front; i != rear; i = (i + 1) % data.length) {
newData[index++] = data[i];
}
data = newData;
front = 0;
rear = index;
}
@Override
public E element() {
if (isEmpty()) {
throw new IllegalArgumentException("queue is null");
}
return data[front];
}
@Override
public boolean isEmpty() {
return front == rear;
}
@Override
public void clear() {
data = (E[]) new Object[DEFAULT_CAPACITY];
size = 0;
front = 0;
rear = 0;
}
@Override
public int size() {
return size;
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append('[');
if (isEmpty()) {
sb.append(']');
return sb.toString();
}
for (int i = front; i != rear; i = (i + 1) % data.length) {
sb.append(data[i]);
if ((i + 1) % data.length == rear) {
sb.append(']');
} else {
sb.append(',');
sb.append(' ');
}
}
return sb.toString();
}
@Override
public boolean equals(Object o) {
if (o == null) {
return false;
}
if (this == o) {
return true;
}
if (o instanceof ArrayLoopQueue) {
ArrayLoopQueue<E> other = (ArrayLoopQueue<E>) o;
if (size != other.size) {
return false;
}
int i = front;
int j = other.front;
while (i != rear) {
if (!data[i].equals(other.data[j])) {
return false;
}
i = (i + 1) % data.length;
j = (j + 1) % other.data.length;
}
return true;
}
return false;
}
@Override
public Iterator<E> iterator() {
return new ArrayLoopQueueIterator();
}
class ArrayLoopQueueIterator implements Iterator<E> {
private int cur = front;
@Override
public boolean hasNext() {
return cur != rear;
}
@Override
public E next() {
E ret = data[cur];
cur = (cur + 1) % data.length;
return ret;
}
}
}