elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.

 

 


Tema destacado:


+  Foro de elhacker.net
|-+  Programación
| |-+  Programación C/C++ (Moderadores: Eternal Idol, Littlehorse, K-YreX)
| | |-+  [C] Lista doble y error en campo anterior, siguiente
0 Usuarios y 1 Visitante están viendo este tema.
Páginas: [1] Ir Abajo Respuesta Imprimir
Autor Tema: [C] Lista doble y error en campo anterior, siguiente  (Leído 2,103 veces)
edr89

Desconectado Desconectado

Mensajes: 105


Ver Perfil
[C] Lista doble y error en campo anterior, siguiente
« en: 10 Octubre 2013, 02:54 am »

Hola, la semana pasada pregunté por una lista ligada simple y partiendo de ese código agregué un apuntador al campo anterior para convertirla en una lista doble circular.

El problema creo sucede cuando le paso los parametros a la funcion que crea el nodo en la linea 30, los parametros son el nombre del jugador, el apuntador del elemento anterior y el apuntador al siguiente.

Lo que me esta costando trabajo es visualizar cuando se crea el primer elemento que apunta a si mismo y los demas apuntan al anterior o posterior pero no a si mismos  :huh:

Pregunta: Que apuntador se debe pasar para el campo siguiente?
cuando es una lista simple se pasa la direccion del elemento anterior para asignarle en su campo siguiente el valor del nuevo nodo, pero aqui??

reedito: cometi de nuevo el error de asignacion en: if(i==0), ya edite el código


Código
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. struct persona
  4. {
  5.    char *nombre;
  6.    struct persona *next;
  7.    struct persona *prev;
  8. };
  9. typedef struct persona JUGADOR;
  10.  
  11. typedef JUGADOR *J_PTR;
  12.        J_PTR first = NULL;
  13.        J_PTR last = NULL;
  14.  
  15. J_PTR add_to_list(char *ch, J_PTR prev_rec,J_PTR next_rec);
  16.  
  17. int main()
  18. {
  19.    int i,num_jugadores;
  20.    char *nombre;
  21.    J_PTR j_addr = NULL;
  22.    printf("Escribe el numero de jugadores: ");
  23.    scanf("%d",&num_jugadores);
  24.    while(getchar()!='\n');
  25.    printf("\nAhora cada uno de sus nombres\n\n");
  26.    for(i=0;i<num_jugadores;i++)
  27.    {
  28.        printf("Jugador %d: ",i+1);
  29.        scanf("%s",&nombre);
  30.        j_addr = add_to_list(nombre, j_addr, first); /*la funcion devuelve new_rec*/
  31.            if(i==0)
  32.            {
  33.                first = j_addr;
  34.            }
  35.        last = j_addr;
  36.        last->next = first;
  37.  
  38.            printf("Nombre:%s\nprev: %p  \nnext: %p\n",nombre,(void *)j_addr->prev,(void *)j_addr->next);
  39.  
  40.        puts("\n");
  41.    }
  42. }
  43.  
  44. J_PTR add_to_list(char *name, J_PTR prev_rec,J_PTR next_rec)
  45. {
  46.    J_PTR new_rec = NULL;
  47.    new_rec = (J_PTR) malloc(sizeof(JUGADOR)); // Crear jugador
  48.    if(!new_rec)
  49.    {   //Validacion de malloc
  50.        printf("Error al reservar memoria");
  51.        exit(1);
  52.    }
  53.    new_rec->nombre = name;
  54.    new_rec->next = NULL;
  55.    new_rec->prev = NULL;
  56.    if(prev_rec) //Si hay un elemento antes
  57.    {
  58.        prev_rec->next = new_rec;
  59.        new_rec->prev = prev_rec;
  60.    }
  61.    new_rec->next = next_rec;
  62.    return(new_rec);
  63. }
  64.  


« Última modificación: 10 Octubre 2013, 03:18 am por edr89 » En línea

eferion


Desconectado Desconectado

Mensajes: 1.248


Ver Perfil
Re: [C] Lista doble y error en campo anterior, siguiente
« Respuesta #1 en: 10 Octubre 2013, 08:10 am »

Si la lista es circular, el primer elemento que metas tendrá que apuntarse a sí mismo... hasta ahí todo claro.

A la hora de insertar el segundo elemento se dará la particularidad de que, como tiene que seguir siendo una lista circular, el anterior y el posterior del primer elemento será el segundo elemento y viceversa:

A <-> B <-> A

Y ya de ahí en adelante la lista tiene el formato que tú ya conoces:

A <-> B <-> C <-> A

La única situación diferente es insertar el primer elemento, que tienes que hacer que se apunte a sí mismo... en el resto de casos sólo tienes que decidir la posición en la que vas a insertarlo y asignar los punteros anterior y posterior de los elementos que estén delante y detrás ( recuerda que al ser circular no habrá punteros nulos y, por tanto, todos los punteros serán válidos )


En línea

edr89

Desconectado Desconectado

Mensajes: 105


Ver Perfil
Re: [C] Lista doble y error en campo anterior, siguiente
« Respuesta #2 en: 11 Octubre 2013, 06:09 am »

recuerda que al ser circular no habrá punteros nulos y, por tanto, todos los punteros serán válidos

Si, primero creo una lista doble y uso dos apuntadores auxiliares, uno inicial y otro final, ya que se agregaron todos los elementos cierro la lista con:  ;D

Código
  1. first->prev = last;

Me di cuenta que no tiene sentido pasar el apuntador inicial como parametro al crear el elemento, modificando el código ahora si imprime las direcciones correctas.

Código
  1. J_PTR add_to_list(char *name, J_PTR prev_rec)
  2. {
  3.    J_PTR new_rec = NULL;
  4.    new_rec = (J_PTR) malloc(sizeof(JUGADOR)); // Crear jugador
  5.    if(!new_rec)
  6.    {   //Validacion de malloc
  7.        printf("Error al reservar memoria");
  8.        exit(1);
  9.    }
  10.    new_rec->nombre = name;
  11.    new_rec->next = NULL;
  12.    new_rec->prev = NULL;
  13.    if(prev_rec) //Si hay un elemento antes
  14.    {
  15.        prev_rec->next = new_rec;
  16.        new_rec->prev = prev_rec;
  17.    }
  18.    return(new_rec);
  19. }



El resultado final es un juego que elimina jugadores de una lista hasta quedar el ultimo.
Es posible que el algoritmo no sea el mas eficiente, lo he podido compilar y funciona.  :)
Código
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #define PINPONPAPAS 6
  4. struct persona
  5. {
  6.    char *nombre;
  7.    struct persona *next;
  8.    struct persona *prev;
  9. };
  10. typedef struct persona JUGADOR;
  11.  
  12. typedef JUGADOR *J_PTR;
  13.        J_PTR first = NULL;
  14.        J_PTR last = NULL;
  15.  
  16. char *input_nombre(size_t long_max);
  17. J_PTR add_to_list(char *ch, J_PTR prev_rec);
  18. char input_error_conteo();
  19. int input_error_num_jugadores();
  20. int input_mayor_lista(int jugadores);
  21. char input_error_sino();
  22. void pausa();
  23. void pin_pon_papas();
  24.  
  25. int main()
  26. {
  27.    int i,num_jugadores;
  28.    int inicio_conteo, pin; //Numero de jugador para empezar el juego y numero de veces que se va a contar respectivamente
  29.    char direccion_conteo; // Las opciones son D = derecha, I = izquierda
  30.    char bucle ='X'; //para repetir el programa
  31.    char *nombre;
  32.    J_PTR j_addr = NULL; //Apunta a los elementos creados en la funcion add_to_list()
  33.    J_PTR j_aux = NULL; //Este apuntador se usa cuando se van eliminando los jugadores cada 6 conteos
  34.    do
  35.    {
  36.        system("CLS");
  37.    pin_pon_papas();
  38.    printf("\n\nEnlista a los jugadores y elimina uno a uno para terminar con un ganador\n");
  39.    printf("\n\nEscribe el numero de jugadores: ");
  40.    num_jugadores = input_error_num_jugadores();
  41.        while(getchar()!='\n'); //limpiar buffer
  42.    printf("\nAhora cada uno de sus nombres\n\n");
  43.        for(i=0;i<num_jugadores;i++)
  44.        {
  45.            printf("Jugador %d: ",i+1);
  46.            nombre = input_nombre(30);//Se crean nombres, el parametro es la longitud maxima de texto
  47.            j_addr = add_to_list(nombre, j_addr); /*la funcion devuelve new_rec*/
  48.                if(i==0)
  49.                {
  50.                    first = j_addr;
  51.                }
  52.            last = j_addr; //se recorre al ultimo jugador tecleado.
  53.            puts("");
  54.        }
  55.    first->prev = last;//cierre de
  56.    last->next = first;//lista circular
  57.    j_addr = first; //Recorrer apuntador al primer elemento creado para imprimir la lista de jugadores.
  58.    printf("\nEstos son los participantes:\n\n");
  59.        for(i=0;i<num_jugadores;i++)
  60.        {
  61.            printf("%2d: %s\n",i+1,j_addr->nombre);
  62. //    printf("Nombre:%s\nDireccion jugador:%p\nprev: %p  \nnext: %p\n",nombre,(void *)j_addr,(void *)j_addr->prev,(void *)j_addr->next);
  63.            j_addr = j_addr->next;
  64.        }
  65.    printf("\nEscribe el numero de jugador con el que quieres iniciar el conteo: ");
  66.    inicio_conteo = input_mayor_lista(num_jugadores);
  67.        while(getchar()!='\n'); //key buffer
  68.    j_addr = first;
  69.    for(i=0;i<inicio_conteo-1;i++)
  70.    {
  71.        j_addr = j_addr->next;
  72.    }
  73.    printf("\n\nHas elegido a %s !\n\n",j_addr->nombre);
  74.    printf("Quieres iniciar el conteo hacia la derecha o izquierda? (D/I)");
  75.    direccion_conteo = input_error_conteo(); //validar dato tecleado
  76.    puts("\nIniciando conteo...\n");
  77.        if(direccion_conteo=='D')
  78.        {
  79.            for(pin=0;pin<num_jugadores-1;pin++)
  80.            {
  81.                    for(i=0;i<PINPONPAPAS;i++)
  82.                    {   //Ubicar al jugador a eliminar
  83.                        j_addr = j_addr->next;
  84.                    }
  85.                pin_pon_papas();
  86.                printf(", sale %s\n\n",j_addr->nombre);
  87.                j_aux = j_addr->next;
  88.                j_aux->prev = j_addr->prev;
  89.                j_aux = j_addr->prev;
  90.                j_aux->next = j_addr->next;
  91.                j_aux = j_addr->prev;
  92.                free(j_addr);
  93.                j_addr = j_aux;
  94.                pausa();
  95.            }
  96.        }
  97.        else
  98.        {
  99.            for(pin=0;pin<num_jugadores-1;pin++)
  100.            {
  101.                    for(i=0;i<PINPONPAPAS;i++)
  102.                    {   //Ubicar al jugador a eliminar
  103.                        j_addr = j_addr->prev;
  104.                    }
  105.                pin_pon_papas();
  106.                printf(", sale %s\n\n",j_addr->nombre);
  107.                j_aux = j_addr->next;
  108.                j_aux->prev = j_addr->prev;
  109.                j_aux = j_addr->prev;
  110.                j_aux->next = j_addr->next;
  111.                j_aux = j_addr->next;
  112.                free(j_addr);
  113.                j_addr = j_aux;
  114.                pausa();
  115.            }
  116.        }
  117.    printf("\nEl ultimo jugador en pie es %s!\n",j_addr->nombre);
  118.    printf("\n\nQuieres jugar de nuevo? ( S/N ): ");
  119.        bucle = input_error_sino();
  120.        first = NULL;
  121.        last = NULL;
  122.        free(j_addr);
  123.        j_aux = NULL;
  124.        j_addr = NULL;
  125.        i=0;
  126.  
  127.    }while(bucle=='S');
  128.    return 0;
  129. }
  130.  
  131. /*Funcion: J_PTR add_to_list()
  132.   Proposito: Crear un bloque en memoria para el jugador y asigna los apuntadores a siguiente y previo*/
  133. J_PTR add_to_list(char *name, J_PTR prev_rec)
  134. {
  135.    J_PTR new_rec = NULL;
  136.    new_rec = (J_PTR) malloc(sizeof(JUGADOR)); // Crear jugador
  137.    if(!new_rec)
  138.    {   //Validacion de malloc
  139.        printf("Error al reservar memoria");
  140.        exit(1);
  141.    }
  142.    new_rec->nombre = name;
  143.    new_rec->next = NULL;
  144.    new_rec->prev = NULL;
  145.    if(prev_rec) //Si hay un elemento antes
  146.    {
  147.        prev_rec->next = new_rec;
  148.        new_rec->prev = prev_rec;
  149.    }   //aqui solamente se crea la lista doble, en main()es donde se cierra la lista
  150.    return(new_rec);
  151. }
  152.  
  153. /*Funcion: input_nombre(size_t long_max)
  154.   Proposito: Funcion para entrada de datos, primero reservo el espacio en memoria de longitud definida en el
  155.              parametro long max, despues sigue la entrada de datos.*/
  156. char *input_nombre(size_t long_max)
  157. {
  158.    char *nombre =NULL;
  159.  
  160.    if ((nombre = malloc(long_max + 1)) != NULL)
  161.    {
  162.        fflush(stdout);
  163.            //en caso de que no haya bloques de memoria
  164.            if (fgets(nombre, long_max, stdin) == NULL)
  165.            {
  166.                free(nombre);
  167.                nombre = NULL;
  168.            }
  169.            else
  170.            {
  171.                size_t i;
  172.                for (i = 0; nombre[i] != '\0' && nombre[i] != '\n'; i++);
  173.                    if (nombre[i] == '\n')
  174.                    {
  175.                        nombre[i] = '\0';
  176.                    }
  177.                    else
  178.                    {
  179.                    int ch;
  180.                    while ((ch = getchar()) != EOF && ch != '\n');
  181.                    }
  182.            }
  183.  }
  184.  
  185.  return nombre;
  186. }
  187.  
  188. /*Funcion: input_error_conteo
  189.   Proposito: Solo permte dos opciones D = derecha, I = izquierda.*/
  190. char input_error_conteo()
  191. {
  192.    char direccion='\0';
  193.    scanf("%c",&direccion);
  194.    direccion = toupper(direccion);
  195.        while(direccion!='D'&&direccion!='I') //Error
  196.            {
  197.                printf("\nDato no valido, intenta de nuevo: ");
  198.                direccion = getche();
  199.                direccion = toupper(direccion);
  200.            }
  201.    while(getchar()!='\n');
  202.    return direccion;
  203. }
  204.  
  205. /*Funcion: input_error
  206.   Proposito: Valida que los datos de entrada del usuario sean numeros, evita que se procesen letras o signos.*/
  207. int input_error_num_jugadores()
  208. {
  209.    int respuesta;
  210.    char si_no;
  211.    while((scanf("%d",&respuesta) != 1)||respuesta<2||respuesta>50) //en caso de ñ o datos raros.
  212.        {
  213.            while (getchar() != '\n');
  214.            if(respuesta==1)
  215.            {
  216.                printf("\n\nAl menos debe haber 2 jugadores: ");
  217.            }
  218.            else if(respuesta<1)
  219.            {
  220.                printf ("\n\nDato no valido intenta de nuevo: ");
  221.            }
  222.            else
  223.            {
  224.                printf("\n\nEl juego no permite mas de 50 jugadores: ");
  225.            }
  226.        }
  227.    return respuesta;
  228. }
  229.  
  230. /*Funcion: input_mayor_lista
  231.   Proposito: Valida que los datos de entrada del usuario sean numeros, evita que se procesen letras, signos o
  232.              numeros negativos, se usa cuando se pregunta por el jugador a partir del cual se iniciara el conteo.*/
  233. int input_mayor_lista(int jugadores)
  234. {
  235.    int respuesta;
  236.    while((scanf("%d",&respuesta) != 1)||respuesta<=0||respuesta>jugadores) //en caso de ñ y datos raros.
  237.        {
  238.            while (getchar() != '\n');
  239.            printf ("\nDato no valido intenta de nuevo: ");
  240.        }
  241.    return respuesta;
  242. }
  243.  
  244. /*Funcion:input_error_sino
  245.   Proposito: Valida que la respuesta sea el caracter S o N,
  246.   se usa en la ultima pregunta para volver a correr el programa */
  247. char input_error_sino()
  248. {
  249.    char respuesta;
  250.    respuesta = getche();
  251.    respuesta = toupper(respuesta);
  252.    printf("\n\n");
  253.        while(respuesta!='S'&&respuesta!='N') //Error si teclea otra cosa
  254.            {
  255.                printf("Opcion invalida, intenta de nuevo: ");
  256.                respuesta = getche();
  257.                puts("");
  258.                respuesta = toupper(respuesta);
  259.            }//Fin mensaje error
  260.    return (respuesta);
  261. }
  262.  
  263. void pausa()
  264. {
  265.    int delay;
  266.    for(delay=0;delay<181111100;delay++); //espacio entre impresiones
  267.  
  268. }
  269.  
  270. void pin_pon_papas()
  271. {
  272.    printf("PIN ");
  273.    pausa();
  274.    printf("PON ");
  275.    pausa();
  276.    printf("PAPAS!");
  277.    pausa();
  278. }
  279.  
  280.  
« Última modificación: 16 Octubre 2013, 09:33 am por Eternal Idol » En línea

Páginas: [1] Ir Arriba Respuesta Imprimir 

Ir a:  

WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines