LISTA DE UN NODO.

UNA LISTA ENLAZADA ES UNA ESTRUCTURA DE DATOS FUNDAMENTALES, Y PUEDE SER USADA PARA IMPLEMENTAR OTRAS ESTRUCTURAS DE DATOS. CONSISTE EN UNA SECUENCIA DE NODOS, EN LOS QUE SE GUARDARAN CAMPOS DE DATOS ARBITRARIOS Y UNA O DOS REFERENCIAS, ENLACES O PUNTEROS AL NODO ANTERIOR O POSTERIOR. EL PRINCIPAL BENEFICIO DE LAS LISTAS ENLAZADAS RESPECTO A LOS VECTORES CONVENCIONALES ES QUE EL ORDEN DE LOS ELEMENTOS ENLAZADOS PUEDE SER DIFERENTE AL ORDEN DE ALMACENAMIENTO EN LA MEMORIA O EL DISCO, PERMITIENDO QUE QUE EL ORDEN DE RECORRIDO DE LA LISTA SEA DIFERENTE AL DE ALMACENAMIENTO.  

CLASE 1:
package nodo;

public class Nodo {
      private String informacion;
      private Nodo enlace;

      public Nodo (String x)
      {
          informacion=x;
          enlace=null;
      }
      public Nodo(String x, Nodo n){
        informacion=x;
        enlace=n;
      }

    /**
     * @return the informacion
     */
    public String getInformacion() {
        return informacion;
    }

    /**
     * @param informacion the informacion to set
     */
    public void setInformacion(String informacion) {
        this.informacion = informacion;
    }

    /**
     * @return the enlace
     */
    public Nodo getEnlace() {
        return enlace;
    }

    /**
     * @param enlace the enlace to set
     */
    public void setEnlace(Nodo enlace) {
        this.enlace = enlace;
    }

}


CLASE 2:

package nodo;
import javax.swing.JOptionPane;
public class Lista {
   private Nodo inicio;

   Lista(){
       inicio=null;
   }
    /**
     * @return the inicio
     */
    public Nodo getInicio() {
        return inicio;
    }

    /**
     * @param inicio the inicio to set
     */
    public void setInicio(Nodo inicio) {
        this.inicio = inicio;
    }
   public Lista InsertarInicio(String informacion){
   Nodo nuevo;
   nuevo= new Nodo(informacion);//crear nuevo nodo(elemento)
   nuevo.setEnlace(getInicio());//enlaza nuevo al frente de la lista
   setInicio(nuevo);//mueve inicio y apunta al nuevo nodo
   return this;//devuelve la referencia del objeto lista
   }
   public Lista InsertarFinal(String informacion){//este metodo funciona si por lo menos la lista tiene un nodo
     Nodo ultimo;
     ultimo=inicio;//ultimo se inicializa al comienza de la lista
     while(ultimo.getEnlace() !=null){//recorrido para buscar el ultimo nodo
     ultimo=ultimo.getEnlace();//ultimo toma la direccion del nodo siguiente
     }
     ultimo.setEnlace(new Nodo (informacion)); //se crea el nuevo nodo despues del ultimo
     return this;
   }
   public Lista InsertarAntes(String nombre, String ref){//se utilizan parametros
       Nodo nuevo, actual, anterior= null;
       boolean esta=true;
       actual=inicio;//vamos a recorrer la lista con actual
       while (!actual.getEnlace().equals(ref)&& esta){//para comparar dos cadenas
           if(actual.getEnlace()!=null){
           anterior=actual;
           actual=actual.getEnlace();
       }
           else{
               esta=false;
           }
       }
       if(esta){
           if(inicio==actual){//vamos a insertar antes del primer nodo
               nuevo=new Nodo(nombre, inicio);//se llama al segundo constructor
               inicio=nuevo;
           }

           else{
               nuevo=new Nodo(nombre, actual);
               anterior.setEnlace(nuevo);
           }
       }
       return this;
   }
  public Lista insertaDespues(String nombre, String ref){
      Nodo nuevo,actual=null;
      boolean esta=true;
      actual=inicio;//es esencial en todo st programa
      while(! actual.getInformacion().equals(ref)&& esta){
          if(actual.getEnlace() !=null)
              actual =actual.getEnlace();
              else{
              esta=false;
              }
          if(esta){
              nuevo=new Nodo (nombre, actual.getEnlace());
              actual.setEnlace(nuevo);
           }
         }
       return this;
     }
  public String eliminaInicio(){
      Nodo x=inicio;
      inicio=inicio.getEnlace();//borrado logico
      return x.getInformacion();
  }
  public String eliminaFinal(){///quitar de la lista l ultimo nodo
      Nodo ultimo,anterior=null;
      ultimo=inicio;
      while(ultimo.getEnlace()!=null){
          anterior=ultimo;
          ultimo=ultimo.getEnlace();
          }
      if(inicio.getEnlace()==null){
          inicio=null;
      }
      else{
      anterior.setEnlace(null);//borrado logico
      }
      return ultimo.getInformacion();
      }
  public void imprimir(){
    String cadena="";
    Nodo q=inicio;
    int i=1;
    while(q !=null){
      cadena+="\n"+i+". "+q.getInformacion();
      q=q.getEnlace();
      i++;
    }
    JOptionPane.showMessageDialog(null, cadena,"Nodos de la lista",JOptionPane.PLAIN_MESSAGE);
}
  public String eliminaX (String x){
      Nodo actual, anterior =null;
      boolean esta=true;
      actual=inicio;
      while(!actual.getInformacion().equals(x)&& esta){
          if(actual.getEnlace()!=null){
              anterior=actual;
              actual.setEnlace(actual.getEnlace());
          }
          else
              esta=false;
      }
      if(esta){
          anterior.setEnlace(actual);//borrado logico
          return actual.getInformacion();
      }
      else
       return " ";
  }
}//ventaja es que podemos acer mejor uso de la memoria  y desventaja si pierdes lniclo por descuido
//o por falta de conocimieto de como programar pierdes la lista