队列Queue
队列(queue)是只允许在一端进行插入操作,而在另一端进行删除操作的线性表。
队列是一种先进先出(First in First Out)的线性表,简称FIFO。允许插入的一端称为队尾,允许删除的一端称为队头。
实现一个队列
创建队列接口,主要方法如下。
public interface Queue<E> {
int getSize();
boolean isEmpty();
void enqueue(E e);
E dequeue();
E getFront();
}
利用之前的动态数组实现一个队列结构。
package com.baidu.demo;
public class ArrayQueue<E> implements Queue<E> {
private Array<E> array;
public ArrayQueue(int capacity){
array = new Array<>(capacity);
}
public ArrayQueue(){
array = new Array<>();
}
@Override
public int getSize(){
return array.getSize();
}
@Override
public boolean isEmpty(){
return array.isEmpty();
}
public int getCapacity(){
return array.getCapacity();
}
@Override
public void enqueue(E e){
array.addLast(e);
}
@Override
public E dequeue(){
return array.removeFirst();
}
@Override
public E getFront(){
return array.getFirst();
}
@Override
public String toString(){
StringBuilder res = new StringBuilder();
res.append("Queue: ");
res.append("front [");
for(int i = 0 ; i < array.getSize() ; i ++){
res.append(array.get(i));
if(i != array.getSize() - 1)
res.append(", ");
}
res.append("] tail");
return res.toString();
}
public static void main(String[] args) {
ArrayQueue<Integer> queue = new ArrayQueue<>();
for(int i = 0 ; i < 10 ; i ++){
queue.enqueue(i);
System.out.println(queue);
if(i % 3 == 2){
queue.dequeue();
System.out.println(queue);
}
}
}
}
在之前的动态数组中,每当出队一个元素时,都要进行元素的移位,导致时间复杂度为O(n)级别。而事实上,出队操作后的其他元素的相对位置是不变的,不挪动元素位置其实也是可以的,我们只需要记录下队尾、队首元素即可,每次出队、入队操作这两个变量都进行维护即可,这样就出现了循环对列。
循环队列
初识状态:
a元素出队:
h、i入队:
/**
* front=tail 时队列为空
* tail+1 = front => (tail+1)%data.length = front 时队满
*/
public class LoopQueue<E> implements Queue<E> {
private E[] data;
private int tail, front;//队首、队尾索引
private int size;// 元素个数
public LoopQueue(int capacity) {
data = (E[]) new Object[capacity + 1];//(tail+1)%data.length = front 时队满,所以有意的浪费一个空间
size = 0;
tail = 0;
front = 0;
}
public LoopQueue() {
this(10);
}
public int getCapacity() {
return data.length - 1;
}
@Override
public int getSize() {
return size;
}
/**
* 判断是否为空
*
* @return
*/
@Override
public boolean isEmpty() {
return front == tail;
}
/**
* 出队
*
* @return
*/
@Override
public E dequeue() {
if (isEmpty()) {
throw new IllegalArgumentException("队列为空");
}
E res = data[front];
data[front] = null;
front = (front + 1) % data.length;
size--;
//队列中的元素个数不到容量的四分之一就缩容,而且要保证缩容量getCapacity() / 2 不能为0
if (size == getCapacity() / 4 && getCapacity() / 2 != 0) {
resize(getCapacity() / 2);
}
return res;
}
/**
* 入队
*
* @param e
*/
@Override
public void enqueue(E e) {
if ((tail + 1) % data.length == front) {//队列满,扩容
resize(getCapacity() * 2);
}
data[tail] = e;
tail = (tail + 1) % data.length;
size++;
}
/**
* 扩容方法
*
* @param newCapacity
*/
private void resize(int newCapacity) {
E[] newData = (E[]) new Object[newCapacity + 1];
for (int i = 0; i < size; i++) {
//newData的i和data的i有front的偏移
//即:newData[0]对应data[front],newData[1]对应data[front+1],……
newData[i] = data[(front + i) % data.length];
}
data = newData;
front = 0;
tail = size;
}
/**
* 返回队首元素
*
* @return
*/
@Override
public E getFront() {
if (isEmpty()) {
throw new IllegalArgumentException("队列为空");
}
return data[front];
}
@Override
public String toString() {
StringBuilder result = new StringBuilder();
result.append(String.format("Queue: size = %d , capacity = %d \n", size, data.length));
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();
}
public static void main(String[] args) {
LoopQueue<Integer> queue = new LoopQueue<>();
for (int i = 0; i < 10; i++) {
queue.enqueue(i);
System.out.println(queue);
if (i % 3 == 2) {
queue.dequeue();
System.out.println(queue);
}
}
}
}
时间复杂度