Colas en Java

Una cola es una estructura de datos 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 el frente (parte inicial, frente) de la lista. Las aplicaciones utilizan una cola para almacenar elementos en su orden de aparición o concurrencia.

Una cola es una estructura de datos en donde las eliminaciones se realizan por uno de sus extremos, denominado frente, y las instrucciones por el otro, denominado final. Se las conoce como estructuras FIFO (First INPUT FIRST OUTPUT).

Una cola se deberá implementar de forma dinámica mediante una array y dos variables numéricas (frente, final).

Una cola se puede componer a partir de una lista enlazada, pero las operaciones son distintas

OPERACIONES

Encolar.- introducir algo en la cola, los elementos se introducen en la cola por el final

Consultar.- Obtener el siguiente elemento de la cola, como es una cola, el siguiente elemento estará al principio de la cola, podemos obtener la cabeza de la cola accediendo al primer elemento de la cola.
Eliminar.- eliminar el siguiente elemento de la cola


En Java podemos crear Colas en pocas lineas de código,usando la clase de java.util.Queue con la cual podemos crear Colas y que contiene los siguientes métodos

Ejemplo práctico:

A continuación se muestra un programa simple, en donde se aplican las operaciones encolar y desencolar elementos en una Cola. El programa está hecho con listas simples enlazadas en el cual se insertan 5 elementos, utilizando la función insertar (encolar). Después se utiliza la función extraer (encolar) para eliminar el primer nodo. Finalmente se cuenta cuantos elementos tiene la nueva lista, e imprime los valores.

Clase Nodo

public class Nodo 
{
 //Declaracion de atributos
 private int dato;
 private Nodo next;
  
 //Constructor
 public Nodo(int dato){
 this.dato=dato;
 }
  
 //Metodos getter and setters
 public int getDato() 
 {
 return dato;
 }
 public void setDato(int dato) 
 {
 this.dato = dato;
 }
 public Nodo getNext() 
 {
 return next;
 }
 public void setNext(Nodo next) 
 {
 this.next = next;
 }
  
 //Metodo toString
 public String toString()
 {
 String s=" "+dato+" ";
 return s;
 }
}

Clase colas

public class Colas 
{
 //Declaración de atributos
 private Nodo inicio;
 private Nodo termino;
 
 //Constructor sin parametros
 public Colas()
 {
 inicio=null;
 termino=null;
 }
  
 //Metodo insertar
 public void insertar(int dato)
 {
 Nodo i=new Nodo(dato);
 i.setNext(null);
 if(inicio==null & termino==null)
 {
 inicio=i;
 termino=i;
 }
 termino.setNext(i);
 termino=termino.getNext();
 }
  
 //Metodo extraer dato
 public int extraer()
 {
 int dato=inicio.getDato();
 inicio=inicio.getNext();
 return dato;
 }
  
 //Metodo para comprobar que la cola no esta vacia
 public boolean estaVacia()
 {
 boolean cola=false;
 if(inicio==null & termino==null)
 {
 cola=true;
 System.out.println("La cola esta vacia");
 }
 else
 {
 System.out.println("La cola no esta vacia");
 cola=false;
 }
 return cola;
 }
  
 //Metodo para contar los elementos de la cola
 public int contar()
 {
 int contador=0;
 Nodo c=this.inicio;
 while(c!=null)
 {
 contador++;
 c=c.getNext();
 }
 System.out.println("Numero de datos en la cola: "+contador);
 return contador;
 }
  
 //Metodo toString
 public String toString()
 {
 Nodo c=this.inicio;
 String s="";
 while(c!=null)
 {
 s=s+c.toString();
 c=c.getNext();
 }
 return s;
 } 
}

Clase Principal

public class Principal 
{
 public static void main(String[] args) 
 {
  Colas cola1=new Colas();
  cola1.insertar(46);
  cola1.insertar(12);
  cola1.insertar(87);
  cola1.insertar(125);
  cola1.insertar(30);
  cola1.extraer();
  cola1.estaVacia();
  cola1.contar();
  System.out.println(cola1.toString());
 }
}

Para Insertar:
– add(e)
– offer(e)

Para Extraer:
– remove()
– poll()

Para Consultar el Frente:
– element()
– peek()

Ejemplo de Cola

            import java.util.LinkedList;
import java.util.Queue;

public class Principal {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        
        /*Creamos la Cola Indicando el tipo de dato*/
        Queue cola=new LinkedList();
        /*Insertamos datos*/
            cola.offer(3);
            cola.add(14);
            cola.offer(12);
            cola.add(7);
            cola.offer(10);
        /*Impresion de la Cola llena con los datos*/
        System.out.println("Cola llena: " + cola);
        /*Estructura repetitiva para desencolar*/
        while(cola.poll()!=null){//Desencolamos y el valor se compara con null
            System.out.println(cola.peek());//Muestra el nuevo Frente
        }
        /*Muestra null debido a que la cola ya esta vacia*/
        System.out.println(cola.peek());     
    }
    
}


       

Ejemplo cola con Prioridades

En java podemos importar la clase java.util.PriorityQueue . A cada elemento ingresado se le da un nivel de prioridad con base en un árbol binario 

            import java.util.PriorityQueue;

/**
 *
 * @author Administrador
 */
public class Principal {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        PriorityQueue pq=new PriorityQueue();
        
        System.out.println(pq.isEmpty());
        pq.isEmpty();
        
        pq.add(3);
        pq.add(14);
        pq.add(12);
        pq.add(7);
        pq.add(10);
        pq.add(1);
        pq.add(6);
        pq.add(-8);
        pq.add(9);
        pq.add(5);
        
        System.out.println(pq);
        System.out.println(pq.isEmpty());
        System.out.println(pq.peek());
        System.out.println(pq);
        /*pq.poll();
        pq.element();
        pq.remove();*/
        
    }
    
}


       

Resumen
Una cola es una estructura de datos del tipo FIFO, con dos operaciones imprescindibles: encolar y desencolar, al primer elemento se lo conoce como "frente o principio" y al último como "final".


En Java podemos crear Colas en pocas lineas de código,usando la clase de java.util.Queue con la cual podemos crear Colas y que contiene los siguientes métodos

Referencias:

• Alvarez,D.(2011).Pilas en Java.Recuperado el 28 de noviembre de 2016 de http://soloinformaticayalgomas.blogspot.com/2011/02/pilas-en-java.html
• Sierra,M(s,n).La estructura de datos pila en java.Clase Stac del API Java.Ejemplo Simple y ejercicios resueltos.Recuperado el 28 de noviembre de 2016 de http://aprenderaprogramar.com/index.php?option=com_content&view=article&id=608:la-estructura-de-datos-pila-en-java-clase-stack-del-api-java-ejemplo-simple-y-ejercicios-resueltos-cu00920c&catid=58:curso-lenguaje-programacion-java-nivel-avanzado-i&Itemid=180
• Alvarez,D.(2011).Colas en Java.Recuperado el 28 de noviembre de 2016 de http://soloinformaticayalgomas.blogspot.com/2011/03/colas-en-java.html