介绍
双向队列（deque，全名double-ended queue）是一种具有队列和栈性质的数据结构。
对于队列，我们只能在头部删除或在尾部添加元素，
而「双向队列 Deque」更加灵活，在其两端都能执行元素添加或删除操作。
常用操作
| 方法名 | 描述 | 时间复杂度 |
| pushFirst() | 将 元素添加至队首 | O（1） |
| pushLast() | 将元素添加至队尾 | O（1） |
| pollFirst() | 删除队首元素 | O（1） |
| pollLast() | 删除队尾元素 | O（1） |
| peekFirst() | 访问队首元素 | O（1） |
| peekLast() | 访问队尾元素 | O（1） |
| size() | 获取队列的长度 | O（1） |
| isEmpty() | 判断队列是否为空 | O（1） |
/*初始化双向队列*/
Deque<Integer> deque = new LinkedList<>();
/*元素入队*/
deque.offerLast(2);//添加至队尾
deque.offerLast(5);
deque.offerLast(4);
deque.offerFirst(3); // 添加至队首
deque.offerFirst(1);
/* 访问元素 */
int peekFirst = deque.peekFirst(); // 队首元素
int peekLast = deque.peekLast(); // 队尾元素
/*元素出队*/
int popFirst = deque.pollFirst(); // 队首元素出队
int popLast = deque.pollLast();// 队尾元素出队
/*获取双向队列的长度 */
int size = deque.size();
/*判断双向队列是否为空*/
boolean isEmpty = deque.isEmpty();实现
与队列类似，双向队列同样可以使用链表或数组来实现
1.基于双向链表的实现
由于可以方便地删除链表头结点(即出队)，以及在链表尾结点后添加新结点(即入队)，因此我们使用普通单向链表来实现队列，
而双向队列的头部和尾部都可以执行入队与出队操作
换言之，双向队列的操作是“首尾对称”的，也需要实现另一个对称方向的操作
因此，双向队列需要使用「双向链表」来实现
将双向链表的头结点和尾结点分别看作双向队列的队首和队尾，并且实现在两端都能添加与删除结点
/*双向链表节点*/
class ListNode {
int val; // 节点值
ListNode next; // 后继节点引用(指针)
ListNode prev; // 前驱节点引用(指针)
ListNode(int val) {
this.val = val;
prev = next = null;
}
}
/*基于双向链表实现的双向队列*/
class LinkedListDeque {
private ListNode front, rear; // 头节点front ，尾节点rear
private int queSize = 0; // 双向队列的长度
public LinkedListDeque() {
front = rear = null;
}
/*获取双向队列的长度*/
public int size() {
return queSize;
}
/*判断双向队列是否为空*/
public boolean isEmpty() {
return size() == 0;
}
/*入队操作*/
private void push(int num, boolean isFront) {
ListNode node = new ListNode(num);
// 若链表为空，则令front，rear都指向node
if (isEmpty()) {
front = rear = node;
} else if (isFront) { // 队首入队操作
// 将node添加至链表头部
front.prev = node;
node.next = front;
front = node; // 更新头节点
} else { // 队尾入队操作
// 将node添加至链表尾部
rear.next = node;
node.prev = rear;
rear = node; // 更新尾节点
}
queSize++; // 更新队列长度
}
/*队首入队*/
public void pushFirst(int num) {
push(num, true);
}
/*队尾入队*/
public void pushLast(int num) {
push(num, false);
}
/*出队操作*/
private Integer pop(boolean isFront) {
// 若队列为空，直接返回null
if (isEmpty()) {
return null;
}
int val;
if (isFront) { // 队首出队操作
val = front.val; // 暂存头节点值
// 删除头节点
ListNode fNext = front.next;
if (fNext != null) {
fNext.prev = null;
front.next = null;
}
front = fNext; // 更新头节点
} else { // 队尾出队操作
val = rear.val; // 暂存尾节点值
// 删除尾节点
ListNode rPrev = rear.prev;
if (rPrev != null) {
rPrev.next = null;
rear.prev = null;
}
rear = rPrev; // 更新尾节点
}
queSize--; // 更新队列长度
return val;
}
/*队首出队*/
public Integer popFirst() {
return pop(true);
}
/*队尾出队*/
public Integer popLast() {
return pop(false);
}
/*访问队首元素*/
public Integer peekFirst() {
return isEmpty() ? null : front.val;
}
/*访问队尾元素*/
public Integer peekLast() {
return isEmpty() ? null : rear.val;
}
/*返回数组用于打印*/
public int[] toArray() {
ListNode node = front;
int[] res = new int[size()];
for (int i = 0; i < res.length; i++) {
res[i] = node.val;
node = node.next;
}
return res;
}
}2.基于环形数组的实现
与基于数组实现队列类似，我们也可以使用环形数组来实现双向队列
在实现队列的基础上，增加实现“队首入队”和“队尾出队”方法即可
/*基于环形数组实现的双向队列*/
class CircularDeque {
private int capacity; // 队列容量
private int[] arr; // 存储数据的数组
private int front; // 头指针，指向队头元素的位置
private int rear; // 尾指针，指向队尾元素的下一个位置
public CircularDeque(int k) {
capacity = k + 1;
arr = new int[capacity];
front = 0;
rear = 0;
}
/* 获取双向队列的长度 */
public int size() {
return (rear - front + capacity) % capacity;
}
/* 判断双向队列是否为空 */
public boolean isEmpty() {
return front == rear;
}
/* 判断双向队列是否已满 */
public boolean isFull() {
return (rear + 1) % capacity == front;
}
/* 从队头插入元素 */
public boolean insertFront(int value) {
if (isFull()) { // 队列已满
return false;
}
front = (front - 1 + capacity) % capacity; // 计算新的头指针位置
arr[front] = value;
return true;
}
/* 从队尾插入元素 */
public boolean insertLast(int value) {
if (isFull()) { // 队列已满
return false;
}
arr[rear] = value;
rear = (rear + 1) % capacity; // 计算新的尾指针位置
return true;
}
/* 从队头删除元素 */
public boolean deleteFront() {
if (isEmpty()) { // 队列为空
return false;
}
front = (front + 1) % capacity; // 计算新的头指针位置
return true;
}
/* 从队尾删除元素 */
public boolean deleteLast() {
if (isEmpty()) { // 队列为空
return false;
}
rear = (rear - 1 + capacity) % capacity; // 计算新的尾指针位置
return true;
}
/* 获取队头元素 */
public int getFront() {
if (isEmpty()) { // 队列为空
return -1;
}
return arr[front];
}
/* 获取队尾元素 */
public int getRear() {
if (isEmpty()) { // 队列为空
return -1;
}
return arr[(rear - 1 + capacity) % capacity];
}
/* 入队操作 */
private void enqueue(int num, boolean isFront) {
if (isFull()) { // 队列已满，无法入队
return;
}
if (isFront) { // 头部入队
front = (front - 1 + capacity) % capacity; // 新的头指针位置
arr[front] = num;
} else { // 尾部入队
arr[rear] = num;
rear = (rear + 1) % capacity; // 新的尾指针位置
}
}
/* 头部入队 */
public void enqueueFront(int num) {
enqueue(num, true);
}
/* 尾部入队 */
public void enqueueRear(int num) {
enqueue(num, false);
}
/* 出队操作 */
private Integer dequeue(boolean isFront) {
if (isEmpty()) { // 队列为空，无法出队
return null;
}
int res;
if (isFront) { // 头部出队
res = arr[front];
front = (front + 1) % capacity; // 新的头指针位置
} else { // 尾部出队
rear = (rear - 1 + capacity) % capacity; // 新的尾指针位置
res = arr[rear];
}
return res;
}
/* 头部出队 */
public Integer dequeueFront() {
return dequeue(true);
}
/* 尾部出队 */
public Integer dequeueRear() {
return dequeue(false);
}
/* 打印输出双向队列中的元素 */
public void printDeque() {
if (isEmpty()) { // 队列为空
System.out.println("[]");//输出空列表[]
return;
}
StringBuilder sb = new StringBuilder("[");
for (int i = front; i != rear; i = (i + 1) % capacity) {
sb.append(arr[i]);
if ((i + 1) % capacity != rear) {
sb.append(", ");
}
}
sb.append("]");
System.out.println(sb.toString());
}
}
//点提：修改头指针或尾指针时需要取模->保证它们的范围在[0, capacity)之间环形数组实现双向队列，需要注意头指针和尾指针的计算方法，以及队列判空和判满的条件。
