Cola Dinámica en Java

Hola a todos, hoy os dejo la implementación de la cola dinámica en Java.

Una cola es una estructura dinámica que agrupa elementos como si fuera una cola, por ejemplo una fila de personas. Haciendo que cada vez que se mete un elemento este se añada a la última posición.

Utiliza FIFO (First Input First Output) que significa que el primero que entra es el primero que saldrá. Imagina la fila de personas en un cine por ejemplo.

Esta cola se ha realizado en vídeo en nuestro canal de Youtube.

Aquí os dejo el código:

Nodo

/**
 * Clase Nodo
 * @author DiscoDurodeRoer
 * @param <T> 
 */
public class Nodo<T> {
    
    //Atributos
    private T elemento;
    private Nodo<T> siguiente; //Apunta al siguiente nodo
    
    //Contructor
    public Nodo(T elemento, Nodo<T> siguiente){
        this.elemento = elemento;
        this.siguiente = siguiente;
    }

    //Metodos
    public T getElemento() {
        return elemento;
    }

    public void setElemento(T elemento) {
        this.elemento = elemento;
    }

    public Nodo<T> getSiguiente() {
        return siguiente;
    }

    public void setSiguiente(Nodo<T> siguiente) {
        this.siguiente = siguiente;
    }

    @Override
    public String toString() {
        return elemento+"\n";
    }
    
    
    
}


Cola dinamica

/**
 * Cola Dinamica
 * @author DiscoDurodeRoer
 * @param <T> 
 */
public class ColaDinamica<T> {

    //Atributos
    private Nodo<T> primero;
    private Nodo<T> ultimo;
    private int tamanio;

    public ColaDinamica() {
        primero = null;
        ultimo = null;
        tamanio = 0;

    }

    /**
     * Indica si la cola esta vacia
     * @return 
     */
    public boolean isEmpty() {
        return primero == null;
    }

    /**
     * Indica el tamaño de la cola
     * @return 
     */
    public int size() {
        return tamanio;
    }

    /**
     * Devuelve el primer elemento en la cola
     * @return 
     */
    public T primero() {
        if (isEmpty()) {
            return null;
        }

        return primero.getElemento();
    }

    /**
     * Elimina y devuelve el primer elemento de la cola
     * @return 
     */
    public T dequeue() {

        if (isEmpty()) {
            return null;
        }

        T elemento = primero.getElemento();
        Nodo<T> aux = primero.getSiguiente();
        primero = null;

        primero = aux;
        tamanio--;
        if (isEmpty()) {
            ultimo = null;
        }

        return elemento;
    }

    /**
     * Añade un nuevo elemento a la cola
     * @param elemento
     * @return 
     */
    public T enqueue(T elemento) {

        Nodo<T> aux = new Nodo(elemento, null);

        if (isEmpty()) {
            primero = aux;
            ultimo = aux;
        } else {
            if (size() == 1) {
                primero.setSiguiente(aux);
            } else {
                ultimo.setSiguiente(aux);
            }
            ultimo = aux;
        }

        tamanio++;
        return aux.getElemento();

    }

    /**
     * Muestra el contenido
     * @return 
     */
    public String toString() {

        if (isEmpty()) {
            return "La lista esta vacia";
        } else {

            String cadena = "";

            Nodo<T> aux = primero;
            while (aux != null) {
                cadena += aux;
                aux = aux.getSiguiente();
            }

            return cadena;

        }

    }

}

Lo podéis descargar directamente desde aquí.

También os dejo el vídeo donde lo hacemos de cero.

Espero que os sea de ayuda. Si tenéis dudas, preguntad. Estamos para ayudarte.

¿Te ha gustado y quieres apoyarme? ¡Sé mi patrón!
Etiquetas

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *