Java-实现双端队列【分析源码】

实现双端队列（理解源码）

队列，作为一种特殊的数据结构；具有先进先出的特点，双端队列是指“可以在队首队尾都可以增删元素”的一种数据结构

步骤一：定义接口：Dequeue、Stack

定义两个接口（Dequeue、Stack），然后让我们创建的ArrayDeque类实现这两个接口。
Dequeue接口：

public interface Dequeue<E> extends Queue<E>{
    public void addFirst(E element);//在队首添加元素
    public void addLast(E element);//在队尾添加元素
    public E removeFirst();
    public E removeLast();
    public E getFirst();
    public E getLast();
}
//在这里让我们的Dequeue继承自该接口
public interface Queue <E> extends Iterable<E> {
    public void offer(E element);
    public E poll();
    public E peek();
    public E element();    //查看队首元素
    public boolean isEmpty();
    public void clear();
    public int size();
    public Iterator<E> iterator();

}

Stack接口：

public interface Stack<E> extends Iterable<E> {
    public int size();//获取栈中元素个数
    public boolean isEmpty();
    //入栈 进栈一个元素 在线性表的表尾添加一个元素
    public void push(E element);
    //出栈 弹出一个元素 在线性表的表尾删除一个元素
    public E pop();
    //查看当前栈顶元素 并不是移除 =》查看线性表中最后一个元素
    public E peek();
    public void clear();
}

步骤二：定义ArrayDeque类，实现Dequeue，Stack，同时让该类支持泛型。

源代码实现：

//双端队列
import java.util.Iterator;

public class ArrayDeque<E> implements Dequeue<E>, Stack<E>{
    private E[] data;
    private int front;//队首指针
    private int rear;
    private int size;
    private static int DEFAULT_CAPACITY = 10;

    public ArrayDeque(){
        data = (E[]) new Object[DEFAULT_CAPACITY + 1];//rear指向null的
        front = 0;
        rear = 0;
        size = 0;
    }
    @Override
    public void addFirst(E element){
        if((rear + 1) % data.length == front){
            //双端队列满
            resize(data.length * 2 - 1);
        }
        front = (front - 1 + data.length) % data.length;
        data[front] = element;
        size++;
    }

    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 void addLast(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 removeFirst(){
        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;
    }
    @Override
    public E removeLast(){
        if(isEmpty()){
            throw new IllegalArgumentException("queue is null");
        }
        rear = (rear - 1 + data.length) % data.length;
        E ret = data[rear];
        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("queue is null");
        }
        return data[front];
    }
    @Override
    public E getLast(){
        if(isEmpty()){
            throw new IllegalArgumentException("queue is null");
        }
        return data[(rear - 1 + data.length) % data.length];
    }

    @Override
    public void offer(E element) {
        //实现队列的入队
        addLast(element);
    }

    @Override
    public E poll() {
        return removeFirst();
    }

    @Override
    public E element() {
        return getFirst();
    }

    @Override
    public E peek() {
        //获取栈顶元素
        return getLast();
    }

    @Override
    public boolean isEmpty() {
        return size == 0 && front == rear;
    }

    @Override
    public void push(E element) {
        //入栈一个元素
        addLast(element);
    }

    @Override
    public E pop() {
        return removeLast();
    }

    @Override
    public void clear() {
        E[] data = (E[]) new Object[DEFAULT_CAPACITY];
        front = 0;
        rear = 0;
        size = 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 Iterator<E> iterator() {
        return new ArrayDequeIterator();
    }

    class ArrayDequeIterator 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;
        }
    }
}