- 上一篇最后我们分析了队列的利弊,故我们这里对队列进行优化。就有了这一篇,循环队列。
队列的问题主要便是入队的时间复杂度O(1).出队的时间复杂度0(n) 。还有就是当进行插入和删除操作后,线性表的开始空间可能会被空出来,会浪费且占用空间。 - 所以我们这里让队列首位相连变成了一个环,但是如何相连,相连之后入队和出队又是如何操作呢,相连以后会不会出现问题呢,出现问题又该如何解决呢,大家跟我一起往下看吧。
优化(循环队列):
- 首先让队头指针和队尾指针一样随着数据元素的变化而变化。这样入队和出队的操作都是O(1),然后我们将线性表首尾相连,当队头或队尾指针到达尾部时,如需后移可重新指向表头,变成一个环,指针从尾到头有一个周期性,也就是数线性表长度,指针+1对线性表长度取余就可以完成指针从头到尾的跳跃,这样就解决了空间浪费的问题。然后将一个空间预留出来不存任何元素,尾指针始终指向这个null空间,这时,队列满的条件是(rear+1)%n== front,队列为空的条件是 rear == front。这样可以解决判断队列满和队列空的条件都是(rear+1)%n==front的问题,这里n是线性表的长度,没法判断。如下图(这个图花了我很大的功夫,这篇博客的核心思想便在这俩张动图之中,大家一定要仔细看):
图一:解决了空间浪费的问题
图二:解决判断队列满和队列空的条件都是(rear+1)%n==front的问题
用Java代码实现循环队列的顺序存储结构,使用ArrayQueueLoop实现Queue接口,重写Queue的方法,这里写的接口都是我们自己编写的,不是java里面自带的接口,大家注意一下,代码如下:
import java.util.Iterator;
//循环队列 底层用动态数组实现
public class ArrayQueueLoop<E> implements Queue<E> {
private E[] data; //定义数组
private int front; //头指针
private int rear; //尾指针
private int size; //有效元素个数
public ArrayQueueLoop(){
data= (E[]) (new Object[11]);//因为有一个空的空间,有效能存储的空间有10个
front=0; //初始化
rear=0;
size=0;
}
@Override
public int getSize() {
return size; //获取有效元素个数,直接返回size
}
@Override
public boolean isEmpty() {
return size==0&&front==rear; //循环队列为空的条件
}
@Override
public void enqueue(E e) {
if((rear+1)%data.length==front){ //队列满时
resize(2*data.length-1); //扩容,扩二倍
}
data[rear]=e; //把e从队尾入队列,rear角标处是空的空间
rear=(rear+1)%data.length; //更新尾指针,rear重新指向空地址
size++; //有效元素+1
}
@Override
public E dequeue() {
if(isEmpty()){ //队列空时不可出队,抛异常
throw new IllegalArgumentException("队列空");
}
E ret=data[front]; //变量ret存头指针的元素,用于返回
front=(front+1)%data.length; //更新头指针
size--; //有效元素-1
//当有效元素小于等于能存储的数组长度,同时缩容后长度的大于等于10,方可进行缩容操作
if(size<=(data.length-1)/4&&(data.length-1)/2>=10){
resize((data.length-1)/2+1); //缩容缩一半
}
return ret; //返回被删除的元素
}
//扩缩容函数
private void resize(int newLen){
E[] newData= (E[]) (new Object[newLen]); //创新数组,即缩容后的数组
int p=front; //用指针p遍历原数组
int i=0; //用指针i遍历新数组
while(true){
newData[i]=data[p]; //把原数组中的元素复制给新数组
i++;
p=(p+1)%data.length;
if(p==rear){ //p指针遍历的尾指针处结束循环
break;
}
}
front=0; //把头指针指向扩容后数组表头位置
rear=size; //尾指针指向有效元素长度角标
data=newData; //把新数组给元素组,偷梁换柱
}
@Override
public E getFront() {
if(isEmpty()){
throw new IllegalArgumentException("队列为空");
}
return data[front]; //获取队头,队头就是头指针处
}
@Override
public E getRear() {
if(isEmpty()){
throw new IllegalArgumentException("队列为空");
}
return data[(rear-1+data.length)%data.length];
//获取队尾,队尾是尾指针的前一个,尾指针始终指向空
}
//清空队列元素,把构造函数里的代码拿过来(初始化状态)
@Override
public void clear() {
data= (E[]) (new Object[11]);//因为有一个空的空间
front=0;
rear=0;
size=0;
}
@Override
public String toString() {
StringBuilder sb=new StringBuilder();
//创建StringBuilder对象,可以直接在原字符串上添加字符,不许要每次改变都创新字符串
/*
输出这样的格式
ArrayQueueLoop: 15/20
[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]
*/
sb.append(String.format("ArrayQueueLoop: %d/%d\n",size,data.length-1));
sb.append('[');
if(isEmpty()){
sb.append(']');
}else{
for(int i=front;i!=rear;i=(i+1)%data.length){
//打印元素,从头指针处开始,到达指针结束
sb.append(data[i]);
if((i+1)%data.length==rear){
//当遍历到指针i下一个位置是尾指针处时,此时i在最后一个元素处,打印']'
sb.append(']');
}else{ //否则在元素间打印','
sb.append(',');
}
}
}
return sb.toString(); //返回sb对象,调用toString方法
}
@Override
public Iterator<E> iterator() {
return new ArrayQueueLoopIterator(); //创建内部类对象
}
//迭代器 内部类(就是打印表内元素,并让其支持foreach循环)
private class ArrayQueueLoopIterator implements Iterator{
int p=front; //从头指针处开始
@Override
public boolean hasNext() {
return p!=rear; //继续条件:p指针不指向尾指针处
}
@Override
public Object next() {
E ret=data[p]; //ret输出元素
p=(p+1)%data.length; //p递增
return ret;
}
}
}
如果有什么问题或者不懂,欢迎私信博主,博主会尽我最大能力帮助你哦!