双端队列Deque

前言

双端队列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;
        }
    }

写在最后

        希望认真看完的同学，朋友可以找找代码的茬，总感觉代码有点问题，又说不清哪里的问题，很难受给，找到问题一定评论区交流一哈，

        加油，大家。