前言
双端队列Deque底层实现和队列的底层实现是一样的,唯一的区别只在于我们添加和删除的操作可以在头和尾都可以操作
1、我们先定义自己的Deque接口,对其中方法进行实现即可
public interface Deque<E> extends Iterable<E>{
public void addFirst(E element);
public void addLast(E element);
public E removeFirst();
public E removeLast();
public E getFirst();
public E getLast();
public int size();
public boolean isEmpty();
public void clear();
}
2、成员变量
private E[] data;//底层数组
private int first;//头
private int last;//尾
private static int DEFAULT_CAPACITY=10;//初始容量
private int size;//有效数据长度
3、构造函数
public ArrayDeque(){
data= (E[]) new Object[DEFAULT_CAPACITY+1];//初始容量+1
//是方便我们之后增添的操作,实际能够存储的还是我们的DEFAULT_CAPACITY
last=0;
first=0;
size=0;
}
4、增添
增添也是比较关键,和我们的Queue区别还是比较大
头添时
****关键点1****置空取余操作
可以看到,我们的头指针从原本的指向0,改变为指向我们的末尾,添加的过程中f会不断减小,而我们的数组长为11,由于0-1之后会超出界限,我们加上我们的数组长,再对数组长取余即可完美解决,双端队列的关键也在于取余,取余操作蛮多也蛮关键,另外让我们的头指针或者尾指针始终指向一个null的数据域也很巧妙,要着重理解
我们这个是让尾指针指向null,所以当移动了我们的头指针后,只需要在将我们要添加的数据放入我们头指针指向的数据域即可
****关键点2****扩容及缩容
由于我们数组的特性(固定的长度),我们底层是数组实现的数据结构,都避免不了扩容和缩容,当我们数组中存放的数据已经满了以后,我们就需要扩容了
对于我们的Deque来说判满就很重要了
可以看到 第一种情况我们单纯尾指针+1==头指针即可,但是我们的第二种情况,尾指针+1都越界了,此时取余就很好了,综合两种情况,第一种取余操作也不会有影响
@Override
public void addFirst(E element) {
if((last+1)%data.length==first)
resize(data.length*2-1);
first=(first-1+data.length)%data.length;
data[first]=element;
size++;
}
//扩容函数,只向内提供,不对外开放
private void resize(int newLen) {
E[] newData= (E[]) new Object[newLen];
int index=0;
int i1=first;
while (i1!=last){
newData[index++]=data[i1];
i1=(i1+1)%data.length;
}
data=newData;
last=index;
first=0;
}
@Override
public void addLast(E element) {
if((last+1)%data.length==first)
resize(data.length*2-1);
data[last]=element;
last=(last+1)%data.length;
size++;
}
5、删除及其他
由于删除,清空,判空,获取头尾,清空,tostring,equals,迭代器这些都是常规操作就不多赘述了,有不懂的地方,欢迎交流。
@Override
public E removeFirst() {
if(isEmpty())
throw new IllegalArgumentException("null");
E ret=data[first];
first=(first+1)%data.length;
size--;
if(size==(data.length-1)/4&&data.length-1>DEFAULT_CAPACITY)
resize(data.length/2+1);
return ret;
}
@Override
public E removeLast() {
if(isEmpty())
throw new IllegalArgumentException("null");
last=(last-1+data.length)%data.length;
E ret=data[last];
size--;
if(size==(data.length-1)/4&&data.length-1>DEFAULT_CAPACITY)
resize(data.length/2+1);
return ret;
}
@Override
public E getFirst() {
if(isEmpty())
throw new IllegalArgumentException("null");
return data[first];
}
@Override
public E getLast() {
if(isEmpty())
throw new IllegalArgumentException("null");
return data[(last-1+data.length)%data.length];
}
@Override
public int size() {
return size;
}
@Override
public boolean isEmpty() {
return size==0;
}
@Override
public void clear() {
data= (E[]) new Object[DEFAULT_CAPACITY+1];
last=0;
first=0;
size=0;
}
@Override
public String toString() {
StringBuilder stringBuilder=new StringBuilder();
stringBuilder.append('[');
if (isEmpty()) {
stringBuilder.append(']');
} else{
for (int i=first;i != last; i=(i+1)%data.length) {
stringBuilder.append(data[i]);
if((i+1)%data.length!=last)
stringBuilder.append(',');
else stringBuilder.append(']');
}
}
return stringBuilder.toString();
}
@Override
public boolean equals(Object obj) {
if (obj == null) {
return false;
}
if (obj == this) {
return true;
}
if (obj instanceof ArrayDeque) {
ArrayDeque other = (ArrayDeque) obj;
if (this.size == other.size) {
int i1 = this.first;
int i2 = other.first;
while (i1 != this.last) {
if (!this.data[i1].equals(other.data[i2])) {
return false;
}
i1 = (i1 + 1) % this.data.length;
i2 = (i2 + 1) % other.data.length;
}
return true;
} else {
return false;
}
} else {
return false;
}
}
@Override
public Iterator<E> iterator() {
return new ArrayDequeIterator();
}
private class ArrayDequeIterator<E> implements Iterator<E> {
private int cur=first;
@Override
public boolean hasNext() {
return cur!=last;
}
@Override
public E next() {
E ret= (E) data[cur];
cur=(cur+1)%data.length;
return ret;
}
}
写在最后
希望认真看完的同学,朋友可以找找代码的茬,总感觉代码有点问题,又说不清哪里的问题,很难受给,找到问题一定评论区交流一哈,
加油,大家。