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 ver desde mi github 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.
Por favor, me interesa que hagas un tutorial lo mas pronto posible sobre una pila estatica hecha con array, ingresando los valores por teclado.