Este artículo proviene de liuyubobobo de "Diversión de la entrada a las estructuras de datos avanzadas" tutoriales de vídeo
Una cola es una forma lineal especial, es especial en que sólo permite su eliminación en el extremo frontal de la mesa, mientras que el extremo posterior de la mesa de operaciones de inserción. Conocido como el extremo de cola del extremo, operación de eliminación se conoce como operación de cabeza de inserción.
Supongamos que usamos una cola de matriz, véase más adelante
la operación de puesta en cola muy rápidamente, sólo es necesario añadir elementos en la cola. Sin embargo, un equipo operativo en un consumen mucho tiempo, los elementos de la cabeza después de la eliminación y volver a la persona que llama, la necesidad de poner todos los elementos de la matriz para seguir adelante, este paso es muy lento.
Después de quitar de la cola a, b, c, d se mueva a la posición inferior marcada 0,1,2
Cuando hay una manera de hacer un equipo, los elementos de la matriz que no se mueven? Hay gotas, utilizando un bucle arrays
cola circular tiene varias características:
1, puntos variables frente HOL (todos los elementos), puntos variables cola a la cola (Elemental).
2, cuando el equipo se mueve hacia atrás delante un subíndice ( "back" esta afirmación no es totalmente correcta, entonces seguido por se da una definición precisa; hablar expansión posterior)
un subíndice hacia atrás 3, mientras que fue el elemento añadido en la cola, la cola se mueve
4, frente == cola indica que la cola está vacía, la cola está llena, no la parte delantera, la cola se refiere a los mismos elementos, pero delante de una posición frontal de la cola.
La figura es un caso en el que la cola está llena, la longitud de la matriz 8, pero sólo almacenar cola elemento 7, de modo que un elemento a vacío, la cola elemento apuntando.
Es a bajar, si debe quedarse sin matrices de memoria y luego del frente de la cola ==; cola está vacía, y también frente == cola, en la implementación del código de distinguir entre cuando la cola está vacía, la cola está llena cuando está complicado. Simplemente "perder" una cola de la cola elemento de memoria, frente == está vacía, esto es sólo un caso.
5, data.length longitud de la matriz definición (longitud de la matriz de la Fig. 8), la cola está llena cuando la condición de juicio es (+ cola. 1) == Frente data.length% , entendemos la determinación brillante figura condición buena.
6, el equipo, es la cola de forma móvil de la cola = (cola + 1)% data.length
Quitar de la cola, se mueve delanteras es = frontales (frontal + 1)% data.length
La figura ejemplo gasto
operación Enqueue, cola = (1 + 1)% 8 = 2, cola en 2
operación de quitar de la cola, = frontales (3 + 1)% 8 = 4, frontal se convierte en 4
7 cuando la posición delantera, quitar de la cola, fornt = (7 + 1)% 8 = 0, en este punto de tiempo a la posición delantera subíndice 0
7, la expansión, después de la fig. Satisface la condición (cola + 1)% data.length == frontal, se necesita la capacidad en este momento
Los códigos son como sigue
// 基于循环数组实现队列
public class LoopQueue<E>{
private E[] data; // 数组
private int front, tail; //队头、队尾
private int size; //队列元素大小
public LoopQueue(){
data = (E[]) new Object[11]; //初始化队列的数组
// 初始化时队头、队尾下标都为0，队列大小也是0
front = 0;
tail = 0;
size = 0;
}
// 队列容量是数组长度减1，因为要空一个元素，以便区别队列是否为空、队列是否满了需要扩容
public int getCapacity(){
return data.length -1;
}
//队列为空
public boolean isEmpty(){
return front == tail;
}
//队列大小
public int getSize(){
return size;
}
//扩容、缩容
private void resize(int newCapacity){
// 数组长度要比容量多一个
E[] newData = (E[])new Object[newCapacity+1];
//将旧数据从队头开始，添加到新数组中
for (int i=0; i<size; i++){
newData[i] = data[(i+front) % data.length];
}
front = 0; //添加完成，队头在新数组下标为0的位置
tail = size; //添加完成，队列大小就是队尾的下标
data = newData; //队列的数组data指向扩容后的数组
}
//入队
public void enqueue(E e){
//如果队列满了，则扩容
if ((tail + 1) % data.length == front){
resize(getCapacity() * 2);
}
data[tail] = e;
//队尾下标移动
tail = (tail + 1) % data.length;
//队列大小加一
size++;
}
//出队
public E dequeue(){
if (isEmpty())
throw new RuntimeException("没数据了");
//队头数据存储到变量中
E ret = data[front];
data[front] = null;
//队头下标移动
front = (front + 1) % data.length;
//队列大小减一
size--;
//这是缩容，如果队列大小小于容量的1/4且容量的1/2不为0，队列缩容为原来的1/2
if (size < getCapacity()/4 && getCapacity()/2 != 0){
resize(getCapacity()/2);
}
//返回队头数据
return ret;
}
@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();
}
public static void main(String[] args){
_2_LoopQueue.LoopQueue<Integer> queue = new _2_LoopQueue.LoopQueue<>();
for(int i = 0 ; i < 20 ; i ++){
queue.enqueue(i);
System.out.println(queue);
if(i % 10 == 0){
queue.dequeue();
System.out.println(queue);
}
}
for(int i = 0 ; i < 18 ; i ++){
queue.dequeue();
System.out.println(queue);
}
}
}
