1. 概述
- 队列:是“先进先出”的数据结构,从队尾入队,从队头出队。
- 队列中使用的Array,参考“数据结构–手写动态数组”。
2. 数组队列源码
public interface Queue<T> {
int getSize();
boolean isEmpty();
void enqueue(T element);
T dequeue();
T getFront();
}
public class ArrayQueue<T> implements Queue<T> {
private Array<T> array;
public ArrayQueue() {
array = new Array<>();
}
public ArrayQueue(int capacity) {
array = new Array<>(capacity);
}
@Override
public int getSize() {
return array.getSize();
}
@Override
public boolean isEmpty() {
return array.isEmpty();
}
public int getCapacity() {
return array.getCapacity();
}
@Override
public void enqueue(T element) {
array.addLast(element);
}
@Override
public T dequeue() {
return array.removeFirst();
}
@Override
public T getFront() {
return array.getFirst();
}
@Override
public String toString() {
StringBuilder result = new StringBuilder();
result.append(String.format("Queue's size: %d, capacity: %d\n", getSize(), getCapacity()));
result.append("Head[");
int size = getSize();
for (int i = 0; i < size; i++) {
result.append(array.get(i));
if (i != size -1) {
result.append(", ");
}
}
result.append("]Tail");
return result.toString();
}
}
3. 循环队列分析及源码
-
概述
- 目的:使用数组队列,对于出队操作,是O(n)的时间复杂度,当数据量过大的时候,性能较低。
- 基础知识:
- 出队时,不再移动元素;而是,使用front和tail来标识,队列的头部和尾部所在位置。
- front == tail时,代表队列为空。
- (tail + 1) % C == front时,代表队列满。 C 代表总Capacity。
-
源码
/**
* 规则:
* 1. tail == front, 队列为空.
* 2. (tail + 1) % c == front, 队列为满.
*
* @param <T>
*/
public class LoopQueue<T> implements Queue<T> {
private T[] data;
private int front, tail;
private int size;
private static final int DEFAULT_CAPACITY = 10;
public LoopQueue() {
this(DEFAULT_CAPACITY);
}
public LoopQueue(int capacity) {
// capacity + 1: 因为tail所在的位置不能存储数据, 需要浪费一个空间.
data = (T[]) new Object[capacity + 1];
front = 0;
tail = 0;
size = 0;
}
public int getCapacity() {
// 因为tail所在的位置不能存储数据, 需要浪费一个空间.
return data.length - 1;
}
@Override
public int getSize() {
return size;
}
@Override
public boolean isEmpty() {
return front == tail;
}
@Override
public void enqueue(T element) {
if ((tail + 1) % data.length == front) { // 数组已满, 进行扩容.
resize(2 * getCapacity());
}
data[tail] = element;
tail = (tail + 1) % data.length;
size++;
}
@Override
public T dequeue() {
if (isEmpty()) {
throw new IllegalArgumentException("LoopQueue is empty!");
}
T oldElement = data[front];
data[front] = null;
front = (front + 1) % data.length;
size--;
if (size == getCapacity() / 4 && getCapacity() / 2 != 0) { // 数组元素较少, 进行缩容.
resize(getCapacity() / 2);
}
return oldElement;
}
@Override
public T getFront() {
if (isEmpty()) {
throw new IllegalArgumentException("LoopQueue is empty!");
}
return data[front];
}
@Override
public String toString() {
StringBuilder result = new StringBuilder();
result.append(String.format("LoopQueue's size: %d, capacity: %d\n", getSize(), getCapacity()));
result.append("Front[");
for (int i = front; i != tail; i = (i + 1) % data.length) {
result.append(data[i]);
if ((i + 1) % data.length != tail) {
result.append(", ");
}
}
result.append("]Tail");
return result.toString();
}
private void resize(int newCapacity) {
T[] newData = (T[]) new Object[newCapacity + 1];
for (int i = 0; i < size; i++) {
// 因为data是循环数组, 保证data下标不会越界
newData[i] = data[((i + front) % data.length)];
}
data = newData;
front = 0;
tail = size;
}
}