Ayuda con ordenamiento de listas enlasadas simples ("De verdad un buen reto")

Rayos, de verdad siento que estoy dejando pasar una oportunidad de negocio :) ehem ehem.

Exactamente en que necesitas ayuda? Vi tu código, pero como no lo identaste resulta realmente dificil tratar de leerlo, aún así no veo nada que tenga cara de "ordenamiento".

Que es lo que llevas y/o en que ncecesitas ayuda?

Lo más sencillo que puedes hacer es implementar el ordenamiento de burbuja. Es extremandamente sencillo.

1- Tomas el primer elemento y comparas si es mayor que el elemento siguiente.
2.a.- Si es mayor intercambias posiciones
2.b Si no es mayor, lo dejas en su lugar ( por que ya está ordenado )
3.- Repites hasta que este todo en su lugar.

Aquí te va el link de Wikipedia ( que seguro ya leiste ) http://es.wikipedia.org/wiki/Ordenamiento_de_burbuja viene incluso un ejemplo en Java.

Ahora, lo que necesitas hacer es: primero entender como funciona el ejemplo que viene ahí, y luego identificar cada parte en tu propio código. Por ejemplo, como intercambiar dos elementos de la lista, o como determinar si un elemento es mayor que otro.

Así que edita tu post, identa tu código y postea tu intento fallido de ordenamiento y quizá desde ahí sea más fácil ayudarte.

Bueno, eso no te funcionó, por que tu no quieres ordenar un arreglo de Object, sino una lista.

Lo primero que tienes que hacer es entender como funciona el método de ordenamiento. Espero que no te ofendas pero si no entiendes el ordenamiento por burbuja, no creo que te sirviera de algo pasar el examen de todas formas.

Aún así, aquí va un último intento.

Me parece que el problema es que quieres entender la lógica y programarla al mismo tiempo.

Explicación del algoritmo
Primero hay que entender lo que vas a hacer y luego ver como lo haces en Java.

Supongamos que tienes este vector ( arreglo, lista, conjunto o como quieras llamarle )

[1,9,5,7,2]

Evaluamos empezando por el primer elemento, el 1 y lo comparamos con el adyacente, el 9.

[1,9,5,7,2] // evaluando el elemento 0 

1 > 9 ? no, entonces evaluamos el siguiente

[1,9,5,7,2] // evaluando el elemento 1 

9 > 5 ? si. entonces los intercambiamos:

[1,5,9,7,2] // después del intercambio. 

y seguimos con el siguiente ( la tercera posición, que después del intercambio es el 9 otra vez )

[1,5,9,7,2] // evaluando el tercer elemento ( indice 2 ) 

9 > 7 ? si, entonces los intercambiamos

[1,5,7,9,2] // después del intercambio. 

Y repetimos, evaluamos ahora el cuarto elemento ( indice 3 )

[1,5,7,9,2] // después del intercambio. 

9 > 2 ? si, intercambiamos

[1,5,7,2,9] // después del intercambio. 

Y ahí le paramos ( por eso el segundo for dice n - 1 )

En este momento ya pusimos en su lugar al primer elemento, al 9, que si te fijas, llego como una burbuja hasta su posición.

Luego repetimos todo el proceso de nuevo, excepto claro el último elemento que ya sabemos que está en su lugar:

[1,5,7,2,9] 1 > 5 ? no
[1,5,7,2,9] 5 > 7 ? no
[1,5,7,2,9] 7 > 2 ? si, intercambio [1,5,2,7,9] y nos detenemos

y así hasta que quedan:

[1,5,2,7,9] 1 > 5 ? no.
[1,5,2,7,9] 5 > 2 ? si, intercambio [1,2,5,7,9] y nos detenemos

ultima

[1,2,5,7,9] 1 > 2 ? no

Y ya quedo ordenado.

Implementación para tu caso específico

Ahora, una vez que esté claro como funciona el ordenamiento se puede pasar a la implementación específica.

Acá estábamos comparando números, que tienen una forma "natural" de comparación. Pero cuando se trata de objetos propios hay que saber cuando un elemento es mayor o menor a otro.

Cuando son números usamos el operador "mayor que" (>),

if(  n > m ) {  .... 
}

Pero en tu caso como es un objeto propio, tendrías que crear un método aparte.

public boolean esMayorQue( List a, Lista b ) { 
     int edadA = Integer.parseInt( ( String ) a.edad );
     int edadB = Integer.parseInt( ( String ) b.edad );
      return edadA > edadB;
}

E invocarlo así ( más o menos )

if( esMayorQue( elemento, elemento.siguiente ) ) { 
   ... intercambiar 
}

El siguiente reto a a enfrentar es, como hacer el intercambio. Cuando se trata de arreglos esto funciona bien:

t = a[i];
a[i] = a[i+1];
a[i+1] = t;

Pero cuando se trata de una estructura como la tuya el intercambio debería ser algo como esto.

[ a -> b -> c -> ?]

aCambiar = a.siguiente.siguiente ( o sea c )

aCambiar es c

a.siguiente.siguiente = aCambiar.siguiente // a donde sea que apuntara c

[a -> b -> ? ]

aCambiar.siguiente = a.siguiente // c apunta a b

aCambiar -> b 

a.siguiente = aCambiar // a apunta a c

[a -> c -> b -> ? ]

Y quedan intercambiados.

Entonces, hay que hacer un método que se llame "intercambiar( a , b ) " y poner esa lógica ahí.

Con todo esto quedaría algo similar a:

for( ... recorrer una vez ) 
    for(  recorrer otra vez  ) 
         if( esMayorQue( lista, lista.siguiente ) ) { 
                intercambiar( lista, lista. siguiente ) ;
         }
    }
} 

Una vez más, lo más importante es primero entender la lógica y luego pelearse con como implementarlo.

Espero que esto te sirva. Haz otro intento, vuelve a repasar el algoritmo hasta que se te pegue en la cabeza y verás de de repente te iluminarás.

Modifica tu código intentando implementar estos métodos y postea lo que te salió y los errores que pudieras tener.

p.d. Prende el corrector ortográfico de tu browser :) :) :)

Suerte B-)

Por lo que dices, lo que necesitabas hacer es hacer una copia de la lista para que la anterior no se modificara. Lo mejor sería que le preguntaras a tu Dr. a que se refiere.

Es posible ordenar una lista en su lugar ( modificando la lista misma ) o se puede regresar otra lista ( una segunda ) que esté ordenada y la primera se queda exactamente igual. A mi me suena que es esto lo que tu Doitor necesita.

Entonces, es muy fácil. Antes de ordenar copias tu lista a otra lista, la ordenas, y la regresas ordenada y listo!!!

Algo como:

Estoy casi seguro que se trata de eso.

Chau!