miniaturadeimagen|200px|derecha|Representación simplificada de una cola
Una cola (también llamada fila) es un tipo de dato abstracto, 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 pull 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 diversos ámbitos, como los sistemas informáticos, la gestión del transporte y la investigación de operaciones, para modelar y gestionar secuencias de objetos, personas o eventos que deben ser procesados de manera ordenada.
En ciencias de la computación, una ‘’cola’’ es una estructura de datos abstracta que sigue el principio ‘’FIFO’’ (’‘First In, First Out’’), en el cual el primer elemento en entrar es el primero en salir. Este tipo de estructura se emplea habitualmente para el manejo de tareas, la planificación de procesos o la comunicación entre programas.
En los lenguajes de programación orientados a objetos, las colas suelen implementarse mediante clases que utilizan listas enlazadas u otras estructuras dinámicas como base.
Usos concretos de la cola
La particularidad de una cola es el hecho de que solo podemos acceder al primer y al último elemento de la estructura. Así mismo, los elementos solo se pueden eliminar por el principio y solo se pueden añadir por el final de la cola.derecha|borde|400px|Ejemplo de Cola Ejemplos de colas en la vida real serían: personas comprando en un supermercado, esperando para entrar a ver un partido de béisbol, esperando en el cine para ver una película, una pequeña peluquería, etc. La idea esencial es que son todos líneas de espera.
Información adicional En caso de estar vacía, borrar un elemento sería imposible hasta que no se añade un nuevo elemento. A la hora de añadir un elemento podríamos darle una mayor importancia a unos elementos que a otros (un cargo VIP) y para ello se crea un tipo de cola especial que es la cola de prioridad. (Ver cola de prioridad).
Operaciones Básicas Crear: se crea la cola vacía. Encolar: se añade un elemento a la cola. Se añade al final de esta. Desencolar: (sacar, salir, eliminar): se elimina el elemento frontal de la cola, es decir, el primer elemento que entró. Frente: (consultar, front): se devuelve el elemento frontal de la cola, es decir, el primer elemento que entró.
Implementaciones
Las colas pueden implementarse utilizando Listas Enlazadas o utilizando una variación del arreglo conocido comúnmente como una cola circular. La ventaja de la cola circular es que se puede utilizar memoria contigua en RAM que permite mejor desempeño del caché que en una lista enlazada además de un menor uso de RAM. Estas pueden crecer dinámicamente o no.
Colas en C #include<stdio.h> #include<stdlib.h>
#define RED "\x1B[31m" #define GRN "\x1B[32m´´ #define YEL "\x1B[33m" #define BLU "\x1B[34m" #define MAG "\x1B[35m" #define CYN "\x1B[36m" #define WHT "\x1B[37m" #define RESET "\x1B[0m"
typedef struct Node{ struct Node *next; struct Node *previous; char *data; }node_t;
typedef struct Queue{ node_t *top; node_t *bottom; int size; }queue_t;
node_t *createNode(char*); char* removeNode(node_t*);
queue_t *createQueue(); int removeQueue(queue_t *);
char *peek(queue_t *); int isEmpty(queue_t *);
/* Si manejaramos una Queue estática... int isFull(queue_t *); */
int enqueue(char *, queue_t *); char *dequeue(queue_t *);
int printQueue(queue_t *); int printNode(node_t *);
int getQueueSize(queue_t *);
node_t *createNode(char *data){ node_t *node = (node_t *)calloc(1, sizeof(node_t)); node->data = data;
return node; }
char* removeNode(node_t *node){ char* data = NULL; if (node) { if (node->previous) node->previous->next = node->next; if (node->next) node->next->previous = node->previous; data = node->data; free(node);
return data; }
queue_t *createQueue(){ queue_t *queue = (queue_t *)calloc(1, sizeof(queue_t));
return queue; }
int removeQueue(queue_t *queue){ if (queue) { node_t *ptr = queue->top; node_t *aux;
while(ptr != NULL){ aux = ptr; ptr = ptr->next; free(removeNode(aux));
free(queue);
return (queue == NULL); }
char *peek(queue_t *queue){ if (queue && queue->top != NULL){ return queue->top->data;
return NULL; }
int isEmpty(queue_t *queue){ return (queue->top == NULL); }
int enqueue(char *data, queue_t *queue){ if(queue != NULL){ node_t *new = createNode(data);
if(queue->bottom == NULL){ queue->bottom = new; queue->top = new; //queue->top->previous = queue->bottom; //No need to set previous for bottom since calloc makes it null.
}else{ queue->bottom->next = new; new->previous = queue->bottom; new->next = NULL; queue->bottom = new;
queue->size++; return EXIT_SUCCESS; } return EXIT_FAILURE; }
char *dequeue(queue_t *queue){ if(queue != NULL && queue->top != NULL){ char *data; node_t *aux = queue->top; queue->top = aux->next; queue->top->previous = NULL; data = removeNode(aux);
queue->size--; return data; } return NULL; }
int printQueue(queue_t *queue){ node_t *ptr = queue->top; int i, size = getQueueSize(queue); for(i = 0; i<size; i++){ #ifdef __unix__ printf(GRN"[%i]Address: %p, Data: %s, Next: %p, Previous: %p\n"RESET, i, ptr, ptr->data, ptr->next, ptr->previous); #elif __WIN32 printf("[%i]Address: %p, Data: %s, Next: %p, Previous: %p\n", i, ptr, ptr->data, ptr->next, ptr->previous); #endif ptr = ptr->next;
printf("\n");
return EXIT_SUCCESS; }
int printNode(node_t *ptr){ char *i = "printNode function"; #ifdef __unix__ printf(GRN"[%s]Address: %p, Data: %s, Next: %p, Previous: %p\n"RESET, i, ptr, ptr->data, ptr->next, ptr->previous); #elif __WIN32 printf("[%s]Address: %p, Data: %s, Next: %p, Previous: %p\n", i, ptr, ptr->data, ptr->next, ptr->previous); #endif
printf("\n");
return EXIT_SUCCESS; }
int getQueueSize(queue_t *queue){ return queue->size; }
Colas en Pascal Clase PscColas, Matriz[]:Cadena, Posición, Valor:Entero Privado: Proc Comenzar ReDim Matriz,1 Posición = 0 Valor = 0 FinProc Proc Terminar Borrar Matriz FinProc Proc Longitud:Entero Devolver Límite(Matriz) FinProc Proc ReDimensionarLaCola ReDim Preservar Matriz, LongMat(Matriz) + 1 FinProc Público: Proc Encolar(Contenido:Cadena) Si Posición = LongMat(Matriz) Entonces ReDimensionarLaCola Matriz[Posición] = Contenido Posición = Posición + 1 FinProc Proc DesEncolar Si Neg(Valor >= Límite(Matriz)) Entonces Valor = Valor + 1 FinProc Proc FrenteCola:Cadena Devolver Matriz[Valor] FinProc Proc FondoCola:Cadena Devolver Matriz[Límite(Matriz)] FinProc Prop ColaLongitud:Entero Lec:Longitud FinProp Privado: Constructor: Comenzar Destructor: Terminar FinClase
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.... 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 using namespace std;
template <class T> class Cola{ struct Nodo{ T elemento; struct Nodo* siguiente; // coloca el nodo en la segunda posición
Nodo* primero; Nodo* ultimo; unsigned int elementos;
public: Cola(): primero(0), ultimo(0), 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; if (ultimo == aux){ ultimo = primero;
delete aux; --elementos;
T consultar() const{ return primero->elemento;
bool vacio() const{ return elementos == 0;
Colas en JAVA Al igual que las pilas, este tipo de estructura de datos se puede implementar de forma estática o dinámica, es decir, ya sea con un arreglo o con una lista enlazada. Al hablar de una cola estática, se considera que tendrá un tamaño definido y no podrá superar dicha capacidad para el almacenamiento de más información, solo la indicada. Y con respecto a una cola dinámica corresponde a aquella que no tendrá un límite de capacidad, es decir, podemos hacer n número de inserciones.
A continuación se presenta la Cola estática, la cual es implementada basándose en un arreglo:public class ColaEstatica{ private int cola[]; private int top;//indica la posición del último elemento insertado private int capacidad;
public ColaEstatica(int cap){ capacidad=cap; cola=new int[capacidad]; top=-1;
public boolean estaVacia(){ return(top==-1);
public boolean estaLlena(){ return((top+1)==capacidad);
public void encolar(int elemento){ if(estaLlena()==false) cola[++top]=elemento; else System.out.println("Desbordamiento superior, no se puede encolar");
public int desencolar(){ if(estaVacia()==false){ int dato=cola; top--; for(int i=0;i<=top;i++){ cola[i]=cola[i+1];
return dato;
else{ System.out.println("Desbordamiento inferior, no se puede desencolar");
return -1;
public static void main (String args[]){ ColaEstatica colita=new ColaEstatica(5); colita.encolar(1); colita.encolar(12); colita.encolar(3); int r=colita.desencolar(); System.out.println("El dato eliminado es "+r); boolean b=colita.estaVacia(); boolean c=colita.estaLlena(); System.out.println("¿Está vacia la pla? "+b); System.out.println("¿Está llena la pla? "+c);
}Enseguida se presenta la implementación de la Cola de forma dinámica, implementada con base en una lista simplemente enlazada:class Nodo{ int informacion; Nodo siguiente;
public Nodo(itn info){ informacion=info; siguiente=null;
class Cola{ Nodo nodoCabeza, nodoFinal;
public Cola() { // Inicializa la Cola, en este caso su primer estado es vacía nodoCabeza = null; nodoFinal = null;
public void insertar(int x) { Nodo nuevo = new Nodo(x); if (nodoCabeza == null && nodoFinal == null) { NodoCabeza = nuevo; } else { nodoFinal.siguiente = nuevo;
nodoFinal = Nuevo;
public int eliminar(){ if (nodoCabeza == null && nodoFinal == null) { System.out.println("Cola vacía, no se puede eliminar"); } else { Nodo nodoEliminado = nodoCabeza; nodoCabeza = nodoCabeza.siguiente; nodoEliminado.siguiente = null; return nodoEliminado.informacion;
public void imprimirCola(){ if nodoCabeza == null && nodoFinal == null) { System.out.println("Cola vacía");
else{