队列特点
- 线性结构
- 队列对应的操作也是数组的子集
- 只能从一端(队尾)添加元素,另一端(队首)取出元素
- 先进先出(FIFO : First In First Out)
实现自己的队列
基于自己实现的动态数组实现队列,源码地址 :https://blog.csdn.net/love905661433/article/details/82909334
同样可以使用JDK自带的ArrayList进行替换
队列接口
package queue;
public interface Queue<E> {
/**
* 入队
* @param e
*/
void enqueue(E e);
/**
* 出队
* @return
*/
E dequeue();
/**
* 获取队首元素
* @return
*/
E getFront();
/**
* 获取队列长度
*/
int getSize();
/**
* 获取队列是否为空
* @return
*/
boolean isEmpty();
}
普通队列实现
package queue;
import array.Array;
public class ArrayQueue<E> implements Queue<E> {
private Array<E> arr;
public ArrayQueue(int capacity) {
arr = new Array<E>(capacity);
}
public ArrayQueue() {
this(10);
}
/**
* 入队
*/
@Override
public void enqueue(E e) {
arr.addlast(e);
}
/**
* 出队
*/
@Override
public E dequeue() {
if (arr.isEmpty()){
throw new RuntimeException("不能对空队列执行出队操作---");
}
return arr.removeFirst();
}
/**
* 获取队首元素
*/
@Override
public E getFront() {
if (arr.isEmpty()){
throw new RuntimeException("不能对获取空队列队首元素---");
}
return arr.getFirst();
}
@Override
public int getSize() {
return arr.getSize();
}
@Override
public boolean isEmpty() {
return arr.isEmpty();
}
@Override
public String toString() {
StringBuilder res = new StringBuilder();
res.append(String.format("ArrayQueue : size = %d, capacity=%d", arr.getSize(), arr.getCapacity()));
res.append(" front [ ");
for (int i = 0; i < arr.getSize(); i++) {
res.append(arr.get(i));
if (i != arr.getSize() - 1) {
res.append(", ");
}
}
res.append(" ] end");
return res.toString();
}
}
循环队列实现
由于队列的特点是先进先出, 使用数组实现队列的话, 每次出队都要将后面的所有元素往前移动一位, 很消耗性能,这个时候就可以使用循环队列的实现
package queue;
/**
* 循环队列
* 以数组表示循环队列
* data : 用于存储队列元素
* front : 用于标识队首元素位于数组arr中的索引位置
* tail : 队尾元素位于arr数组中的索引位置
*
* 设计 : 只有front == tail时标识队列为空, 因此队列中有个元素空间被有意识的浪费了
* tail % getCapacity = front -1 时标识队列已满
* @author qiyexue
*
* @param <E>
*/
public class LoopQueue<E> implements Queue<E> {
private E[] data;
private int front;
private int tail;
private int size;
public LoopQueue() {
this(10);
}
@SuppressWarnings("unchecked")
public LoopQueue(int capacity) {
// 因数组中有个元素被有意识的浪费了,所以new的数组长度为capacity + 1
data = (E[]) new Object[capacity + 1];
front = 0;
tail = 0;
size = 0;
}
@Override
public void enqueue(E e) {
// System.out.println(String.format("front = %d, tail =%d size = %d, capacity=%d", front, tail, size, getCapacity()));
// 判断队列是否已满, 队列已满的情况下进行扩容
if ((tail + 1) % data.length == front) {
resize(getCapacity() * 2);
}
data[tail] = e;
tail = (tail +1) % data.length;
size ++;
}
@Override
public E dequeue() {
if (isEmpty()) {
throw new RuntimeException("不能对空队列执行出队操作---");
}
E ret = data[front];
// 释放对象引用, gc可以回收已出队元素
data[front] = null;
front = (front + 1) % data.length;
size --;
// 如果队列已经小于capacity/4了,就对队列进行缩容, 但不能将队列缩容到0
if (size == getCapacity() / 4 && getCapacity() / 2 != 0 ) {
resize(getCapacity() / 2);
}
return ret;
}
@Override
public E getFront() {
return data[front];
}
@Override
public int getSize() {
return size;
}
@Override
public boolean isEmpty() {
return front == tail;
}
/**
* 获取到当前队列容量, 当tail==front时,队列为空
* @return
*/
public int getCapacity(){
return data.length -1;
}
/**
* 数组扩容或者缩容
*/
@SuppressWarnings("unchecked")
private void resize(int newCapacity){
E[] newArr = (E[]) new Object[newCapacity + 1];
for (int i = 0; i < size; i++) {
newArr[i] = data[(i + front) % data.length];
}
data = newArr;
front = 0;
tail = size;
}
@Override
public String toString(){
StringBuilder res = new StringBuilder();
res.append(String.format("Queue: size = %d , capacity = %d\n", size, getCapacity()));
res.append("front [");
for(int i = front ; i != tail ; i = (i + 1) % data.length){
res.append(data[i]);
if((i + 1) % data.length != tail)
res.append(", ");
}
res.append("] tail");
return res.toString();
}
}