队列(Queue)
◼ 队列是一种特殊的线性表，只能在头尾两端进行操作
队尾(rear):只能从队尾添加元素，一般叫做 enQueue，入队
队头(front):只能从队头移除元素，一般叫做 deQueue，出队
先进先出的原则，First In First Out，FIFO
队列的接口设计
◼int size(); // 元素的数量
◼boolean isEmpty(); // 是否为空
◼void clear(); // 清空
◼void enQueue(E element); // 入队
◼E deQueue(); // 出队
◼E front(); // 获取队列的头元素
◼ 队列的内部实现是否可以直接利用以前学过的数据结构？
动态数组、链表
优先使用双向链表，因为队列主要是往头尾操作元素
练习 – 用栈实现队列
◼ https://leetcode-cn.com/problems/implement-queue-using-stacks/
◼ 准备2个栈:inStack、outStack
入队时，push 到 inStack 中
出队时
✓如果 outStack 为空，将 inStack 所有元素逐一弹出，push 到 outStack，outStack 弹出栈顶元素
✓如果 outStack 不为空， outStack 弹出栈顶元素
◼ 假设如下操作:11入队、22入队、出队、33入队、出队 inStack outStack inStack outStack
package alangeit;
import alangeit.list.LinkedList;
import alangeit.list.List;
public class Queue {
private List list = new LinkedList<>();
public int size() {
return list.size();
}
public boolean isEmpty() {
return list.isEmpty();
}
public void clear() {
list.clear();
}
public void enQueue(E element) {
list.add(element);
}
public E deQueue() {
return list.remove(0);
}
public E front() {
return list.get(0);
}
}
// 队列
static void test1() {
System.out.println("--------------------------------- 队列");
Queue queue = new Queue<>();
queue.enQueue(11);
queue.enQueue(22);
queue.enQueue(33);
queue.enQueue(44);
while (!queue.isEmpty()) {
System.out.println(queue.deQueue());
}
}
双端队列(Deque)
◼ 双端队列是能在头尾两端添加、删除的队列
英文 deque 是 double ended queue 的简称
◼int size(); // 元素的数量
◼boolean isEmpty(); // 是否为空
◼void clear(); // 清空
◼void enQueueRear(E element);// 从队尾入队
◼E deQueueFront(); // 从队头出队
◼void enQueueFront(E element);// 从队头入队
◼E deQueueRear(); // 从队尾出队
◼E front(); // 获取队列的头元素
◼E rear(); // 获取队列的尾元素
package alangeit;
// 双端队列
import alangeit.list.LinkedList;
import alangeit.list.List;
public class Deque {
private List list = new LinkedList<>();
public int size() {
return list.size();
}
public boolean isEmpty() {
return list.isEmpty();
}
public void clear() {
list.clear();
}
public void enQueueRear(E element) {
list.add(element);
}
public E deQueueFront() {
return list.remove(0);
}
public void enQueueFront(E element) {
list.add(0, element);
}
public E deQueueRear() {
return list.remove(list.size() - 1);
}
public E front() {
return list.get(0);
}
public E rear() {
return list.get(list.size() - 1);
}
}
// 双端队列
static void test() {
System.out.println("--------------------------------- 双端队列");
Deque queue1 = new Deque<>();
queue1.enQueueFront(11);
queue1.enQueueFront(22);
queue1.enQueueRear(33);
queue1.enQueueRear(44);
/* 头 22 11 33 44 尾 */
// while (!queue1.isEmpty()) {
// System.out.println(queue1.deQueueFront());
// }
/* 尾 44 33 11 22 头 */
while (!queue1.isEmpty()) {
System.out.println(queue1.deQueueRear());
}
}
循环队列(Circle Queue)
◼其实队列底层也可以使用动态数组实现，并且各项接口也可以优化到 O(1) 的时间复杂度
◼ 这个用数组实现并且优化之后的队列也叫做:循环队列
◼ 循环双端队列:可以进行两端添加、删除操作的循环队列
package alangeit.circle;
@SuppressWarnings("unchecked")
public class CircleQueue {
private int front;// 队头下标
private int size;
private E[] elements;
private static final int DEFAULT_CAPACITY = 10;
public CircleQueue() {
elements = (E[]) new Object[DEFAULT_CAPACITY];
}
public int size() {
return size;
}
public boolean isEmpty() {
return size == 0;
}
public void clear() {
for (int i = 0; i < size; i++) {
elements[index(i)] = null;
}
front = 0;
size = 0;
}
// 入队
public void enQueue(E element) {
ensureCapacity(size + 1);
elements[index(size)] = element;
size++;
}
// 出队
public E deQueue() {
E frontElement = elements[front];
elements[front] = null;
front = index(1);
size--;
return frontElement;
}
public E front() {
return elements[front];
}
@Override
public String toString() {
StringBuilder string = new StringBuilder();
string.append("capcacity=").append(elements.length)
.append(" size=").append(size)
.append(" front=").append(front)
.append(", [");
for (int i = 0; i < elements.length; i++) {
if (i != 0) {
string.append(", ");
}
string.append(elements[i]);
}
string.append("]");
return string.toString();
}
private int index(int index) {
index += front;
return index - (index >= elements.length ? elements.length : 0);
}
/**
* 保证要有capacity的容量
* @param capacity
*/
private void ensureCapacity(int capacity) {
int oldCapacity = elements.length;
if (oldCapacity >= capacity) return;
// 新容量为旧容量的1.5倍
int newCapacity = oldCapacity + (oldCapacity >> 1);
E[] newElements = (E[]) new Object[newCapacity];
for (int i = 0; i < size; i++) {
newElements[i] = elements[index(i)];
}
elements = newElements;
// 重置front
front = 0;
}
}
// 循环队列
static void test() {
System.out.println("--------------------------------- 循环队列");
CircleQueue queue = new CircleQueue();
// 0 1 2 3 4 5 6 7 8 9
for (int i = 0; i < 10; i++) {
queue.enQueue(i);// 入队
}
// null null null null null 5 6 7 8 9
for (int i = 0; i < 5; i++) {
queue.deQueue();// 出队
}
System.out.println(queue);
while (!queue.isEmpty()) {
System.out.println(queue.deQueue());
}
// 15 16 17 18 19 5 6 7 8 9
for (int i = 15; i < 20; i++) {// 扩容
queue.enQueue(i);// 入队
}
System.out.println(queue);
while (!queue.isEmpty()) {
System.out.println(queue.deQueue());
}
System.out.println(queue);
}
循环双端队列
package alangeit.circle;
// 循环双端队列
@SuppressWarnings("unchecked")
public class CircleDeque {
private int front;
private int size;
private E[] elements;
private static final int DEFAULT_CAPACITY = 10;
public CircleDeque() {
elements = (E[]) new Object[DEFAULT_CAPACITY];
}
public int size() {
return size;
}
public boolean isEmpty() {
return size == 0;
}
public void clear() {
for (int i = 0; i < size; i++) {
elements[index(i)] = null;
}
front = 0;
size = 0;
}
/**
* 从尾部入队
* @param element
*/
public void enQueueRear(E element) {
ensureCapacity(size + 1);// 扩容
elements[index(size)] = element;
size++;
}
/**
* 从头部出队
* @param element
*/
public E deQueueFront() {
E frontElement = elements[front];
elements[front] = null;
front = index(1);
size--;
return frontElement;
}
/**
* 从头部入队
* @param element
*/
public void enQueueFront(E element) {
ensureCapacity(size + 1);// 扩容
front = index(-1);
elements[front] = element;
size++;
}
/**
* 从尾部出队
* @param element
*/
public E deQueueRear() {
int rearIndex = index(size - 1);
E rear = elements[rearIndex];
elements[rearIndex] = null;
size--;
return rear;
}
// 头部
public E front() {
return elements[front];
}
// 尾部
public E rear() {
return elements[index(size - 1)];
}
@Override
public String toString() {
StringBuilder string = new StringBuilder();
string.append("capcacity=").append(elements.length)
.append(" size=").append(size)
.append(" front=").append(front)
.append(", [");
for (int i = 0; i < elements.length; i++) {
if (i != 0) {
string.append(", ");
}
string.append(elements[i]);
}
string.append("]");
return string.toString();
}
private int index(int index) {
index += front;
if (index < 0) {
return index + elements.length;
}
return index - (index >= elements.length ? elements.length : 0);
}
/**
* 保证要有capacity的容量
* @param capacity
*/
private void ensureCapacity(int capacity) {
int oldCapacity = elements.length;
if (oldCapacity >= capacity) return;
// 新容量为旧容量的1.5倍
int newCapacity = oldCapacity + (oldCapacity >> 1);
E[] newElements = (E[]) new Object[newCapacity];
for (int i = 0; i < size; i++) {
newElements[i] = elements[index(i)];
}
elements = newElements;
// 重置front
front = 0;
}
}
// 循环双端队列
static void test() {
System.out.println("--------------------------------- 循环双端队列");
CircleDeque queue = new CircleDeque<>();
// 头5 4 3 2 1 100 101 102 103 104 105 106 8 7 6 尾
// 头 8 7 6 5 4 3 2 1 100 101 102 103 104 105 106 107 108 109 null null 10 9 尾
for (int i = 0; i < 10; i++) {// 入队
queue.enQueueFront(i + 1);
queue.enQueueRear(i + 100);
}
System.out.println(queue);
// 头 null 7 6 5 4 3 2 1 100 101 102 103 104 105 106 null null null null null null null 尾
for (int i = 0; i < 3; i++) {// 出队
queue.deQueueFront();
queue.deQueueRear();
}
System.out.println(queue);
// 头 11 7 6 5 4 3 2 1 100 101 102 103 104 105 106 null null null null null null 12 尾
queue.enQueueFront(11);
queue.enQueueFront(12);
System.out.println(queue);
while (!queue.isEmpty()) {
System.out.println(queue.deQueueFront());
}
}
%运算符优化
◼ 尽量避免使用乘*、除/、模%、浮点数运算，效率低下
◼ 已知n>=0，m>0
n%m 等价于 n – (m > n ? 0 : m) 的前提条件:n < 2m
作业 – 用队列实现栈
◼ https://leetcode-cn.com/problems/implement-stack-using-queues/