style="display:inline-block;width:728px;height:90px"
data-ad-client="ca-pub-5164839828746352"
data-ad-slot="7563230308">

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

Hola soy estudiante de ingeniera en sistemas y estoy viendo la materia estructura de datos y la verdad estoy batallando mucho tengo que presentar un examen en done tengo que hacer un programa que reciba 6 datos con 3 campos cada uno (Nombre, edad, Carrera) cuando los 6 campos esten listo la lista se debe de partir en 2 y ordenarse por el campo edad.
soy novato en esto y la verdad es que no se como hacerlo ya trate con el metodo bubuja pero como lo entiendo muy bien como fionciona mi programa no puede fuincionar correctamente espero me ayuden.

import java.util.Scanner;
import javax.swing.*;

class Lista
{
public Object dato;
public Object edad;
public Object carrera;
public Lista siguiente;
public Lista(Object d,Object n,Object e, Lista s)
{
dato=d; siguiente=s;
edad=e;
carrera=n;
}
}
class ColaEncadenada
{
private Lista frente = null;
private Lista cola = null;
private int Tamaño =0;

public ColaEncadenada separar()
{
ColaEncadenada b = new ColaEncadenada();
Lista aux;
aux=frente;
aux=aux.siguiente;
aux=aux.siguiente;
b.frente=aux.siguiente;
b.cola=cola;
cola=aux;
aux.siguiente=null;
return b;
}
public Object picoCola()
{
return cola.dato;
}
public Object picofrente()
{
return frente.dato;
}
public void Agregar(Object newDato,Object newCarrera, Object newEdad)
{
Lista aux;
if (frente == null && cola == null)
{
frente = new Lista(newDato,newCarrera,newEdad, cola);
cola = frente;
}
else
{
aux =cola;
aux.siguiente = new Lista(newDato,newCarrera,newEdad,null);
cola=cola.siguiente;

}
}
public void Listar()
{
Lista aux;

if (frente==null)
{
System.out.println("La lista esta vacia!!\nIngrese dato primero!");
}
else
{
{
System.out.println("El frente es "+picofrente());
System.out.println("La cola es "+ picoCola());
}
aux=frente;
while(aux!=null)
{
System.out.println(aux.dato);
System.out.println(aux.edad);
System.out.println(aux.carrera);
aux=aux.siguiente;
}
}
}

public static void main (String[] args)
{
Scanner leer = new Scanner (System.in);
int opcion =0;

ColaEncadenada Primero = new ColaEncadenada();
ColaEncadenada Segundo = new ColaEncadenada();
while (opcion!=4)
{
System.out.println("Que deceas hacer");
System.out.println("1.-Ingresar");
System.out.println("2.-Listar");
System.out.println("3 - Cerrar programa.");

opcion = leer.nextInt();

switch(opcion)
{
case 1:
System.out.println("Que vas a ingresar");
Object n =leer.next();
Object c =leer.next();
Object e =leer.next();
Primero.Agregar(n,c,e);

break;

case 2:
System.out.println(" primero!");
Primero.Listar();
System.out.println(" segundo!");
Segundo.Listar();
Segundo=Primero.separar();
System.out.println(" despues de separar!");
System.out.println(" primero!");
Primero.Listar();
System.out.println(" segundo!");
Segundo.Listar();

break;

case 3:
System.out.println("Fin del programa!");
break;

}
}
}
}

Opciones de visualización de comentarios

Seleccione la forma que prefiera para mostrar los comentarios y haga clic en «Guardar las opciones» para activar los cambios.
Imagen de hhle12

Quisa para algunos esto sea

Quisa para algunos esto sea una tonteria o algo muy facil pero en serio que no se como hacerle en verdad espero me puedan ayduar ya que mi carrera esta en juego

Rayos, de verdad siento que

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.

Imagen de hhle12

jaja, La verdad es que no se nada de ordenamiento

mira mi problema es presisamente ese que no comprendo como hacer el ordenamiento con ningun metodo he leido mucho sobre el metodo burbuja pero la verdad es que no le entiendo y me urge saber como hacerlo ya que tengo 4 dias a partir de hoy para entregarlo ya que es un examen el cual nos dieron chanse de entregar asta esa fecha ya que no se vieron todos los temas y el ultimo tema que debimos de haber bisto fue todo lo relacionado con los ordenamientos.
de todos los puntos que mencione tengo todo y he de confensar que tambien la sufri solo me falta eso de los ordenamientos pero no tengo ni la mas remota idea de como hacerle espero y me puedas ayudar te lo agradeceria infinitamente
PD: seria mucho pedir que me proporciones ti direccion de correo electronico la verdad me gustaria poder contactarte un poco mas rapido ya que sule tener muchas dudas y la mayoria de los maestros que tengo no sirven mas que para cobrar y calentar el aciento

Imagen de hhle12

trate de modificarlo

hola trate de modificar mi post pero no pude ponerlo completo como le puedo hacer. mira esto fue lo que hise pero no me funciono:

<pre>
  static int[] Burbuja(Object edad[])
  {
    int i,j,t,n=edad.length;
   
    for(i=0;i&lt;n-1;i++)
    {
      for(j=0;j&lt;n-1;j++)
      {
        if(edad[j]&gt;edad[j+1])
        {
          t=edad[j];
            edad[j]=edad[j+1];
          edad[j+1]=t;
        }
      }
    }
    return edad;
  }  

</pre>

Imagen de ale_imp

Quizas te pueda servir

<pre>
public class Burbuja {
       
       
        public static int[] OrdenarBurbuja(int[] n){
                int temp;
                int t = n.length;
                for (int i = 1; i &lt; t; i++) {
                    for (int k = t- 1; k &gt;= i; k--) {
                        if(n[k] &lt; n[k-1]){
                            temp = n[k];
                            n[k] = n[k-1];
                            n[k-1]=  temp;
                        }
                    }
                }
                return n;
            }

        public static void main (String args[]){
                int n[] = {10,21,13,34,60};
               
                OrdenarBurbuja(n);
                //ya nada mas imprimes el nuevo arreglo ordenado y ya
        }
       
}</pre>

Es lo que te explico oscar primero

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.

Bueno, eso no te funcionó,

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-)

Imagen de AlexSnake

Tan claro como el agua

@OscarRyz, excelente explicacion, que digo excelente... magnifica. Asi deberiamos entender siempre lo que queremos hacer.

Imagen de hhle12

Muchas Gracias!!

muchas gracias por la explciacion vaya que tu explicacion es excelente ojala mi maestro explicara asi.

Imagen de hhle12

Hola

hola como etsas espeor que veas esto pronto ya tengo el algoritmo completo con orden y todo eso pero a hora el Dr me salio conq ue esta mal por que pide hacer dos listas y no una segun yo si tengo dos listas en el programa me podrian decir en donde esta mi error si es que lo tengo muchas gracias

Pues probablemente te podamos

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:

list = [q,w,e,r,t,y]

ordenar()  : Lista {
   nuevaLista = []
   for( Elemento e in  estaLista ) {
      nuevaLista.add( e );
   }
    // ordenar esa nueva lista como lo hacias antes
     // y regresarla
   return nuevaLista // nuestra original jamás se movio.
}  

Estoy casi seguro que se trata de eso.

Chau!

Imagen de hhle12

saludos

Hola OscarRys disculpa seria mucha la molesti se me pudieras proporcionar tu direccion de correo electronico es que la verdad que tengo dudas y pues quisiera que alguien me las respondiera en serio me interesa aprender gracias espero una pronta respuesta

Que tal hhe12. Mi correo no

Que tal hhe12.

Mi correo no lo puedo revisar tan seguido como quisiera, básicamente es por los firewalls corporativos.. Para mí sería mejor ayudarte por aquí.

style="display:inline-block;width:728px;height:90px"
data-ad-client="ca-pub-5164839828746352"
data-ad-slot="7563230308">