[SOLUCIONADO] Ordenamiento con punteros a estructura en c , ordenamiento burbujeo.

[ElenaJuarez]

Hola, buenas tardes. Soy nueva en el foro. En fin, tengo un problema intentando ordenar alfabeticamente un campo de una estructura. Para ordenar numeros utilizo una manera y quería hacer lo mismo para strings. Para ordenar numeros ejemplo edades realizo lo siguiente:

Código C:

struct BD *p,aux;
int i,j;
for(p=v,i=0;i<l;i++){
for(j=0;j<l-1-i;){
 
if((p+j)->edad>(p+j+1)){
aux=*(p+j);
*(p+j)=*(p+j+1);
*(p+j+1)=aux;
}
 
}}
 

Entonces quise hacer lo mismo pero modificando algunas cositas:

Código C:

for(p=v,i=0;i<l;i++){
for(j=0;j<l-1-i;){
 
if (strcmp((p+j)->nom,(p+j+1)->nom)>0){
 
strcpy(aux,*(p+j));
strcpy(*(p+j),*(p+j+1));
strcpy(*(p+j+1),aux);
}
}}
 

Y obviamente no funciona. Cualquier idea es bienvenida. Gracias!!

[Rufux]

strcmp no se usa si queremos comparar solo un caracter, en este caso basta comparar si una letra es mayor que otra, para eso tienes que tener en cuenta que las letras de a A-Z son menores que de a-z.

ejemplo:

cout << ('A' < 'B'? "Si": "No");

luego el ordenamiento, vere si lo encuentro, o si no veo como se hacia xD

Saludos

[vangodp]

Rufux Se trata de C. Viene especificado en el texto.

ElenaJuarez : Bienvenida al foro.

No se muy bien lo que quieres pero creo que es esto:

Código C:

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#define MAX_NOMBRES 100
#define MAX_LETRAS  25
 
 
struct BD{
    char nombre[MAX_NOMBRES][MAX_LETRAS]; //100 nombres de maximo 24 caracteres( No ocupar el ultimo ;) )
};
 
int main (){
    int i, j;
    struct BD *p, datos;
    int temp = 0;
    p = &datos;
    //100 nombres de no mas de 24 caracteres. La usaremos para no estar rellenando a mano XD
    char arreglo[MAX_NOMBRES][MAX_LETRAS] = {
        "Karla"            , "Reyna"        , "Ana"            , "Gina"        , "Georgina"    ,  //linea1
        "Joan"            , "Mario"        , "Enrique"        , "Maria"        , "Margo"        ,
        "Lupe"            , "Guadalupe"    , "Erika"        , "Marcuz"        , "Raquel"        , 
        "Leticia"        , "Carlos"        , "Luz"            , "Elena"        , "Pablo"        , 
        "Jose"            , "Juan"        , "Pedro"        , "Xochil"        , "Pepe"        , 
        "Kiju"            , "Rebeca"        , "Rodrigo"        , "Raul"        , "Adile"        , 
        "Janeth"        , "Daniel"        , "Dante"        ,"Eduardo"        , "Emmanuel"    , 
        "Esther"        , "Francia"        , "Federico"    , "Federica"    , "Fausto"        , 
        "Gabriel"        , "Gustavo"        , "German"        , "Hugo"        , "Israel"        ,    
        "Isabel"        , "Irma"        , "Lucia"        , "Lucy"        , "Luz"            , 
        "Luis"            , "Luisa"        , "Lucrecia"    , "Marcos"        , "Manuel"        ,
        "Manuela"        , "Mayla"        , "Nayla"        , "Teodoro"        , "Teofilo"        ,
        "Teofilito"        , "Argenis"        , "Delia"        , "Jesus"        , "Jim"            ,
        "Reyna"            , "Marce"        , "Paco"        , "Francisco"    , "Javier"        ,
        "Xavier"        , "Johan"        , "Joana"        , "Johana"        , "Lourdes"        , 
        "Rebeca"        , "Nathasa"        , "Elizabeth"    , "Miriam"        , "Yuri"        , 
        "Dum"            , "Victor"        , "Victoria"    , "Marta"        , "Martin"        , 
        "Mateo"            , "Matias"        , "Monica"        , "Moises"        , "Mirta"        , 
        "Eloy"            , "Elsa"        , "Emilia"        , "Estela"        , "Querubin"    ,
        "Casimiro"        , "Catalina"    , "Calletano"    , "Ignacio"        , "Zazaza"           //linea20
    };
 
    //cargamos los nombres a la estructura de forma desordenada desde el puntero y lo imprimimos.
    for ( i = 0; i < MAX_NOMBRES; i++ ) {
        strcpy ( &(p->nombre[i][0]), arreglo[i]);
        printf ( "\n %d \t%s", i+1, p->nombre[i] ); 
    }
    
    
    //Ordenamos los nombres
    printf("\n\nOrdenando...\n\n");
    for ( i = 0; i < MAX_NOMBRES; i++ ){
        for ( j = 0; j < MAX_NOMBRES; j++ ) {
            temp = strcmp ( &p->nombre[j][0], &p->nombre[j + 1][0] );
            
            if ( temp > 0 ) {
                strcpy ( p->nombre[0], p->nombre[j] );
                strcpy ( p->nombre[j], p->nombre[j + 1] );
                strcpy ( p->nombre[j + 1], p->nombre[0] );
            }
        }
    }
 
    //volvemos a imprimir ordenados.
    for ( i = 0; i < MAX_NOMBRES; i++ ) {
        printf ( "\n %d \t%s", i + 1, p->nombre[i] );
    }
 
    getchar();
    return 0;
}
 

Cuando tengas que hacer: *(puntero).nombre puedes hacerlo p->nombre"Es lo mismo" pero mas fácil.

En la estructura tengo 100 nombres de 25 letras cada. Nunca usamos la ultima en el caso de ser char.
luego creo un objeto de la estructura y hago que p apunte a ese objeto.

Luego de tener el puntero afinado le cargo los 100 nombres del arreglo para no tener que estar llenando nada a mano XD

Luego se ordena de forma parecida a la que comentas y luego después imprimimos el resultado.

No se si es esto lo que quieres... Espero que sirva

Suerte.

[Rufux]

Gracias vangodp, me olvide que programo en C pero con compilador de C++ xD

:::EDITADO::
Me acabo de dar cuenta que no lei bien xD, confundí ordenar letras de una cadena, con ordenar lista dinamica alfabeticamente, bueno si te sirve ya lo tienes xD

De todas formas hice una función de ejemplo del ordenamiento a burbuja con un solo ciclo (creo que es compatible tambien con C, es la siguiente:

Código C++:

typedef struct nodo{
    char nombre[100];
    struct nodo *next;
}Nodo;
 
typedef Nodo *ListaNombres;
 
void order(ListaNombres *lista){
    
    ListaNombres antes = NULL, ahora, despues, siguiente, temp;
    
    ahora = *lista;
    despues = ahora->next;
    
    while (despues) {
        
        if(despues->nombre[0] < ahora->nombre[0]){
            
            siguiente = despues->next;
            
            if(antes != NULL)
                antes->next = despues;
            
            despues->next = ahora;
            ahora->next =  siguiente;
            
            //intercambiamos ahora y despues para continuar el ciclo
            temp = despues;
            despues = ahora;
            ahora = temp;
            
        }
        
        antes = ahora;
        ahora = ahora->next;
        despues = despues->next;
    }
}
 

Bueno lo probe, funciona (me hiciste repase un poco xD), lo que hace es recibir el puntero a una lista, luego use 5 punteros (puedes usar 4) y son:
antes - el puntero al nodo anterior, es diferente de null despues de el primer ciclo
ahora - seria el puntero al primer nodo seleccionado de la lista
despues - seria el puntero al nodo que le sigue al de "ahora"
siguiente - seria el puntero al nodo que le sigue a "despues" (sirve solo para guardar el la dirección del siguiente nodo, así no lo borramos mientras se hace el cambio, se podria usar solo temp)
temp - seria un puntero temporaneo que sirve para guardar la direccion antes de sustituir "ahora" con "despues" (porque no puedes hacer "ahora" = "despues" y "despues" = "ahora", sin perder la dirección de ahora)

bueno el ciclo termina cuando despues es igual a null, dentro del ciclo comparo los primeros caracteres de los nombres, para ordenarlos de menor a mayor (de A a z)

luego intercambio los nodos, hice un dibujo para mostrarlo xD

http://imgur.com/EhFQ50x

Bueno espero que te sirva de ayuda, saludos

[ElenaJuarez]

Muchas gracias a los dos, me sirvieron las dos respuestas!! Estoy estudiando para un final y la verdad que hasta cosas que no vi en clase me pongo a hacer!! muchas gracias por sacarme las dudas!!