Pila Dinámica en Java

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

Una pila es una estructura dinámica que “apila” elementos de forma que para llegar al primero, hay que quitar todos los nodos que se hayan añadido después.

Utiliza LIFO (Last Input First Output) que significa que el último que entra es el primero que saldrá.

Esta pila 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";
    }

}


Pila dinamica

/**
 * Clase Pila Dinamica
 *
 * @author DiscoDurodeRoer
 * @param <T>
 */
public class PilaDinamica<T> {

    //Atributos
    private Nodo<T> top; //Ultimo nodo que se ha incluido
    private int tamanio;

    //Constructores
    public PilaDinamica() {
        top = null; //No hay elementos
        this.tamanio = 0;
    }

    /**
     * Indica si esta vacia o no
     *
     * @return
     */
    public boolean isEmpty() {
        return top == null;
    }

    /**
     * Indica el tamaño
     *
     * @return
     */
    public int size() {
        return this.tamanio;
    }

    /**
     * Devuelve el que esta más arriba en la pila
     *
     * @return
     */
    public T top() {
        if (isEmpty()) {
            return null;
        } else {
            return top.getElemento();
        }
    }

    /**
     * Saca y devuelve el elemento que mas arriba esta en la pila
     *
     * @return
     */
    public T pop() {
        if (isEmpty()) {
            return null;
        } else {
            T elemento = top.getElemento();
            Nodo<T> aux = top.getSiguiente();
            top = null; //marco para borrar
            top = aux; //actualizo el top
            this.tamanio--;
            return elemento;
        }
    }

    /**
     * Mete un elemento a la pila
     *
     * @param elemento
     * @return
     */
    public T push(T elemento) {

        Nodo<T> aux = new Nodo<>(elemento, top);
        top = aux; //actualizo el top
        this.tamanio++;
        return aux.getElemento();
    }

    /**
     * Devuelve el estado de la pila
     *
     * @return
     */
    public String toString() {

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

            String resultado = "";
            Nodo<T> aux = top;
            //Recorro la pila
            while (aux != null) {
                resultado += aux.toString();
                aux = aux.getSiguiente();
            }

            return resultado;

        }

    }

}

Lo podéis descargar directamente desde aquí.

También te dejo el vídeo donde lo hacemos paso a paso (también lo podéis descargar por aquí)

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 *