Ir al contenido principal

Invertir una lista sencilla en Java

Bueno dejo un pequeño método en Java que hice para un trabajo de la Universidad, lo que hace es invertir una lista sencilla a través de nodos.

Primero hay que tener en cuenta que el mundo del problema posee dos clases, una llamada Region.java y otra Colombia.java la cual tiene la lista de regiones y tambien una referencia a la primera Región, cada Región tiene una referencia a la siguiente Región y así sucesivamente hasta la ultima y formar la lista.



Bueno, todo el código completo sería algo como esto:


Codigo Coordenada.java:

public class Coordenada {

 private int x;
 private int y;

 public Coordenada(int x, int y){
  this.x = x;
  this.y = y;
 }

 public int getX(){
  return x;
 }

 public int getY(){

  return y;
 }
} 

Código Region.java:

public class Region {

 private String nombre;
 private double area;
 
 private Region siguiente;
 private Coordenada miCoordenada;

 public void setNombre(String nombre) {

  this.nombre = nombre;
 }

 public String getNombre() {

  return nombre;
 }

 public void setArea(double area) {

  this.area = area;
 }

 public double getArea() {

  return area;
 }

 public void setSiguiente(Region siguiente) {

  this.siguiente = siguiente;
 }

 public Region getSiguiente() {

  return siguiente;
 }

 public void setCoordenada(int x, int y) {

  miCoordenada = new Coordenada(x, y);
 }

 public Coordenada getCoordenada() {

  return miCoordenada;
 }
}

Código Colombia.java:

public class Colombia { Region primera; int cantidadRegiones; public Colombia() { primera = null; cantidadRegiones = 0; } public void agregarRegion(String nombre, int x, int y, double area) { if (buscarRegion(nombre) == null) { Region miRegion = new Region(); miRegion.setNombre(nombre); miRegion.setArea(area); miRegion.setCoordenada(x, y); miRegion.setSiguiente(primera); primera = miRegion; } else JOptionPane.showMessageDialog(null, "Esta region ya fue ingresada"); } public Region buscarRegion(String nombre) { Region miRegion = primera; while (miRegion != null) { if (miRegion.getNombre().equals(nombre)) return miRegion; miRegion = miRegion.getSiguiente(); } return null; } public void inicializarColombia() { agregarRegion("quindio", 10, 20, 230.54); agregarRegion("cali", 30, 11, 580.32); agregarRegion("barranquilla", 72, 10, 1520.14); agregarRegion("bogota", 55, 38, 14554.32); agregarRegion("pereira", 31, 48, 654.22); agregarRegion("medellin", 31, 48, 654.22); } public void invertirLista() { Region miRegion = primera, temp = null; while (miRegion.getSiguiente() != null) { temp = miRegion.getSiguiente(); miRegion.setSiguiente(temp.getSiguiente()); temp.setSiguiente(primera); primera = temp; } } }
En base al método de invertir la lista invertirLista(), lo que hacemos primeramente es declarar una Región (miRegion) y le apuntamos a Primera para poder empezar desde el inicio :P, y tambien declaramos una referencia (temp) que nos servira para el cambio de nodos.

Como bien, la lista es sencilla por lo tanto no tenemos referencia a Anterior, por eso debemos tener un auxiliar que nos sirva de rescate.

El bucle lo que hace es mientras no estemos en la ultima región "While(miRegion.getSiguiente() != null)" apuntamos temp hacia la siguiente de donde estamos parados, para que de esta forma al cambiar la referencia en la que estamos hacia la que sigue de la siguiente, en temp nos quede la que saltamos (ahora explico bien el mecanismo usado).

Con "miRegion.setSiguiente(temp.getSiguiente());" lo que hacemos es que donde estamos ponemos en siguiente la referencia siguiente del elemento que saltamos, de esta forma quedaria en la misma posición de temp.

Ahora "temp.setSiguiente(primera);" lo que hace es cambiar la referencia siguiente de temp para que apunte a la primera, y hecho esto ya pasamos nuestro elemento miRegion una posición mas en la lista, y con "primera = temp" indicamos que primera ya no es miRegion sino temp, el esquema siguiente ilustra lo que hace el bucle.


Esquema:

1. Inicio del escenario: Region miRegion = primera, temp=null;



2. Inicializamos temp: temp = miRegion.getSiguiente();


3. Saltamos E2: miRegion.setSiguiente(temp.getSiguiente());



4. Apuntamos temp a primera: temp.setSiguiente(primera);


5. Tomamos ya primera como temp: primera = temp;


6. Ahora ordenamos el esquema para que se vea mejor:

Como ven esto se repite mientras miRegion.getSiguiente() != null, eso indicaria que terminamos, ya que los elementos iran quedando uno detrás del otro y asi sucesivamente.

Espero les sirva de algo.

Comentarios

Anónimo ha dicho que…
Hola muchas gracias, mi sirvió de mucho tu tutoríal de como invertir la lista sencilla.

Un saludo.
Anónimo ha dicho que…
muy util man! bien explicado.. muchas gracias!
amerikano ha dicho que…
Gracias a ambos por leerla, y me agrada que les halla gustado :).

salu2
Anónimo ha dicho que…
muchas gracias...me sirvio para un ejercicio de la universidad....muchas gracias....
....Dios te Bendiga....

Entradas populares de este blog

Nota final del blog

Desde la última vez que publiqué una nota en el blog publicando algun tutorial de mi autoria o algún tema en especifico he recibido muchos comentarios por interno de personas que me solicitan resubir los archivos, lo cual es normal debido al tiempo que ha pasado desde entonces, pero en cierta manera es gratificante ver mensajes  de agradecimiento de personas a quienes les ha servido mucho en su aprendizaje lo tutoriales que pude realizar de ingeniería inversa o de programación básica. Después de todos estos años solo logré encontrar algunos de los archivos que estaban presentes en el blog y los volvi a subir para que puedan descargarlos. También debo decir que este blog ya no va más. He tenido algunos inconvenientes y cambios en temas personales por lo cual el reversing ya no es una de mis actividades. Les agradezco a todos los que han dejado sus comentarios positivos a lo largo de los años que ha estado online el blog y muy orgulloso de ver que a muchos les ha ayudado mis pequeños

[SRC] Compresor de Archivos Huffman

Después de unos días sin publicar he vuelto otra vez y quiero mostrar esta vez una de las tareas que nos pusieron este semestre en la universidad programando en java. Se trata de implementar el algoritmo de compresión Huffman , para quien no sepa de que se trata, en este link se explica que es esto, pero para ahondar un poco les cuento que se trata primero de generar una lista enlazada con los bytes del archivo y sus frecuencias ordenada de menor a mayor y luego con esta se procede a formar un arbol binario de frecuencias donde los bytes que tengan mayor aparición en el archivo o texto a comprimir (en este caso solo es para archivos y no tan largos :P) se encontraran a mayor altura.