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:  

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.

J_PTR add_to_list(char *name, J_PTR prev_rec)
{
    J_PTR new_rec = NULL;
    new_rec = (J_PTR) malloc(sizeof(JUGADOR)); // Crear jugador
    if(!new_rec)
    {   //Validacion de malloc
        printf("Error al reservar memoria");
        exit(1);
    }
    new_rec->nombre = name;
    new_rec->next = NULL;
    new_rec->prev = NULL;
    if(prev_rec) //Si hay un elemento antes
    {
        prev_rec->next = new_rec;
        new_rec->prev = prev_rec;
    }
    return(new_rec);
}

---

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. 

#include <stdio.h>
#include <stdlib.h>
#define PINPONPAPAS 6
struct persona
{
    char *nombre;
    struct persona *next;
    struct persona *prev;
};
typedef struct persona JUGADOR;
 
typedef JUGADOR *J_PTR;
        J_PTR first = NULL;
        J_PTR last = NULL;
 
char *input_nombre(size_t long_max);
J_PTR add_to_list(char *ch, J_PTR prev_rec);
char input_error_conteo();
int input_error_num_jugadores();
int input_mayor_lista(int jugadores);
char input_error_sino();
void pausa();
void pin_pon_papas();
 
int main()
{
    int i,num_jugadores;
    int inicio_conteo, pin; //Numero de jugador para empezar el juego y numero de veces que se va a contar respectivamente
    char direccion_conteo; // Las opciones son D = derecha, I = izquierda
    char bucle ='X'; //para repetir el programa
    char *nombre;
    J_PTR j_addr = NULL; //Apunta a los elementos creados en la funcion add_to_list()
    J_PTR j_aux = NULL; //Este apuntador se usa cuando se van eliminando los jugadores cada 6 conteos
    do
    {
        system("CLS");
    pin_pon_papas();
    printf("\n\nEnlista a los jugadores y elimina uno a uno para terminar con un ganador\n");
    printf("\n\nEscribe el numero de jugadores: ");
    num_jugadores = input_error_num_jugadores();
        while(getchar()!='\n'); //limpiar buffer
    printf("\nAhora cada uno de sus nombres\n\n");
        for(i=0;i<num_jugadores;i++)
        {
            printf("Jugador %d: ",i+1);
            nombre = input_nombre(30);//Se crean nombres, el parametro es la longitud maxima de texto
            j_addr = add_to_list(nombre, j_addr); /*la funcion devuelve new_rec*/
                if(i==0)
                {
                    first = j_addr;
                }
            last = j_addr; //se recorre al ultimo jugador tecleado.
            puts("");
        }
    first->prev = last;//cierre de
    last->next = first;//lista circular
    j_addr = first; //Recorrer apuntador al primer elemento creado para imprimir la lista de jugadores.
    printf("\nEstos son los participantes:\n\n");
        for(i=0;i<num_jugadores;i++)
        {
            printf("%2d: %s\n",i+1,j_addr->nombre);
//    printf("Nombre:%s\nDireccion jugador:%p\nprev: %p  \nnext: %p\n",nombre,(void *)j_addr,(void *)j_addr->prev,(void *)j_addr->next);
            j_addr = j_addr->next;
        }
    printf("\nEscribe el numero de jugador con el que quieres iniciar el conteo: ");
    inicio_conteo = input_mayor_lista(num_jugadores);
        while(getchar()!='\n'); //key buffer
    j_addr = first;
    for(i=0;i<inicio_conteo-1;i++)
    {
        j_addr = j_addr->next;
    }
    printf("\n\nHas elegido a %s !\n\n",j_addr->nombre);
    printf("Quieres iniciar el conteo hacia la derecha o izquierda? (D/I)");
    direccion_conteo = input_error_conteo(); //validar dato tecleado
    puts("\nIniciando conteo...\n");
        if(direccion_conteo=='D')
        {
            for(pin=0;pin<num_jugadores-1;pin++)
            {
                    for(i=0;i<PINPONPAPAS;i++)
                    {   //Ubicar al jugador a eliminar
                        j_addr = j_addr->next;
                    }
                pin_pon_papas();
                printf(", sale %s\n\n",j_addr->nombre);
                j_aux = j_addr->next;
                j_aux->prev = j_addr->prev;
                j_aux = j_addr->prev;
                j_aux->next = j_addr->next;
                j_aux = j_addr->prev;
                free(j_addr);
                j_addr = j_aux;
                pausa();
            }
        }
        else
        {
            for(pin=0;pin<num_jugadores-1;pin++)
            {
                    for(i=0;i<PINPONPAPAS;i++)
                    {   //Ubicar al jugador a eliminar
                        j_addr = j_addr->prev;
                    }
                pin_pon_papas();
                printf(", sale %s\n\n",j_addr->nombre);
                j_aux = j_addr->next;
                j_aux->prev = j_addr->prev;
                j_aux = j_addr->prev;
                j_aux->next = j_addr->next;
                j_aux = j_addr->next;
                free(j_addr);
                j_addr = j_aux;
                pausa();
            }
        }
    printf("\nEl ultimo jugador en pie es %s!\n",j_addr->nombre);
    printf("\n\nQuieres jugar de nuevo? ( S/N ): ");
        bucle = input_error_sino();
        first = NULL;
        last = NULL;
        free(j_addr);
        j_aux = NULL;
        j_addr = NULL;
        i=0;
 
    }while(bucle=='S');
    return 0;
}
 
/*Funcion: J_PTR add_to_list()
  Proposito: Crear un bloque en memoria para el jugador y asigna los apuntadores a siguiente y previo*/
J_PTR add_to_list(char *name, J_PTR prev_rec)
{
    J_PTR new_rec = NULL;
    new_rec = (J_PTR) malloc(sizeof(JUGADOR)); // Crear jugador
    if(!new_rec)
    {   //Validacion de malloc
        printf("Error al reservar memoria");
        exit(1);
    }
    new_rec->nombre = name;
    new_rec->next = NULL;
    new_rec->prev = NULL;
    if(prev_rec) //Si hay un elemento antes
    {
        prev_rec->next = new_rec;
        new_rec->prev = prev_rec;
    }   //aqui solamente se crea la lista doble, en main()es donde se cierra la lista
    return(new_rec);
}
 
/*Funcion: input_nombre(size_t long_max)
  Proposito: Funcion para entrada de datos, primero reservo el espacio en memoria de longitud definida en el
             parametro long max, despues sigue la entrada de datos.*/
char *input_nombre(size_t long_max)
{
    char *nombre =NULL;
 
    if ((nombre = malloc(long_max + 1)) != NULL)
    {
        fflush(stdout);
            //en caso de que no haya bloques de memoria
            if (fgets(nombre, long_max, stdin) == NULL)
            {
                free(nombre);
                nombre = NULL;
            }
            else
            {
                size_t i;
                for (i = 0; nombre[i] != '\0' && nombre[i] != '\n'; i++);
                    if (nombre[i] == '\n')
                    {
                        nombre[i] = '\0';
                    }
                    else
                    {
                    int ch;
                    while ((ch = getchar()) != EOF && ch != '\n');
                    }
            }
  }
 
  return nombre;
}
 
/*Funcion: input_error_conteo
  Proposito: Solo permte dos opciones D = derecha, I = izquierda.*/
char input_error_conteo()
{
    char direccion='\0';
    scanf("%c",&direccion);
    direccion = toupper(direccion);
        while(direccion!='D'&&direccion!='I') //Error
            {
                printf("\nDato no valido, intenta de nuevo: ");
                direccion = getche();
                direccion = toupper(direccion);
            }
    while(getchar()!='\n');
    return direccion;
}
 
/*Funcion: input_error
  Proposito: Valida que los datos de entrada del usuario sean numeros, evita que se procesen letras o signos.*/
int input_error_num_jugadores()
{
    int respuesta;
    char si_no;
    while((scanf("%d",&respuesta) != 1)||respuesta<2||respuesta>50) //en caso de ñ o datos raros.
        {
            while (getchar() != '\n');
            if(respuesta==1)
            {
                printf("\n\nAl menos debe haber 2 jugadores: ");
            }
            else if(respuesta<1)
            {
                printf ("\n\nDato no valido intenta de nuevo: ");
            }
            else
            {
                printf("\n\nEl juego no permite mas de 50 jugadores: ");
            }
        }
    return respuesta;
}
 
/*Funcion: input_mayor_lista
  Proposito: Valida que los datos de entrada del usuario sean numeros, evita que se procesen letras, signos o
             numeros negativos, se usa cuando se pregunta por el jugador a partir del cual se iniciara el conteo.*/
int input_mayor_lista(int jugadores)
{
    int respuesta;
    while((scanf("%d",&respuesta) != 1)||respuesta<=0||respuesta>jugadores) //en caso de ñ y datos raros.
        {
            while (getchar() != '\n');
            printf ("\nDato no valido intenta de nuevo: ");
        }
    return respuesta;
}
 
/*Funcion:input_error_sino
  Proposito: Valida que la respuesta sea el caracter S o N,
  se usa en la ultima pregunta para volver a correr el programa */
char input_error_sino()
{
    char respuesta;
    respuesta = getche();
    respuesta = toupper(respuesta);
    printf("\n\n");
        while(respuesta!='S'&&respuesta!='N') //Error si teclea otra cosa
            {
                printf("Opcion invalida, intenta de nuevo: ");
                respuesta = getche();
                puts("");
                respuesta = toupper(respuesta);
            }//Fin mensaje error
    return (respuesta);
}
 
void pausa()
{
    int delay;
    for(delay=0;delay<181111100;delay++); //espacio entre impresiones
 
}
 
void pin_pon_papas()
{
    printf("PIN ");
    pausa();
    printf("PON ");
    pausa();
    printf("PAPAS!");
    pausa();
}
 
 

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  

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

#include <stdio.h>
#include <stdlib.h>
struct persona
{
    char *nombre;
    struct persona *next;
    struct persona *prev;
};
typedef struct persona JUGADOR;
 
typedef JUGADOR *J_PTR;
        J_PTR first = NULL;
        J_PTR last = NULL;
 
J_PTR add_to_list(char *ch, J_PTR prev_rec,J_PTR next_rec);
 
int main()
{
    int i,num_jugadores;
    char *nombre;
    J_PTR j_addr = NULL;
    printf("Escribe el numero de jugadores: ");
    scanf("%d",&num_jugadores);
    while(getchar()!='\n');
    printf("\nAhora cada uno de sus nombres\n\n");
    for(i=0;i<num_jugadores;i++)
    {
        printf("Jugador %d: ",i+1);
        scanf("%s",&nombre);
        j_addr = add_to_list(nombre, j_addr, first); /*la funcion devuelve new_rec*/
            if(i==0)
            {
                first = j_addr;
            }
        last = j_addr;
        last->next = first;
 
            printf("Nombre:%s\nprev: %p  \nnext: %p\n",nombre,(void *)j_addr->prev,(void *)j_addr->next);
 
        puts("\n");
    }
}
 
J_PTR add_to_list(char *name, J_PTR prev_rec,J_PTR next_rec)
{
    J_PTR new_rec = NULL;
    new_rec = (J_PTR) malloc(sizeof(JUGADOR)); // Crear jugador
    if(!new_rec)
    {   //Validacion de malloc
        printf("Error al reservar memoria");
        exit(1);
    }
    new_rec->nombre = name;
    new_rec->next = NULL;
    new_rec->prev = NULL;
    if(prev_rec) //Si hay un elemento antes
    {
        prev_rec->next = new_rec;
        new_rec->prev = prev_rec;
    }
    new_rec->next = next_rec;
    return(new_rec);
}
 

y que pasa si resumo la funcion a esto:

#include <stdio.h>
#include <stdlib.h>
 
char *input_nombre();
 
int main(void)
{
    char *nombre;
    nombre = input_nombre();
    printf("Hola %s\n", nombre);
    return EXIT_SUCCESS;
}
 
char *input_nombre()
{
    char *nombre;
    printf("Indica el nombre: ");
    fgets(nombre, 30, stdin);
    return nombre;
}
 

 Al compilar corre y da el nombre, no va a validar el tamaño pero me di cuenta que con fgets solo imprime 30 caracteres, el resto no se sobreescribe en memoria o si? 

Hola, tengo una función que pide el nombre de una persona, quiero que regrese el arreglo de caracteres para que en main se haga uso del nombre tecleado. Hay un tema donde usan apuntadores, he tratado de adaptarlo a mi funcion pero me da error, algo estoy haciendo mal:

/*Que debe regresar?*/ input_nombre()
{
    char nombre[20];
    int longitud=0;
    do
    {
        printf("Persona 1: ");
        scanf("%s",&nombre);
            while (getchar() != '\n');
        longitud = strlen(nombre);
        if(longitud>20)
        {
            printf("\nError, el nombre no puede ser mayor a 20 caracteres\n\n");
        }
 
    }while(longitud>20);
    return //El nombre de la persona
}

Eventualmente voy a guardar el nombre en una estructura en su campo nombre[20] 

si, tienes toda la razon, yo estaba pensando en el caso cuando solo hay un elemento, pero en realidad lo que importa es el apuntador a NULL y si solo hay un elemento en automatico apunta a NULL

me he despejado muchas dudas respecto al tema, gracias!

edito:
ya tengo la version final, la funcion que borra los elementos es la adaptación del primero código al segundo 

void borrar_mayores(int natural)
{
    LISTPTR *p;
    LISTPTR aux;
    p=&first;
    if(first->next_rec==NULL)
    {
        if ((*p)->ch> natural)
        { /* Eliminar elemento unico de lista */
            aux = first;
            first = NULL;
            *p = NULL;
            free(aux);
        }
    }
    while (*p != NULL)
    {
        if ((*p)->ch> natural)
        { /* Eliminar actual */
            aux = *p;
            *p = (*p)->next_rec;
            free(aux);
        }
        else /* Siguiente nodo */
        {
            p = &(*p)->next_rec;
        }
 
    }
}

edito:
he reescrito a una nueva version, la finalidad es la misma
el primer código que hice me termino disgustando.

Lo compilé y aparentemente no truena todo corre como debe, me ayudan a detectar posibles fallas?

#include <stdio.h>
#include <stdlib.h>
struct lista
{
    char ch;
    struct lista *next_rec;
};
typedef struct lista LIST;
typedef LIST *LISTPTR;
 
LISTPTR add_to_list( char, LISTPTR );
void show_list(void);
void free_memory_list(void);
void borrar_mayores(int respuesta,int natural);
 
LISTPTR first = NULL;
 
int main(void)
{
    LISTPTR rec_addr;
    int i=0;
    int respuesta, natural;
    rec_addr = add_to_list(rand()%100+1, (LISTPTR)NULL);
    first = rec_addr;
    puts("Numeros aleatorios\n");
    //Imprimir menu principal
    //Input total de datos
    respuesta = input_error();
    while(i++<(respuesta-1))
    {
        rec_addr = add_to_list(rand()%100+1,rec_addr);
    }
    show_list();
 
    //Numero natural
    printf("Escribe un natural menor a 100: ");
    natural = input_error();
    rec_addr = first;
    borrar_mayores(respuesta,natural);
    show_list();
    getch();
    free_memory_list();
    return(0);
    //completar funcion main
}
 
LISTPTR add_to_list(char ch, LISTPTR prev_rec)
{
    LISTPTR new_rec = NULL;
    new_rec = (LISTPTR) malloc(sizeof(LIST));
    if(!new_rec)
    {
        printf("Error al reservar memoria");
        exit(1);
    }
    new_rec->ch = ch;
    new_rec->next_rec = NULL;
    if(prev_rec)
    {
        prev_rec->next_rec = new_rec;
    }
    return(new_rec);
}
 
void borrar_mayores(int respuesta,int natural)
{
    LISTPTR new_rec = first;
    LISTPTR aux = new_rec;
    if(new_rec->next_rec==NULL)
    {
        if(new_rec->ch>natural)
        {
            free(new_rec);
            first=NULL;
            printf("\n\nLa nueva lista no tiene datos. ");
            getch();
            exit(0);
        }
    }
    while(new_rec==first)
    {
        if(new_rec->ch>natural)
        {
            first = new_rec->next_rec;
            free(new_rec);
            new_rec = first;
            aux = first;
        }
        else
        {
            aux = new_rec;
            new_rec = new_rec->next_rec;
        }
    }
    while(new_rec->next_rec!=NULL)
    {
 
        if(new_rec->ch>natural)
        {
            aux->next_rec=new_rec->next_rec;
            free(new_rec);
            new_rec = aux->next_rec;
 
        }
        else
        {
            aux = new_rec;
            new_rec = new_rec->next_rec;
        }
    }
}
 
void show_list()
{
    LISTPTR cur_ptr;
    int counter = 1;
    printf("Rec addr  Position  Data  Next rec addr\n\n");
    cur_ptr = first;
    while(cur_ptr)
    {
        printf("  %x   ",cur_ptr);
        printf("     %2i       %d",counter++,cur_ptr->ch);
        printf("      %x   \n",cur_ptr->next_rec);
        cur_ptr = cur_ptr->next_rec;
    }
}
 
void free_memory_list()
{
    LISTPTR cur_ptr,next_rec;
    cur_ptr = first;
    while (cur_ptr)
    {
        next_rec = cur_ptr->next_rec;
        free(cur_ptr);
        cur_ptr = next_rec;
    }
}
 
int input_error(void)
{
    int respuesta;
    char key_buff[50];
    printf("Escribe el numero de datos a generar: ");
    while((scanf("%d",&respuesta) != 1)||respuesta==0) //en caso de ñ
        {
            while (getchar() != '\n');
            printf ("\nDato no valido intenta de nuevo: ");
        }
    gets(key_buff);
    return respuesta;
}
 

Saludos!

Entiendo, la cuestion es que debo trabajar con memoria dinamica porque es el tema que estamos viendo, el programa corre bien al generar e imprimir los numeros pero despues de preguntar por el numero natural (linea 53) truena. Lo que quiero hacer es eliminar datos mayores .

typedef struct st_num //Plantilla para numero aleatorio.
{
   int rand_num;
   struct st_num *ptr_next;
}st_num;
 
struct
{
   st_num *head;
   st_num *last;
 
}fila;
 
void menu_principal();
void menu_principal()
{
    system("CLS");
    puts("Generador de numeros aleatorios\n\n");
    printf("Escribe el numero de datos a generar: ");
}
 
int main()
{
   int i;
   int respuesta_num; //Dato tecleado por usuario
   char key_buff[40];
   st_num *nodo;
   st_num *nodo_aux;
   menu_principal(); //Borrar pantalla y desplegar texto
   scanf("%d",&respuesta_num);
   gets(key_buff); //limpiar buffer
   fila.head = NULL;
   fila.last = NULL;
 
   for(i=0;i<respuesta_num;i++)
   {
       nodo = (st_num *) malloc(sizeof(st_num)); //Se crea bloque
       nodo->rand_num = rand()%100+1;           //Se asigna numero
           if(i==0)                             //Condicion para primer elemento
           {
               fila.head = nodo;
               fila.last = nodo;
               nodo->ptr_next = NULL;
           }
           if(nodo->ptr_next != NULL)
           {
               nodo ->ptr_next = fila.head;
           }
       fila.head = nodo;
       printf("%d\n",nodo->rand_num);
   }
   printf("Ahora escribe un numero natural menor a 100: ");
   scanf("%d",&respuesta_num);
   gets(key_buff);
   while(nodo->ptr_next!=NULL)
   {
       if((nodo->rand_num>respuesta_num)&&nodo==fila.head)
       {
           fila.head = (fila.head)->ptr_next;
           free(nodo);
           nodo = fila.head;
       }
       else if(nodo->rand_num>respuesta_num)
       {
           nodo_aux = nodo->ptr_next;
           free(nodo);
           nodo = nodo_aux;
       }
       nodo = nodo->ptr_next;
   }
    //Imprimir nueva lista...
}
 

Como debo hacer para poder usar el operador flecha? no sirve con estructuras?

tendria que declarar:

typedef fila *nodo NODO

y entonces puedo usar

NODO->head;

he cambiado los operadores por puntos y compila aunque al terminar el programa regresa el numero que ha tecleado el usuario.

Hola, estoy construyendo una lista de numeros pero al compilar me da error por el operador ->, alguien nota el error?

#include <stdio.h>
#include <stdlib.h>
typedef struct st_num //Plantilla para numero aleatorio.
{
    int rand_num;
    struct st_num *ptr_next;
}st_num;
 
typedef struct
{
    st_num *head;
    st_num *last;
 
}fila;
 
int main()
{
    int i;
    int respuesta_num; //Dato tecleado por usuario
    char key_buff[40];
    st_num *nodo;
    menu_principal(); //Borrar pantalla y desplegar texto
    scanf("%d",&respuesta_num);
    gets(key_buff); //limpiar buffer
    fila->head = NULL;
    fila->last = NULL;
 
    for(i=0;i<respuesta_num;i++)
    {
        nodo = (st_num *) malloc(sizeof(st_num)); //Direccion de bloque creado
        nodo->rand_num = rand()%100+1;
            if(i=0) //Edicion de primer elemento
            {
                fila->head = nodo;
                fila->last = nodo;
                nodo->ptr_next = NULL;
            }
            if(nodo->ptr_next != NULL)
            {
                nodo ->ptr_next = fila->head;
            }
        fila->head = nodo;
        printf("%d\n",nodo->ptr_next);
    }
}