Colas Y Filas En JAVA

¿Qué es una cola?

Una cola es una estructura de datos, caracterizada por ser una secuencia de elementos en la que la operación de inserción push se realiza por un extremo y la operación de extracción pop por el otro. También se le llama estructura FIFO (del inglés First In First Out), debido a que el primer elemento en entrar será también el primero en salir.

Las colas se utilizan en sistemas informáticos, transportes y operaciones de investigación (entre otros), dónde los objetos, personas o eventos son tomados como datos que se almacenan y se guardan mediante colas para su posterior procesamiento. Este tipo de estructura de datos abstracta se implementa en lenguajes orientados a objetos mediante clases, en forma de listas enlazadas.

¿Cómo se implementa?

Colas en Maude

La ColaNV es la cola no vacía, que diferenciamos de la cola normal a la hora de tomar en cuenta errores. A su vez, el elemento X representa el tipo de valor que puede contener la cola: entero, carácter, registro, entre otros.

fmod COLA {X :: TRIV} is

sorts ColaNV{X} Cola{X} .

subsort ColaNV{X} < Cola{X} .

*** generadores

op crear : -> Cola{X} [ctor] .

op encolar : X$Elt Cola{X} -> ColaNV {X} [ctor] .

*** constructores

op desencolar : Cola{X} -> Cola{X} .

*** selectores

op frente : ColaNV{X} -> X$Elt .

*** variables

var C : ColaNV{X} .

vars E E2 : X$Elt .

*** ecuaciones

eq desencolar(crear) = crear .

eq desencolar(encolar(E, crear)) = crear .

eq desencolar(encolar(E, C)) = encolar(E, desencolar(C)) .

eq frente(encolar(E, crear)) = E .

eq frente(encolar(E, C)) = frente(C) .

endfm

Especificación de una cola de colas de enteros en Maude:

view VInt from TRIV to INT is

sort Elt to Int .

endv

view VColaInt from TRIV to COLA{VInt} is

sort Elt to Cola{VInt} .

endv

fmod COLA-COLAS-INT is

protecting INT .

protecting COLA{VColaInt} .

*** operaciones propias de la cola de colas de enteros

op encolarInt : Int ColaNV{VColaInt} -> ColaNV{VColaInt} .

op desencolarInt : Cola{VColaInt} -> Cola{VColaInt} .

op frenteInt : ColaNV{VColaInt} -> [Int] .

*** variables

var CCNV : ColaNV{VColaInt} .

var CC : Cola{VColaInt} .

var CE : Cola{VInt} .

var E : Int .

*** ecuaciones

eq encolarInt(E, encolar(CE, CC)) = encolar(encolar(E, CE), CC) .

eq desencolarInt (encolar(CE, crear)) = encolar(desencolar(CE), crear) .

eq desencolarInt (encolar(CE, CCNV)) = encolar(CE, desencolarInt(CCNV)) .

eq frenteInt(CCNV) = frente(frente(CCNV)) .

endfm

Colas en C++

#ifndef COLA

#define COLA // Define la cola

template <class T>

class Cola{

private:

struct Nodo{

T elemento;

struct Nodo* siguiente; // coloca el nodo en la segunda posición

}* primero;

struct Nodo* ultimo;

unsigned int elementos;

public:

Cola(){

elementos = 0;

}

~Cola(){

while (elementos != 0) pop();

}

void push(const T& elem){

Nodo* aux = new Nodo;

aux->elemento = elem;

if (elementos == 0) primero = aux;

else ultimo->siguiente = aux;

ultimo = aux;

++elementos;

}

void pop(){

Nodo* aux = primero;

primero = primero->siguiente;

delete aux;

--elementos;

}

T consultar() const{

return primero->elemento;

}

bool vacia() const{

return elementos == 0;

}

unsigned int size() const{

return elementos;

}

};

#endif

Colas en JAVA

public void inserta(Elemento x) {

Nodo Nuevo;

Nuevo = new Nodo(x, null);

if (NodoCabeza == null) {

NodoCabeza = Nuevo;

} else {

NodoFinal.Siguiente = Nuevo;

}

...