一个用Java实现的双向队列，可以分别在头尾插入和删除节点

分析，双向队列的内部实现是一个双向链表，可以分别从头尾插入和删除节点。

通常使用一个first指向头 last指向尾。然后分别维护各种next和prev指针。通常情况要考虑边界条件，即当队列本身为空的时候插入新节点如何维护first和last的指向

删除节点的时候，若队列变为空又应该如何维护first和last指针。非常繁琐而且容易写错，不过使用的空间最少，代码如下

import java.util.Iterator;
import java.util.NoSuchElementException;
import edu.princeton.cs.algs4.StdOut;

public class Deque<Item> implements Iterable<Item> {
private int n;
private Node first;
private Node last;

private class Node {
private Item item;
private Node next;
private Node prev;
}
public Deque() {
n = 0;
first = null;
last = null;
}

public boolean isEmpty() {
return first == null;
}

public int size() {
return n;
}

public void addFirst(Item item) {
if (item == null)
throw new NullPointerException("can't add null element!");
Node oldfirst = first;
first = new Node();
first.item = item;
first.prev = null;
// it is and empty queue..
if (oldfirst == null) {
last = first;
first.next = null;
}
else {
first.next = oldfirst;
oldfirst.prev = first;
}
n++;
}

public void addLast(Item item) {
if (item == null)
throw new NullPointerException("can't add null element!");
Node oldlast = last;
last = new Node();
last.item = item;
last.next = null;
if (oldlast == null) {
first = last;
last.prev = null;
} else {
last.prev = oldlast;
oldlast.next = last;
}
n++;
}

public Item removeFirst() {
if (isEmpty())
throw new NoSuchElementException(
"Can't remove from empty deque");
Item item = first.item;
first = first.next;
n--;
if (n == 0)
last = null;
else
first.prev = null;
return item;
}

public Item removeLast() {
if (isEmpty())
throw new NoSuchElementException(
"Stack underflow");
Item item = last.item;
last = last.prev;
n--;
if (n == 0)
first = null;
else
last.next = null;
return item;
}
public Iterator<Item> iterator() {
return new DequeIterator();
}

private class DequeIterator implements Iterator<Item> {
private Node current = first;
public boolean hasNext() {
return current != null;
}

public void remove() {
throw new UnsupportedOperationException(
"remove is not supported!");
}

public Item next() {
if (!hasNext())
throw new NoSuchElementException();
Item item = current.item;
current = current.next;
return item;
}
}

public static void main(String[] args) {
Deque<String> dq = new Deque<String>();
dq.addFirst("A");
dq.addFirst("B");
dq.addFirst("C");
dq.addLast("Q");
dq.addLast("E");
dq.addLast("D");
for (String s : dq) {
StdOut.println(s);
}
StdOut.println("Remove first" + dq.removeFirst());
StdOut.println("Remove last" + dq.removeLast());
for (String s : dq) {
StdOut.println(s);
}
}
}

另一种方法是引入一个哨兵节点nil， 初始化时nil的prev和next分别指向自身。用于判断队列是否为空

加入新元素以后只需要操作新增节点，nil 和 nil的下一个节点。不需要考虑边界情况（因为没有nullpointer）

该方法仅多使用了一个节点的空间，但是代码看起来更加简洁如下

import java.util.Iterator;
import java.util.NoSuchElementException;
import edu.princeton.cs.algs4.StdOut;
import edu.princeton.cs.algs4.StdRandom;

public class Deque<Item> implements Iterable<Item> {
private int n;
private Node nil;

private class Node {
private Item item;
private Node next;
private Node prev;
}
public Deque() {
n = 0;
nil = new Node();
nil.next = nil;
nil.prev = nil;
}

public boolean isEmpty() {
return nil.next == nil;
}

public int size() {
return n;
}

public void addFirst(Item item) {
if (item == null)
throw new NullPointerException("can't add null element!");
Node first = new Node();
first.item = item;
first.prev = nil;
first.next = nil.next;
nil.next.prev = first;
nil.next = first;

n++;
}

public void addLast(Item item) {
if (item == null)
throw new NullPointerException("can't add null element!");
Node last = new Node();
last.item = item;
last.next = nil;
last.prev = nil.prev;
nil.prev.next = last;
nil.prev = last;

n++;
}

public Item removeFirst() {
if (isEmpty())
throw new NoSuchElementException(
"Can't remove from empty deque");
Node del = nil.next;
Item item = del.item;
del.next.prev = nil;
nil.next = del.next;
n--;
return item;
}

public Item removeLast() {
if (isEmpty())
throw new NoSuchElementException(
"Stack underflow");
Node del = nil.prev;
Item item = del.item;
del.prev.next = nil;
nil.prev = del.prev;
n--;
return item;
}
public Iterator<Item> iterator() {
return new DequeIterator();
}

private class DequeIterator implements Iterator<Item> {
private Node current = nil.next;
public boolean hasNext() {
return current != nil;
}

public void remove() {
throw new UnsupportedOperationException(
"remove is not supported!");
}

public Item next() {
if (!hasNext())
throw new NoSuchElementException();
Item item = current.item;
current = current.next;
return item;
}
}

public static void main(String[] args) {
Deque<Integer> dq = new Deque<Integer>();
for (int i = 0; i < 10; i++) {
int r = StdRandom.uniform(1, 65535);
StdOut.println("Random add and remove node for " + r);
for (int j = 0; j < r; j++) {
if (StdRandom.uniform() > 0.5)
dq.addFirst(StdRandom.uniform(0, 10));
else
dq.addLast(StdRandom.uniform(0, 10));
}
for (int n : dq)
StdOut.println(n);

for (int j = 0; j < r; j++) {
if (StdRandom.uniform() > 0.5)
dq.removeFirst();
else
dq.removeLast();
}
}
StdOut.println("Done!");
}

}