Problema con Palindromos en C

[CNerd]

Buenos dias, soy nuevo en el foro, tengo un problema con mi programa, quisiera poder escribir una palabra y ver si es un palindromo o no. Implementando TADs, mas especificamente pilas.

Ahi va mi programa, no funciona de cualquier forma, cualquier otra solucion sera bienvenida, pero en lo posible que sea en TADs.

Código [Seleccionar] Expandir

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

typedef struct nodo{
       char palindrome;
       struct nodo *siguiente;
       } tipoNodo;

typedef tipoNodo *pNodo;
typedef tipoNodo *Pila;

void Push(Pila *l, char v);
char Pop(Pila *l);
void imprimePila(Pila *pila);


void Push(Pila *pila, char v)
{
    pNodo nuevo;
    nuevo = (pNodo)malloc(sizeof(tipoNodo));
    nuevo->palindrome = v;
    nuevo->siguiente = *pila;
    *pila = nuevo;
}

char Pop(Pila *pila)
{
   pNodo nodo;
   char v;
   nodo = *pila;
   if(!nodo) return 0;
   *pila = nodo->siguiente;

   v = nodo->palindrome;

   free(nodo);
   return v;
}

void imprimePila(Pila *pila)
{
    pNodo nuevo;
    if(nuevo==NULL)
    {
        printf("La pila esta vacia\n");
    }
    else
    {
        printf("La pila es: \n");
        while(nuevo!=NULL)
        {

             printf("%s -> ", nuevo->palindrome);

             nuevo = nuevo->siguiente;
        }
        printf("NULL\n\n");
    }
}


int main()
{
   int i;
   Pila pila = NULL;
   char p[10];
   printf("Ingrese palabra: \n");
   scanf("%c", &p);
   int x;
   x = strlen(p);
for ( i = 0; i < x; i++ )
{
   printf ( "%c", pila->palindrome );
   Pop ( &pila );
}
   imprimePila(&pila);


   return 0;
}




Aca tengo otro que hice anteriormente pero este funciona agregando los nombres para ver como funcionan las pilas, mi idea es que deberia poner 1 scanf en el  main para poder leer la palabra y luego que ingresen las letras, de ser impar (porque las pares no pueden ser palindromos) y si la letra central funciona de espejo es un palindromo, o sea cuando entra la mitad de la palabra a la pila deberia salir la misma mitad funcionando la letra central como un pivote.
Aca esta el codigo al que le podria cambiar algo del main

Código [Seleccionar] Expandir

#include<stdio.h>
typedef struct
{
    struct elemento* siguiente;
    char* nombre;
}nodo_T;

nodo_T* ultimo=NULL;

void push(nodo_T* elemento)
{
    elemento->siguiente=NULL;
    if(ultimo==NULL)
    {
        ultimo=elemento;
    }
    else{
     elemento->siguiente=ultimo;
    ultimo=elemento;
    }
}
nodo_T* pop()
{
    if(ultimo==NULL)
    {
        return NULL;
    }
    nodo_T* elemento_retorno=ultimo;
    ultimo=elemento_retorno->siguiente;
    return elemento_retorno;
}
int main()
{
    nodo_T* primero = malloc(sizeof(nodo_T));
    nodo_T* segundo = malloc(sizeof(nodo_T));
    nodo_T* tercero = malloc(sizeof(nodo_T));
    nodo_T* cuarto = malloc(sizeof(nodo_T));
    primero->nombre="Palabra 1";
    segundo->nombre="Palabra 2";
    tercero->nombre="Palabra 3";
    cuarto->nombre="Palabra 4";
    push(primero);
    push(segundo);
    push(tercero);
    push(cuarto);

    nodo_T* i=pop();

    while(i!=NULL)
    {
        printf("\n%s",i->nombre);
        i=pop();
    }
    return 0;
}



[eferion]

Se me ocurren dos opciones:

1. usar una pila y una cola:

cada letra la introduces en ambos contenedores a la vez. Una vez tienes la palabra completa empiezas a asacar elementos de la pila y de la cola... si coinciden hasta el final es palíndromo.

Nota: recuerda que una pila es de tipo LIFO y una cola FIFO.

2. Con una pila y un string:

Guardas la palabra en un string y en la pila... después vas comparando el string desde el principio hasta el final con lo que vas sacando de la pila... si coinciden hasta el final es palíndromo.

Por cierto, respecto a esta afirmación que has hecho:

... de ser impar (porque las pares no pueden ser palindromos) ...

Palíndromos de 4 letras:

erre
allá
elle
alla

Palíndromos de 6 letras:

narran
rallar
selles

Palíndromos de 8 letras:

acurruca