Ir al contenido

Cola (informática)

De Wikipedia, la enciclopedia libre
La versión para imprimir ya no se admite y puede contener errores de representación. Actualiza los marcadores del navegador y utiliza en su lugar la función de impresión predeterminada del navegador.
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 sistemas informáticos, transportes y operaciones de investigación (entre otros), donde 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.

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.

Ejemplo de Cola
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[0];
            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{
            for(Nodo auxiliar = nodoCabeza; auxiliar != null; auxiliar=auxiliar.siguiente){
                System.out.print(auxiliar.informacion+" ");
            }
            System.out.println();
        }
    }
    
    public static void main(String[] ar) {
        Cola cola=new Cola();
        cola.insertar(8);
        cola.insertar(25);
        cola.insertar(2);
        cola.imprimirCola();
        int v = cola.eliminar();
        System.out.println("Elemento eliminado "+v);
        cola.imprimirCola();
}

Colas en C#

public partial class frmPrincipal
    {
        // Variables globales
        public static string[] Cola;
        public static int Frente;
        public static int Final;
        public static int N;
 
        [STAThread]
        public static void Main(string[] args)
        {
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);
            Application.Run(new frmPrincipal());
        }
 
        public frmPrincipal()    // Constructor
        {
 
            InitializeComponent();
 
            Cola = new string[5];   // Arreglo lineal de 5
            N = 4;
            Frente = -1;
            Final = -1;
        }
 
        void CmdInsercionClick(object sender, System.EventArgs e)
        {
            frmInsercion Insercion = new frmInsercion();
            Insercion.Show();
        }
 
        void CmdRecorridoClick(object sender, System.EventArgs e)
        {
            frmRecorrido Recorrido = new frmRecorrido();
            Recorrido.Show();
        }
 
        void CmdBusquedaClick(object sender, EventArgs e)
        {
            frmBusqueda Busqueda = new frmBusqueda();
            Busqueda.Show();
        }
 
        void CmdEliminacionClick(object sender, EventArgs e)
        {
            frmEliminacion Eliminar = new frmEliminacion();
            Eliminar.Show();
        }
    }

Algoritmo Insertar(Cola, N, Frente, Final, Elemento) 

void CmdInsertarClick(object sender, System.EventArgs e)
        {
            elemento = txtInsercion.Text;
            // Se verifica que haya espacio en la Cola
            if (frmPrincipal.Frente == 0 && frmPrincipal.Final == frmPrincipal.N)
            {
                MessageBox.Show("La Cola esta llena");
                return;
            }
            if (frmPrincipal.Frente == frmPrincipal.Final + 1)
            {
                MessageBox.Show("La Cola esta llena"); 
                return;
            }
 
            // Si la cola esta vacia se inicializan punteros
            if (frmPrincipal.Frente == -1)
            {
                frmPrincipal.Frente = 0;
                frmPrincipal.Final = 0;
            }
            else if (frmPrincipal.Final == frmPrincipal.N)
            {
                frmPrincipal.Final = 0;
            }
            else
            {
                frmPrincipal.Final = frmPrincipal.Final + 1;
            }
            // Se agrega elemento a la Cola
            frmPrincipal.Cola[frmPrincipal.Final] = elemento;
            txtInsercion.Text = "";
 
        }

Algoritmo Eliminación (Cola, Frente, Final, N) 

void CmdEliminarClick(object sender, EventArgs e)
        {
            if (frmPrincipal.Frente == -1)
            {
                MessageBox.Show("Cola Vacia");
                return;
            }
            string elemento = frmPrincipal.Cola[frmPrincipal.Frente];
 
            // si la cola tiene un solo elemento
            if (frmPrincipal.Frente == frmPrincipal.Final)
            {
                frmPrincipal.Frente = -1;
                frmPrincipal.Final = -1;
            }
 
            else if (frmPrincipal.Frente == frmPrincipal.N)
            {
                frmPrincipal.Frente = 0;
            }
 
            else
            {
                frmPrincipal.Frente = frmPrincipal.Frente + 1;   
            }
 
            lsEliminado.Items.Add(elemento);
        }

Otra forma de programar una cola en Java Por Jorge Herrera C 

import java.util.*;
public class Cola <Tipo>{ 
    private List<Tipo> cola;
    public Cola(){
        cola=new ArrayList<Tipo>();        
    }
    public boolean colaVacia(){
        return cola.isEmpty();
    }
    public void agregar(Tipo elemento){
       cola.add(elemento);       
    }
    public Tipo sacar(){
        if(colaVacia())return null;
        Tipo elemento=cola.get(0);
        cola.remove(0);         
        return elemento;
    }    
}// Fin de la clase Cola

A continuación un ejemplo de una clase manejadora de la clase Cola 

public class Manejador {
    public static void main(String[] args) {
        Cola cola=new <Integer>Cola(); 
        System.out.println(cola.sacar()); 
        cola.agregar(23);
        cola.agregar(24);
        cola.agregar(25);
        while(!cola.colaVacia()){
           System.out.println(cola.sacar()); 
        }
        Cola nombres=new <String>Cola();
        nombres.agregar("Jorge");
        nombres.agregar("Raquel");
        nombres.agregar("Mayra Alejandra");
        while(!nombres.colaVacia()){
            System.out.println(nombres.sacar());
        }
    }
}// Fin de la clase Manejadora

Tipos de colas

  • Colas de prioridad: En ellas, los elementos se atienden en el orden indicado por una prioridad asociada a cada uno. Si varios elementos tienen la misma prioridad, se atenderán de modo convencional según la posición que ocupen. Hay dos formas de implementación:
    1. Añadir un campo a cada nodo con su prioridad. Resulta conveniente mantener la cola ordenada por orden de prioridad.
    2. Crear tantas colas como prioridades haya, y almacenar cada elemento en su cola.
  • Bicolas (o Colas doblemente terminadas): son colas en donde los nodos se pueden añadir y quitar por ambos extremos; se les llama DEQUE (Double Ended QUEue). Para representar las bicolas lo podemos hacer con un array circular con Inicio y Fin que apunten a cada uno de los extremos. Hay variantes:
  • Bicolas de entrada restringida: Son aquellas donde la inserción solo se hace por el final, aunque podemos eliminar al inicio o al final.
  • Bicolas de salida restringida: Son aquellas donde solo se elimina por el final, aunque se puede insertar al inicio y al final.

Véase también

Obtenido de «https://es.wikipedia.org/w/index.php?title=Cola_(informática)&oldid=146758324»