public class Pila {

// Busca un elemento en la pila.

// Puntero que indica el inicio de la pila o también conocida como el
* @param referencia valor del nodo a buscar.
// tope de la pila.
* @return true si el valor de referencia existe en la pila.
private Nodo inicio;
*/
// Variable para registrar el tamaño de la pila.
public boolean buscar(int referencia){
private int tamanio;
// Crea una copia de la pila.
/**
Nodo aux = inicio;
* Constructor por defecto.
// Bandera para verificar si existe el elemento a buscar.
*/
boolean existe = false;
public void Pila(){
// Recorre la pila hasta llegar encontrar el nodo o llegar al final
inicio = null;
// de la pila.
tamanio = 0;
while(existe != true && aux != null){
}
// Compara si el valor del nodo es igual que al de referencia.
/**
if (referencia == aux.getValor()) {
* Consulta si la pila esta vacia.
// Cambia el valor de la bandera.
* @return true si el primer nodo (inicio), no apunta a otro nodo.
existe = true;
*/
}
public boolean esVacia(){
else{
return inicio == null;
// Avanza al siguiente nodo.
}
aux = aux.getSiguiente();
/**
}
* Consulta cuantos elementos (nodos) tiene la pila.
}
* @return numero entero entre [0,n] donde n es el numero de elementos
// Retorna el valor de la bandera.
* que contenga la lista.
return existe;
*/
}
public int getTamanio(){
/**
return tamanio;
* Elimina un nodo de la pila ubicado por su valor.
}
* @param referencia valor de referencia para ubicar el nodo.
/**
*/
* Agrega un nuevo nodo a la pila.
public void remover(int referencia){
* @param valor a agregar.
// Consulta si el valor existe en la pila.
*/
if (buscar(referencia)) {
public void apilar(int valor){
// Crea una pila auxiliar para guardar los valores que se
// Define un nuevo nodo.
// vayan desapilando de la pila original.
Nodo nuevo = new Nodo();
Nodo pilaAux = null;
// Agrega al valor al nodo.
// Recoore la pila hasta llegar al nodo que tenga el valor
nuevo.setValor(valor);
// igual que el de referencia.
// Consulta si la pila esta vacia.
while(referencia != inicio.getValor()){
if (esVacia()) {
// Crea un nodo temporal para agregarlos a la pila auxiliar.
// Inicializa la pila con el nuevo valor.
Nodo temp = new Nodo();
inicio = nuevo;
// Ingresa el valor al nodo temporal.
}
temp.setValor(inicio.getValor());
// Caso contrario agrega el nuevo nodo al inicio de la pila.
// Consulta si la pila auxiliar no ha sido inicializada.
else{
if(pilaAux == null){
nuevo.setSiguiente(inicio);
// Inicializa la pila auxiliar.
inicio = nuevo;
pilaAux = temp;
}
}
// Incrementa el contador del tamaño.
// Caso contrario si la pila auxiliar ya contiene elementos
tamanio++;
// los agrega al inicio.
}
else{
/**
temp.setSiguiente(pilaAux);
* Elimina el elemento que se encuentra en el tope de la piala.
pilaAux = temp;
*/
}
public void retirar(){
// Elimina el nodo del tope de la pila hasta llegar al nodo
if (!esVacia()) {
// que se desea eliminar.
// Asigna como primer nodo al siguiente de la pila.
retirar();
inicio = inicio.getSiguiente();
}
// Decrementa el contador del tamaño de la pila
// Elimina el nodo que coincide con el de referencia.
tamanio--;
retirar();
}
// Regresa los valores de la pila auxiliar a la pila original
}
// mientras la pila auxiliar tenga elementos.
/**
while(pilaAux != null){
* Consulta el valor del nodo que se encuentra en la cima de la pila
// Utiliza el metodo apilar para regresar los elementos a
* @return valor del nodo.
// la pila original.
* @throws Exception
apilar(pilaAux.getValor());
*/
// Avansa al siguiente nodo de la pila auxiliar.
public int cima() throws Exception{
pilaAux = pilaAux.getSiguiente();
if(!esVacia()){
}
return inicio.getValor();
// Libera la memoria utilizada por la pila auxiliar.
} else {
pilaAux = null;
throw new Exception("La pila se encuentra vacia.");
}
}
}
}
 // Actualiza el valor de un nodo en la pila.
public class Nodo {
* @param referencia valor del nodo para ubicar el que se desea actualizar.
// Variable en la cual se va a guardar el valor.
* @param valor por el cual se desea remplazar el valor del nodo.
private int valor;
*/
// Variable para enlazar los nodos.
public void editar(int referencia, int valor){
private Nodo siguiente;
// Consulta si el nodo existe en la pila
/**
if (buscar(referencia)) {
* Constructor que inicializamos el valor de las variables.
// Crea una pila auxiliar.
*/
Nodo pilaAux = null;
public void Nodo(){
// Recoore la pila hasta llegar al nodo que tenga el valor
this.valor = 0;
// igual que el de referencia.
this.siguiente = null;
while(referencia != inicio.getValor()){
}
// Crea un nodo temporal para agregarlos a la pila auxiliar.
Nodo temp = new Nodo();
// Métodos get y set para los atributos.
// Ingresa el valor al nodo temporal.
temp.setValor(inicio.getValor());
public int getValor() {
// Consulta si la pila auxiliar no a sido inicializada.
return valor;
if(pilaAux == null){
}
// Inicializa la pila auxiliar.
pilaAux = temp;
public void setValor(int valor) {
}
this.valor = valor;
// Caso contrario si la pila auxiliar ya contiene elementos
}
// los agrega al inicio.
else{
public Nodo getSiguiente() {
temp.setSiguiente(pilaAux);
return siguiente;
pilaAux = temp;
}
}
// Elimina el nodo del tope de la pila hasta llegar al nodo
public void setSiguiente(Nodo siguiente) {
// que se desea eliminar.
this.siguiente = siguiente;
retirar();
}
}
}
// Actualiza el valor del nodo.
inicio.setValor(valor);
// Regresa los valores de la pila auxiliar a la pila original
// mientras la pila auxiliar tenga elementos.
while(pilaAux != null){
// Utiliza el metodo apilar para regresar los elementos a
// la pila original.
apilar(pilaAux.getValor());
// Avansa al siguiente nodo de la pila auxiliar.
pilaAux = pilaAux.getSiguiente();
}
// Libera la memoria utilizada por la pila auxiliar.
pilaAux = null;
}
}
/**
* Elimina la pila
*/
public void eliminar(){
// Elimina el valor y la referencia a los demas nodos.
inicio = null;
// Reinicia el contador a 0.
tamanio = 0;
}
/**
* Despliega en pantalla los elementos de la pìla.
*/
public void listar(){
// Crea una copia de la pila.
Nodo aux = inicio;
// Recorre la pila hasta el ultimo nodo.
while(aux != null){
System.out.println("|\t" + aux.getValor() + "\t|");
System.out.println("-----------------");
aux = aux.getSiguiente();
}
}
}