Foro de elhacker.net

Hola

Tengo un ejercicio de parcial en el cual tengo que crear 2 listas. En una lista tengo que poner en cada nodo una palabra y la otra lista esta vacia.
Luego tengo que hacer una función que tome esas 2 listas y si la longitud de la palabra de cada nodo  de la lista1 es mayor que 4, tengo que agregar la palabra de forma ordenada a la otra lista.
Entonces Como ejemplo:

Como condición del ejercicio tengo que crear la funcion filtrar_palabras que reciba las 2 listas y el entero limite. Si el limite es 4, entonces tengo que incluir en la 2da lista, todas las palabras que tengan longitud 4 o superior.

Lista original: "A" , "La", "Grande", "Le", "Puse", "Cuca".

Limite: 4;

Lista Modificada: "Cuca", "Grande", "Puse".

He intentado hacerlo y me tira error de ejecucion y nada. Hice un par de cambios pero lo maximo que llegaba era a ejecutar la lista original y cuando queria filtrar, tiraba error de ejecucion, ahora tira error en todo .. :(

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <conio.h>
 
struct s_nodo
{
    char*txt;
    struct s_nodo*sig;
};
typedef struct s_nodo* t_nodo;
 
void AGREGAR(t_nodo*,char*); 
void filtrar_palabras(t_nodo,t_nodo*,int);
void insertar_ordenado(t_nodo*,char*);
void imprimir(t_nodo);
 
 
int main()
{
    t_nodo original=NULL;
    t_nodo filtrado=NULL;
    int limite=4;
    AGREGAR(&original,"a");
    AGREGAR(&original,"la");
    AGREGAR(&original,"grande");
    AGREGAR(&original,"le");
    AGREGAR(&original,"puse");
    AGREGAR(&original,"Cuca");
 
    printf("\nLa lista original es: \n");
    imprimir(original);
 
    filtrar_palabras(original,&filtrado,limite);
 
    printf("\nLa lista filtrada es: \n");
    imprimir(filtrado);
 
    return 0;
}
 
 
void AGREGAR(t_nodo*nodo,char* palabra)
{
    if(*nodo==NULL)
    {
        *nodo=malloc(sizeof(struct s_nodo));
        strcpy((*nodo)->txt,palabra);
        (*nodo)->sig=NULL;
    }
    else
        AGREGAR(&(*nodo)->sig,palabra);
}
 
 
void filtrar_palabras(t_nodo original,t_nodo*filtrado,int longitud)
{
 
    while(original!=NULL)
    {
        if((strlen(original->txt))>=longitud)
        {
            insertar_ordenado(filtrado,original->txt);
        }
        original=original->sig;
    }
}
 
 
void insertar_ordenado(t_nodo*nodo,char* txt)
{
    t_nodo aux=NULL;
    if(*nodo==NULL || ((strcmp((*nodo)->txt,txt))>0))
    {
        aux=malloc(sizeof(struct s_nodo));
        if(aux==NULL)
        {
            printf("Memoria insuficiente");
        }
        strcpy(aux->txt,txt);
        aux->sig=*nodo;
        *nodo=aux;
    }
    else
    {
        insertar_ordenado(&(*nodo)->sig,txt);
    }
}
 
void imprimir(t_nodo nodo)
{
    while(nodo!=NULL)
    {
        printf(" - %s - ",nodo->txt);
        nodo=nodo->sig;
    }
}

Hay varias cosas: errores que resolver y funciones que optimizar.

El primer error a resolver se encuentra en cuánto generas un nodo nuevo, en cualquiera de las funciones.

La variable txt de la estructura es un puntero, por lo que no puedes copiar directamente el contenido de la cadena, argumento de función, txt a susodicha variable. Primero deberás adquirir el suficiente espacio, mediante malloc, para alojar dicha cadena.

Cuándo crees la función para liberar los nodos de la lista recuerda también liberar las cadenas.

Hola

Modifique la el programa de manera que en vez de cargar directamente la palabra vaya pidiendola.
De esta forma, logro imprimir la lista original, pero no la otra.

Con lo que dijiste tengo dudas en la linea que dice

strcpy(aux->txt,txt);

Nose como modificarlo para que copie el contenido pidiendo memoria como decis.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <conio.h>
 
struct s_nodo
{
    char*txt;
    struct s_nodo*sig;
};
typedef struct s_nodo* t_nodo;
 
char*CARGA();
void AGREGAR(t_nodo*);
t_nodo* filtrar_palabras(t_nodo,t_nodo*,int);
void insertar_ordenado(t_nodo*,char*);
void imprimir(t_nodo);
 
 
int main()
{
    t_nodo original=NULL;
    t_nodo filtrado=NULL;
    int limite;
 
    AGREGAR(&original);
    AGREGAR(&original);
    AGREGAR(&original);
    AGREGAR(&original);
    AGREGAR(&original);
    AGREGAR(&original);
    printf("\nIngrese el limite: ");
    scanf("%d",&limite);
    printf("\nLa lista original es \n");
    imprimir(original);
    filtrado=filtrar_palabras(original,&filtrado,limite);
    printf("\nLa lista filtrada es: \n");
    imprimir(filtrado);
 
 
 
    return 0;
}
 
 
void AGREGAR(t_nodo*nodo)
{
    if(*nodo==NULL)
    {
        *nodo=malloc(sizeof(struct s_nodo));
        (*nodo)->txt=CARGA();
        (*nodo)->sig=NULL;
    }
    else
    {
        AGREGAR(&(*nodo)->sig);
    }
}
 
char*CARGA()
{
    char*texto=NULL;
    char letra;
    int i=0;
    texto=malloc(sizeof(struct s_nodo));
    if(texto==NULL)
    {
        printf("Memoria insuficiente");
        return texto;
    }
 
    letra=getche();
 
    while(letra!='\r')
    {
        *(texto+i)=letra;
        i++;
        texto=realloc(texto,(i+1)*sizeof(char));
        letra=getche();
    }
    *(texto+i)='\0';
    printf("\n");
    return texto;
}
 
 
t_nodo* filtrar_palabras(t_nodo original,t_nodo*filtrado,int longitud)
{
    while(original!=NULL)
    {
        if((strlen(original->txt))>=longitud)
        {
            insertar_ordenado(filtrado,original->txt);
        }
        original=original->sig;
    }
    return filtrado;
}
 
 
void insertar_ordenado(t_nodo*nodo,char* txt)
{
    t_nodo aux=NULL;
    if(*nodo==NULL || ((strcmp((*nodo)->txt,txt))>0))
    {
        aux=malloc(sizeof(struct s_nodo));
        if(aux=NULL)
        {
            printf("Memoria insuficiente");
        }
 
        strcpy(aux->txt,txt);
        aux->sig=*nodo;
        *nodo=aux;
    }
    else
    {
        insertar_ordenado(&(*nodo)->sig,txt);
    }
}
 
void imprimir(t_nodo nodo)
{
    while(nodo!=NULL)
    {
        printf(" - %s - ",nodo->txt);
        nodo=nodo->sig;
    }
}

Obtenida la cadena de texto, por ejemplo supongamos que está en str.