Tutorial invertir lista simple en java a travez de nodos by.AmeRiK@nO

Hola a todos, este es un pequeño tute que explica de forma breve un método que tuve que hacer para la universidad que invierte el orden de una lista sencilla en Java. Bueno empecemos.

El escenario es el siguiente:

Hay una clase Region.java, la cual posee un nombre, una area, una coordenada a travez de una clase Coordenada.java y finalmente una referencia tipo Region hacia la siguiente region para poder tener la lista

, hay una clase llamada Colombia.java la cual posee la lista de las Regiones, la cantidad, y la referencia tipo Region hacia la primera:

Clase Coordenada.java packete mundo:

Código

package mundo;
 
import javax.swing.JComponent;
 
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;
	}
}

La clase Region.java es la siguiente:

Código

package mundo;
 
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;
	}
}

Bueno lo unico que tiene esta clase son los metodos usuales setter y getters jeje, ahora miremos como esta la clase Colombia.java:

Código

package mundo;
 
import javax.swing.JOptionPane;
 
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("valle", 30, 11, 580.32);
		agregarRegion("barranquilla", 72, 10, 1520.14);
		agregarRegion("bogota", 55, 38, 14554.32);
		agregarRegion("pereira", 31, 48, 654.22);
		agregarRegion("a", 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;
		}
	}
}

Bueno lo que tiene es un método agregarRegion el cual como ven primero busca en buscarRegion(String nombre) que no haya sido ingresada todavía, y si no esta ingresada la inserta creando una nueva Region y asignandole primera a su referencia siguiente, por lo tanto la primera que se ingrese tendra en siguiente una referencia a null, por ser la última, es decir primera que se ingresa es última que queda jeje.

Bueno, al inicializar la aplicación se llamara al método inicializarColombia() que lo que hace es tan solo agregar unas cuantas regiones, pero no es el caso mostrar la clase principal :¬¬

, ahora viene lo interesante y es el método invertirLista().

Lo que hacemos primeramente es declarar una Región (miRegion) y le apuntamos a Primera para poder empezar desde el inicio

, 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 (temp)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 hasta que 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, cualquier duda comenten :xD

salu2

amerikano