Hola..

Tengo un codigo que hice el cual crea y ordena en forma alfabeticamente creciente un lista de caracteres, se pueden insertar elementos a la lista y eliminarlos.

Pero me falta dos puntos para terminar mi programa:

1° tengo que imprimir con una función recursiva la lista ordenada alfabeticamente decreciente, es decir de z-a,.

2° Y hacer una funcion recursiva que al momento que yo ingrese un elemeto que quiero que se busque en la lista me diga cuantos caracteres hay antes y cuantes después del caracter que yo indique.

Aqui esta mi codigo, pero quisiera ver si me ayudan y me pueden decir como hacer estas dos funciones recursivas que me faltan, por favor:

#include <stdio.h>
#include <stdlib.h>
 
struct lista_nodos {
 
       /*Se declara una estructura*/
 
       char valor;
       struct lista_nodos *sigPtr; };
 
       typedef struct lista_nodos LISTA;
       typedef struct lista_nodos *LISTPREVPTR;
       /*Se usa un alias para la estructura lista_nodos*/
 
       void inserta(LISTPREVPTR*, char);
       /*Se declara la función inserta*/
       char elimina (LISTPREVPTR*, char);
       /*Se declara la función elimina*/
       int estavacia (LISTPREVPTR);
       /*Se declara la función estavacia*/
       void imprime (LISTPREVPTR);
       /*Se declara la función imprime*/
       void menu (void);
       /*Se declara la funcion menu*/
 
       main(){
 
       LISTPREVPTR inicioPtr = NULL;
       int avanza, selec;
       char dato;
       printf("\n\n%s\n\n","<Un programa que construye listas dinamicas>");
       menu();
       /*Se manda llamar a la función menu*/
       printf("\n%s","\n\nLa opción seleccionada es: ");
       scanf("%d",&selec);
       /*Se lee la función que elige el usuario*/
 
       while(selec != 3){
       /*Cuando la opción elegida por el usuario sea distinta de 1, 2 o 3 
       se despliega nuevamente el menu*/
 
       switch(selec){
       /*Se definen las acciones a realizar conforme a la opción que elija
       el usuario*/
 
       case 1:
 
       printf("\n%s","Deme un caracter: ");
       scanf("\n%c", &dato);
       inserta(&inicioPtr, dato);
       /*Se manda llamar a la funcón inserta*/
       imprime(inicioPtr);
       /*Se manda llamar a la función inicio*/
       break;
 
       case 2:
 
       if(!estavacia(inicioPtr)){
 
       printf("\n%s","El caracter a eliminar es: ");
       scanf("\n%c",&dato);
 
       if(elimina(&inicioPtr, dato)){
       /*Se manda llamar a la función elimina*/
 
       printf("\n%s%c%s\n\a\a","El caracter: ",dato,"fue eliminado de la lista");
       imprime(inicioPtr);
       /*Se manda llamar a la función imprime*/
       }
       else
       /*En caso de no encontrarse el caracter se entra al else*/
 
    printf("\n%s%c%s\n\a","El caracter: ",dato,"no fue encontrado en la lista");
    }
 
       else
       /*La ultima opcion que puede ocurrir al momento de eliminar un carcter 
       se presenta en este else*/
       printf("\a\n\t%s\n\a","La lista esta vacia");
       break;
 
       default:
       /*En caso de no ocurrir nada de lo anterior se lanzara en pantalla 
       lo siguiente*/
 
       printf("\n%s\n","La selección es incorrecta");
       menu();
       /*Se despliega el menu*/
       break;
       }
 
       menu();
       printf("\n%s","La opcion seleccionada es: ");
       scanf("%d", &selec);
       };
 
       printf("\n\n%s","Hasta pronto");
       scanf("%d",&avanza);
       return 0;
       }
 
       void menu(void){
       /*Se define la función menu*/
 
       printf("\n\nSeleccione una opcion: ");
       printf("\n\n1.-Insertar un elemento en la lista");
       printf("\n\n2.-Eliminar un elemento en la lista");
       printf("\n\n3.-Salir del programa");
       }
 
       void inserta(LISTPREVPTR*aPtr, char datoin){
       /*Se define la función inserta*/
       LISTPREVPTR datnvoPtr, datprevPtr, datactPtr, lista_nodos;
       /*Se declaran apuntadores que sean del tipo LISTPREVPTR*/
       datnvoPtr=(LISTPREVPTR)malloc(sizeof(lista_nodos));
       /*evalúa a sizeof (lista_nodos) para determinar el tamaño de una 
       estructura del tipo lista_nodos, para asignar una nueva área en 
       memoria, y para almacenar un apuntador a la memoria asignada a la
        variable datnvoPtr */
 
       if(datnvoPtr != NULL){
       /*En caso de que datnvoPtr sea distinto de NULL, se realizara lo 
       siguiente*/
 
       datnvoPtr->valor=datoin;
       datnvoPtr->sigPtr=NULL;
       datprevPtr=NULL;
       datactPtr=*aPtr;
 
       while(datactPtr != NULL&&datoin>datactPtr->valor){
 
       datprevPtr=datactPtr;
       datactPtr=datactPtr->sigPtr;
       };
 
       if(datprevPtr==NULL){
       /*Se compara datprevPtr con NULL y se continuara si son iguales*/
       datnvoPtr->sigPtr=*aPtr;
       *aPtr=datnvoPtr;
       }
 
       else{
       /*Si datprevPtr es distinto de NULL se entrara al else*/
       datprevPtr->sigPtr=datnvoPtr;
       datprevPtr->sigPtr=datactPtr;
       }
       }
 
       else
       /*En caso de no haber ocurrido ninguna de las anteriores se entrara 
       a este else*/
       printf("\n%s%c%s\n%s\a\a\a\a","El caracter: ",datoin,"no fue insertado",
       "memoria insuficiente\n\n");
       }
 
       char elimina(LISTPREVPTR*bPtr, char datoele){
       /*Se define la función elimina*/
 
       LISTPREVPTR datempPtr, datprevPtr, datactPtr;
       /*Se declaran apuntadores que sean dell tipo LISTPREVPTR*/
 
       if(datoele==(*bPtr)->valor){
       datempPtr=*bPtr;
       *bPtr=(*bPtr)->sigPtr;
       free(datempPtr);
       /*Se liberara memoria de datempPtr*/
       return datoele;
       }
 
       else{
       datprevPtr=*bPtr;
       datactPtr=(*bPtr)->sigPtr;
 
       while(datactPtr!=NULL&&datactPtr->valor!=datoele){
       datprevPtr=datactPtr;
       datactPtr=datactPtr->sigPtr;
       };
 
       if(datactPtr!=NULL){
       datempPtr=datactPtr;
       datprevPtr->sigPtr=datactPtr->sigPtr;
       free(datempPtr);
       /*Se liberara memoria de datempPtr*/
       return datoele;
       }
       }
       return '\0';
       }
 
       int estavacia(LISTPREVPTR cPtr){
       /*Se define la función estavacia*/
 
       return(cPtr==NULL);
       }
 
       void imprime(LISTPREVPTR dPtr){
       /*Se define la función imprime*/
 
       if(dPtr==NULL){
       /*En casao de que dPtr no este inicializado se imprimira lo de abajo*/
 
       printf("\a\n\t%s","La lista esta vacia\n\n");
       printf("NULL \n\n");
       }
 
       else{
       /*Cuando dPtr tenga valor se mostrara la lista*/
       printf("\n\t%s","La lista es: ");
       while(dPtr!=NULL){
       /*Solo cuando dPtr sea distitno de NULL se hara la impresión que aparece
       abajo*/
       printf("%c--->",dPtr->valor);
       dPtr=dPtr->sigPtr;
       }
       printf("\n");
       }
       }

Hola, gracias por responder y ayudarme ... mi duda con lo que estas diciendo y que ya tenia por eso no he podido terminar mi programa es como con una función RECURSIVA (al igual que me piden en el primer punto) hacer que me de el numero de caracteres antes y depués del que pida el usuario.

Por ejemplo si el usuario ingreso las letras: h,o,a,c,l t, p, f, k. Entonces la lista apareceria asi:

a--c--f--h--k--l--o--p--t

y si el usuario quiera saber cuantas lestras hay antes y despues de la "k", aqui seria facil porque es numerable pero en caso de que se ingresen mucho más? sé que ese es el chiste de la recursión, pero no entiendo como hacerlo?

Te respondo al MP:

Los datos en el programa aparecen desordenados en el programa porque este ... no los ordena. Para ello necesitas de una función mas que ordene los nodos de la lista. En el caso de listas vinculadas lo usual es MergeSort pero si apenas empiezas es mejor la ordenación al insertar cada nodo.

En cuanto a la función que imprima el numero de caracteres antes de uno dado debes descomponer eso también en funciones: una que imprima el resultado y otra que calcule el numero de caracteres antes del buscado.

Y faltan los requisitos de la(s) funcion(es). Sin eso difícil dar una respuesta exacta.

No voy a hacerlo todo. En el caso del calculo de forma recursiva del numero de elementos antes de uno dado ello se puede realizar de esta forma:

struct nodo {
    char valor;
    struct nodo *sig;
};
 
/* ... */
 
struct nodo *nodos_antes(struct nodo *p, int *num, char ch);
 
/* ... */
 
void imprimir_na(struct nodo *p, char ch)
{
    int num = 0;
 
    if (nodos_antes(p, &num, ch) == NULL)
        puts("El caracter no es parte de la lista");
    else 
        printf("Hay %d elementos antes del caracter %c\n", num, ch);
}
 
struct nodo *nodos_antes(struct nodo *p, int *num, char ch)
{
    if (p == NULL || p->valor == ch)
        return p;
    else {
        ++*num;
        return nodos_antes(p->sig, num, ch);
    }
}

Es una función de soporte "imprimir_na" que imprime el resultado de la otra función recursiva "nodos_antes".

Un saludo

Tienes razón. Lo siento.

El programa tiene errores en la función "insertar", demasiado larga en mi opinión y si tratas de insertar los caracteres 'a', 'b' y 'c' en ese orden todos menos el primero se pierden, revisala.

Un saludo

Me pueden ayudar diciendome como mando llamar esta función en el programa...
Ya me he roto la cabeza y no puedo...