Java雙端隊列Deque

鏈表實現

import java.util.Iterator;
public class Deque<Item> implements Iterable<Item> {
    private class Node {
        Item item;
        Node next;
        Node pre;
    }
    private class QueueIterator implements Iterator<Item> {
        public boolean hasNext() {
            return current != null;
        }
        public Item next() {
            Item tmp = current.item;
            current = current.next;
            return tmp;
        }
        private Node current = front;
    }
    public Iterator<Item> iterator() {
        return new QueueIterator();
    }
    boolean isEmtpy() {
        return front == null;
    }
    int size() {
        return n;
    }
    void pushLeft(Item x) {
        Node oldfront = front;
        front = new Node();
        front.item = x;
        front.next = oldfront;
        front.pre = null;
        if(oldfront == null)
            rear = front;
        else
            oldfront.pre = front;
        n++;
    }
    void pushRight(Item x) {
        Node oldrear = rear;
        rear = new Node();
        rear.item = x;
        rear.next = null;
        rear.pre = oldrear;
        if(oldrear != null)
            oldrear.next = rear;
        else
            front = rear;
        n++;
    }
    Item popLeft() {
        if(isEmtpy())
            return null;
        Item tmp = front.item;
        front = front.next;
        if(front == null)
            rear = null;
        else
            front.pre = null;
        n--;
        return tmp;
    }
    Item popRight() {
        if(isEmtpy())
            return null;
        Item tmp = rear.item;
        rear = rear.pre;
        if(rear != null)
            rear.next = null;
        else
            front = null;
        n--;
        return tmp;
    }
    private Node front;
    private Node rear;
    int n;
}

動態數組調整實現

import java.util.Iterator;
public class ResizingArrrayDeque<Item> implements Iterable<Item> {
    private class DequeueIterator implements Iterator<Item> {
        public boolean hasNext() {
            return current < rear;
        }
        public Item next() {
            return array[current++];
        }
        private int current = front;
    }
    public Iterator<Item> iterator() {
        return new DequeueIterator();
    }
    public ResizingArrrayDeque() {
        array = (Item[]) new Object[max];
        n = max;
        front = n / 2;
        rear = front;
    }
    public ResizingArrrayDeque(int size) {
        if(size < 3) {
            array = (Item[]) new Object[max];
            n = max;
        }
        else {
            array = (Item[]) new Object[size];
            n = size;
        }
        front = n / 2;
        rear = front;
    }
    boolean isEmpty() {
        return n == 0;
    }
    private void resize(int len) {
        Item[] tmp = (Item[]) new Object[len];
        int i, j;
        for(i = len / 2 - n / 2, j = front; j <= rear; i++, j++)
            tmp[i] = array[j];
        front = len / 2 - n / 2;
        rear = i - 1;
        array = tmp;
    }
    public void pushLeft(Item x) {
        if(front - 1 < 0)
            resize(2 * array.length);
        array[--front] = x;
        size++;
    }
    public void pushRight(Item x) {
        if(rear + 1 >= n)
            resize(2 * array.length);
        array[rear++] = x;
        size++;
    }
    public Item popLeft() {
        if(isEmpty())
            return null;
        size--;
        Item tmp = array[front++];
        if(front == rear)
            rear++;
        return tmp;
    }
    public Item popRight() {
        if(isEmpty())
            return null;
        size--;
        Item tmp = array[--rear];
        if(rear == front)
            rear++;
        return tmp;
    }
    private Item[] array;
    private int n;
    private int front;
    private int rear;
    private int size;
    private final int max = 50;
}