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.