Pila Ligada (nexos) en JAVA

Aquí  con un nuevo post muy sencillo, hace ya tiempo que hice este código como tarea y les comparto el código y el pdf donde viene una breve explicacon espero les sea de utilidad




Pila Ligada


Una pila es una estructura  de datos lineal en la cual se obtiene acceso a los datos en un orden especifico.
Primero en entrar ultimo en salir (LIFO).





Se observa que e una Pila los datos entran y salen por el mismo lado


Para una pila Ligada necesitamos un Nodo que es como una envoltura que contiene el dato y el enlace a un nodo siguiente








A continuación la clase Nodo

/**
 * Write a description of class Nodo here.
 * 
 * @author (Eli Alejandro Salinas Perez) 
 * @version (a version number or a date)
 */
public class Nodo
{
    // Necesitaremos un Nodo, imagenemos un nodo como una envoltura que contiene un dato, y tambien contienen
    // el enlace a otro dato
    //Declaramos los atributos del Nodo, un nodo se compone de un dato y de un enlace que es un Nodo
    
    private Object dato;
    // Nuestro dato sera de tipo Object para hacerlo mas generico
    private Nodo siguiente;
    // El nodo se llamara siguiente ya que contiene el enlace al siguiente nodo
    
    
    // Creamos nuestro Constructor .
    // Que parametros debe llevar el construtor?? La respuesta es simple, El dato que se almacenara
    
    public Nodo(Object dato){
    this.dato=dato;
    this.siguiente=null;
    // El sigueinte comienza en nulo porque podemos tener un solo nodo
    }
    
    // A contnuacion haremos los set y get de nuestros atributos
    
    public void setDato(Object Dato){
        this.dato=dato;
        // por eso prefiero Netbeans , los get y set los gneera solo jejee
        
    }
    public Object getDato(){
    return dato;
    }
    
    public void setSiguiente(Nodo siguiente){
    this.siguiente=siguiente;
    }
    
    public Nodo getSiguiente(){
    return siguiente;
    }
    
    
    
    // Ya quedo nuestra clase Nodo asi de sencilla
    


}


Ahora la clase Pila


/**
 * Write a description of class Pila here.
 * 
 * @author (Eli Alejandro Salinas Perez) 
 * @version (a version number or a date)
 */
public class Pila
{
Nodo tope;
// que contiene nuestra pila priemramente un tope, que se refiere a cual es el nodo ultimo dentro de
// pila
int cont;
// un contador que permite saber cuantos elemntos existen en la pila
public Pila() {
tope = null;
// la pila debe iniciar vacia es decir sin ningun nodo
}


// Nuestro metodo vacia(), determina si nuestra pila esta vacia, como se que esta vacia? pues esta vacia 
// cuando el tope es nulo es decir no existe ningun nodo
public boolean vacia(){
if(tope==null)
return true;
return false;
}


// nuestro metodo push() es el que agrega a la pila los elementos, que recibe pues el dato que es de tipo Object 
// para ser mas generico


public boolean push(Object ob){
Nodo aux=new Nodo(ob); // El dato es guardao en un Nodo, se crea un objecto nodo que contiene el dato pasado
if(aux!=null){
    // Si nuestro nodo no es nulo agrega
aux.setSiguiente(tope);
// el tope ahora se enlaza a nuestro nodo que se inserta, es decir tenemos un nuevo tope 
tope=aux;
// tope toma el valor de aux (todo el objeto, con su dato y su nodo siguiente)
cont++;
// contador aumento pues tenemos un nodo nuevo
return true;
}
return false;
}


//Metodo pop , este metodo es el que elimina de nuestra pila, en una pila solo se puede eliminar desde el tope es decir el ultimo elemento que entro
public Object pop(){
    // para eliminar primero debemos comprobar que no se encuentre vacia
if(!vacia()){ // si no esta vacia, entonces puede eliminar
Object ob=tope.getDato(); // se obtiene el dato del nodo tope, guardandolo en un object temporal


tope=tope.getSiguiente(); // ahora tope toma el valor del tope siguiente , con esto se a eliminado, pues el tope anterior que queda volando y el recolector de basura se lo
// llevara ya que no encuentra referencia a ese nodo
cont--;
// contador se decrementa
return ob;
// se retorna el nodo que se guardo temporalmente para ser mostrado
}
return null;
// si esta vacia retorna null o nada pues
}




// Ver tope solo nos permite ver el ultimo nodo sin eliminarlo


public Object verTope(){
    // de nuevo solo puedo ver el tope si existe algo en mi pila
if(!vacia()){
return tope.getDato();
// retorna el nodo del tope y ya
}
return null;
} 
    
// No es esencial tener el contador, si lo ponen agreguen los set y get del contador
}










Adjunto el pdf donde viene una pequeña prueba y el proyecto en Bluej






Para la prueba es necesario usar el IDE Bluej, yo lo recomiendo si están en aprendizaje, podrán descargarlo aquí.
http://www.bluej.org/