一.概念
双端队列的意思是可以在头部和尾部添加和删除元素，更一般的单向链表队列比起来更加的灵活，下面我们用双向循环带哨兵链表和数组来分别实现
二.定义接口Dequeue
/**
* 双端队列
*/
public interface Dequeue<E> {
//队头添加元素
boolean offerTop(E e);
//队尾添加元素
boolean offerTail(E e);
//队头取元素并删除该元素
E pollTop();
//队尾取元素并删除该元素
E pollTail();
//队头取元素
E peekTop();
//队尾取元素
E peekTail();
//是否为空
boolean isEmpty();
//是否为满
boolean isFull();
}三.双向循环带哨兵链表链表实现
1.图示
（1）向队头添加节点
（2）向队尾添加节点
对于移除节点，和上面的类似，代码注释中也都做了解释，这里就不在展示了。
2.代码实现
/**
* 双向链表实现双端队列
* @param <E>
*/
public class LinkedDequeue<E> implements Dequeue<E> ,Iterable<E>{
//内部节点类
static class Node<E>{
Node<E> pre;
E value;
Node<E> next;
public Node(Node<E> pre,E value,Node<E> next){
this.pre = pre;
this.value = value;
this.next = next;
}
}
//容量
int capacity;
//队列中元素的个数
int size;
//哨兵
Node<E> sentinel = new Node<>(null,null,null);
//初始化
public LinkedDequeue(int capacity){
//初始化容量
this.capacity = capacity;
//开始时哨兵的下一个节点是本身
sentinel.next = sentinel;
//上一个节点也是本身
sentinel.pre = sentinel;
}
@Override
public Iterator<E> iterator() {
return new Iterator<E>() {
//获取第一个元素
Node<E> p = sentinel.next;
@Override
public boolean hasNext() {
//如果p==sentinel就说明遍历完成了，没有下一个了
return p != sentinel;
}
@Override
public E next() {
E value = p.value;
p = p.next;
return value;
}
};
}
/**
* 向头部添加节点
* a -> added -> b
* <- <-
* a是哨兵， b是哨兵的下一个节点
* @param e
* @return
*/
@Override
public boolean offerTop(E e) {
if(isFull()){
return false;
}
Node<E> a = sentinel;
Node<E> b = sentinel.next;
Node<E> added = new Node<>(a,e,b);
a.next = added;
b.pre = added;
size++;
return true;
}
/**
* 向尾部添加节点
*
a -> added -> b
* <- <-
* a是哨兵的上一个，b是哨兵
*
* @param e
* @return
*/
@Override
public boolean offerTail(E e) {
if(isFull()){
return false;
}
Node<E> b = sentinel;
Node<E> a = sentinel.pre;
Node<E> added = new Node<>(a,e,b);
a.next = added;
b.pre = added;
size++;
return true;
}
/**
* 将头部节点移除
* @return 头部元素的值
*
* a removed b
* a是哨兵，removed是哨兵的下一个，b是removed的下一个
* a -> b
* <-
*/
@Override
public E pollTop() {
if(isEmpty()){
return null;
}
Node<E> a = sentinel;
Node<E> removed = sentinel.next;
Node<E> b = removed.next;
a.next = b;
b.pre = a;
size--;
return removed.value;
}
/**
* 将尾部节点移除
* @return 尾部元素的值
*
* a removed b
* b是哨兵，removed是b的上一个，a是removed的上一个
* a -> b
* <-
*/
@Override
public E pollTail() {
if(isEmpty()){
return null;
}
Node<E> b = sentinel;
Node<E> removed = sentinel.pre;
Node<E> a = removed.pre;
a.next = b;
b.pre = a;
size--;
return removed.value;
}
/**
* 获取第一个元素的值，但是不移除
* @return
*/
@Override
public E peekTop() {
if(isEmpty()){
return null;
}
return sentinel.next.value;
}
/**
* 获取最后一个元素的值，但是不移除
* @return
*/
@Override
public E peekTail() {
if(isEmpty()){
return null;
}
return sentinel.pre.value;
}
@Override
public boolean isEmpty() {
return size == 0;
}
@Override
public boolean isFull() {
return size == capacity;
}
}四.数组带头尾指针实现
1.图示
（1）刚开始时head和tail都在同一位置，表示空
当在尾部tail添加元素时，先在tail处添加元素，然后让tail加一,
注意:这里的加一不是直接tail++,因为是循环队列，所以若到了array.length处，也就是末尾，下一次加一就要跑到索引0的位置了，一般我们之前是用的求余数运算来找到合法的索引位置，但是我们这里会用一个新的方式来运算索引
（2）tail处添加元素
（3）head处添加元素
我们在head处添加元素时，我们是让head先减一，然后再在head处添加，为啥呢？因为我们是循环数组，让head减一，相当于改变了头的位置，好像是在向左移动一样，向左扩展，
注意：这里的减一也是要算出合法的索引，而且如果head本来是在索引0处，那么head就要移动到array.length处，这样就好像是在向前移动
对于头部尾部移除元素，都是类似的，在此不过多描述。
（4）代码实现
/**
* 数组实现双端队列
* @param <E>
*/
public class ArrayDequeue<E> implements Dequeue<E>,Iterable<E>{
E array[];
//头指针
int head;
//尾指针
int tail;
@SuppressWarnings("all")
public ArrayDequeue(int capacity){
//实际容量要多空出一个来判断空满
array = (E[]) new Object[capacity+1];
}
//加一方法
public static int inc(int i,int length){
if(i + 1 >= length){
return 0;
}
return i + 1;
}
//减一方法
public static int dec(int i,int length){
if(i - 1 < 0){
return length - 1;
}
return i - 1;
}
/**
* 头部添加元素
*
* 先让head--,然后再在head处添加元素
*
* @param e
* @return
*/
@Override
public boolean offerTop(E e) {
if(isFull()){
return false;
}
head = dec(head,array.length);
array[head] = e;
return true;
}
/**
* 在尾部添加依赖
*
* 先在tail处添加元素，然后让tail++
* @param e
* @return
*/
@Override
public boolean offerTail(E e) {
if(isFull()){
return false;
}
array[tail] = e;
tail = inc(tail,array.length);
return true;
}
/**
* 移除队头元素
*
* 先获取head处元素，然后让head++
*
* @return
*/
@Override
public E pollTop() {
if(isEmpty()){
return null;
}
E e = array[head];
array[head] = null; //help GC
head = inc(head,array.length);
return e;
}
/**
* 移除队尾元素
*
* 先让tail--，然后返回tail处的值
*
* @return
*/
@Override
public E pollTail() {
if(isEmpty()){
return null;
}
tail = dec(tail,array.length);
E e = array[tail];
array[tail] = null; //help GC
return e;
}
@Override
public E peekTop() {
if(isEmpty()){
return null;
}
return array[head];
}
@Override
public E peekTail() {
if(isEmpty()){
return null;
}
return array[dec(tail, array.length)];
}
/**
* 判断是否为空
* @return
*/
@Override
public boolean isEmpty() {
return head == tail;
}
/**
* 判断是否为满
* @return
*/
@Override
public boolean isFull() {
//当 head > tail 时，
/**
* 需要判断 head - tail == 1
*/
/**
* 当 tail > head 时
* 需要判断 tail - head == array.length - 1;
*/
if(head > tail){
return head - tail == 1;
}else if( head < tail){
return tail - head == array.length - 1;
}else{
return false;
}
}
/**
* 遍历
* @return
*/
@Override
public Iterator<E> iterator() {
return new Iterator<E>() {
int p = head;
@Override
public boolean hasNext() {
return p != tail;
}
@Override
public E next() {
E e = array[p];
p = inc(p,array.length);
return e;
}
};
}
}五.及时释放元素
我们在之前的队列和栈的移除元素操作时，每次都是直接跳过元素，相当于移除了该元素，其实这里有误区：
1.如果元素类型为基本类型，比如Int类型，那么一个数字占四个字节，直接跳过和设置为0都占用内存空间，设置为0意义不大，所以直接跳过就可以了。
2.如果元素类型为引用类型，比如Student学生对象，那么如果你直接跳过该元素，其实他并没有被释放，也就是不能被GC回收，这时需要我们手动释放元素，我们可以让array[x]=null;来释放内存空间
另外说一点，在jdk中有一个类LinkedList,这个类可用当栈，也可以当队列，也实现了双端队列的功能
