c


Las colas son estructuras de datos restrictivos que almacena elementos en una
lista y permite acceder a los datos por uno de los dos extremos de la lista. Un
elemento se inserta en la cola (parte final) de la lista y se suprime o elimina por la
frente (parte inicial, cabeza) de la lista. Las aplicaciones utilizan una cola para
almacenar elementos en su orden de aparición o concurrencia

Los elementos se eliminan (se quitan) de la cola en el mismo orden en que se

almacenan y, por consiguiente, una cola es una estructura de tipo FIFO —






 




 
 

o bien 
 

 
 


 
 

El servicio de atención a clientes en un almacén es un ejemplo típico
de cola. La acción de gestión de memoria intermedia — 

de trabajos o
tareas de impresora en un distribuidor de impresoras — 
es otro ejemplo
típico de cola'. Dado que la impresión es una tarea (un trabajo) que requiere más
tiempo que el proceso de la transmisión real de los datos desde la computadora a
la impresora, se organiza una cola de trabajos de modo que los trabajos se
imprimen en el mismo orden en que se recibieron por la impresora. Este sistema
tiene el gran inconveniente de que si su trabajo personal consta de una Única
página para imprimir y delante de su petición de impresión existe otra petición para
imprimir un informe de 300 páginas. deberá esperar a la impresión de esas 300
páginas antes de que se imprima su página.
Desde el punto de vista de estructura de datos, una cola es similar a una pila, en
donde los datos se almacenan de un modo lineal y el acceso a los datos sólo está
permitido en los extremos de la cola. Las acciones que están permitidas en una
cola son:


Creación de una cola vacía.

Verificación de que una cola esta vacía.

Añadir un dato al final de una cola.

Eliminación de los datos de la cabeza de la cola.
En esta segunda figura se observa que se han introducido tres elementos: 3, 1 y 4
(en ese orden):

se desencola, obteniendo un 3:

se encola un 7:

Al igual que las pilas, las colas se pueden implementar utilizando arrays o listas
enlazadas. En esta sección se considera la iinplementación utilizando arrays. La
definición de una cold ha de contener un array para almacenar los elementos de la
cola, y dos marcadores o punteros (variables) que mantienen las posiciones frente
y final de la cola ; es decir, un marcador apuntando a la posición de la cabeza de
la cola y el otro al primer espacio vacío que sigue al final de la cola. Cuando un
elemento se añade a la cola, se verifica si el inarcador final apunta a una posición
válida, entonces se añade el elemento a la cola y se incrementa el marcador final
en 1. Cuando un elemento se elimina de la cola, se hace una prueba para ver si la
cola está vacía y, si no es así, se recupera el elemento de la posición apuntada
por el marcador (puntero) de cabeza y éste se incrementa en 1. Este
procedimiento funciona bien hasta la primera vez que el puntero de cabeza o
cabecera alcanza el extremo del array y el array queda o bien vacío o bien lleno.

Definición de la especificación de una cola

Una cola debe manejar diferentes tipos de datos; por esta circunstancia, se define
en primer lugar el
tipo genérico TipoDato. La clase Cola contiene una lista (listaQ) cuyo máximo
tamaño se determina por la constante MaxTamQ. Se definen dos tipos de
variables puntero o marcadores, frente y f i.nal. Éstas son los punteros de
cabecera y cola o final respectivamente.
Las operaciones típicas de la cola son: InsertarQ, EliminarQ, Qvacia, Qllena, y
FrenteQ. InsertarQ toma un elernento del tipo TipoDato y 1o inserta en el final de
la cola. EliminarQ elimina (quita) y devuelve el elemento de la cabeza o frente de
la cola. La operación FrenteQ devuelve el valor del elemento en el frente de la
cola, sin eliminar el elemento y, por tanto, no modifica la cola. La operación Qvacia
comprueba si la cola está vacía, es necesario esta comprobación antes de
eliminar un elemento. Qllena comprueba si la pila esta llena, esta comprobación se
realiza antes de insertar un nuevo miembro. Si las precondiciones para InsertarQ y
EliminarQ se violan, el programa debe imprimir un mensaje de error y terminar.


 cc

  

La implementación de colas en P.O.O. es de la siguiente manera, de forma muy

general y básica en una biblioteca creada por usuario.

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 Insertar (Cola elem){

Nodo* aux = new Nodo;

aux->elemento = elem;
if (elementos == 0) primero = aux;
else ultimo->siguiente = aux;
ultimo = aux;
++elementos;
}

void EliminarElem(){
Nodo* aux = primero;
primero = primero->siguiente;
delete aux;
--elementos;
}
Cola consultar( {return primero->elemento;}

bool vacia() Cola {return elementos == 0;}

int size(){return elementos;}

};

#endif