Código en C para Verificar Palíndromos con Colas y Pilas: Implementación Paso a Paso

A continuación se presenta un programa en lenguaje C que determina si una palabra es un palíndromo utilizando una cola y una pila, ambas implementadas mediante listas enlazadas dinámicas.

Librerías utilizadas

El programa incluye las siguientes cabeceras:

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

Definición de estructuras

Estructura de datos de la palabra

struct nodop {
    char palabra[15];
};

Nodo de la cola

struct nodo {
    struct nodop pal;
    struct nodo *siguiente;
};

typedef struct nodo *COLA;

Nodo de la pila

struct nodoPILA {
    struct nodop pal2;
    struct nodoPILA *siguiente2;
};

typedef struct nodoPILA *PILA;

Funciones de la cola

Crear cola

void crear(COLA *inicio, COLA *final) {
    (*inicio) = NULL;
    (*final) = NULL;
}

Verificar si la cola está vacía

int vacia(COLA inicio) {
    if (inicio == NULL)
        return 1;
    else
        return 0;
}

Ingresar elemento en la cola

void ingresar(COLA *inicio, COLA *final, char palabra) {
    COLA nuevo;
    nuevo = (COLA) malloc(sizeof(struct nodo));
    nuevo->pal.palabra[0] = palabra;
    nuevo->siguiente = NULL;
    if ((*final) == NULL) {
        (*final) = nuevo;
        (*inicio) = nuevo;
    } else {
        (*final)->siguiente = nuevo;
        (*final) = (*final)->siguiente;
    }
}

Extraer elemento de la cola

char mostrar(COLA *inicio, COLA *final) {
    COLA q;
    char a;
    a = (*inicio)->pal.palabra[0];
    if ((*inicio)->siguiente == NULL) {
        free(*inicio);
        (*inicio) = NULL;
        (*final) = NULL;
    } else {
        q = (*inicio);
        (*inicio) = (*inicio)->siguiente;
        q->siguiente = NULL;
        free(q);
    }
    return a;
}

Funciones de la pila

Crear pila

void crearPILA(PILA *inicio) {
    (*inicio) = NULL;
}

Ingresar elemento en la pila

void ingresarPILA(PILA *inicio, char palabra) {
    PILA nuevo;
    nuevo = (PILA) malloc(sizeof(struct nodoPILA));
    nuevo->pal2.palabra[0] = palabra;
    nuevo->siguiente2 = NULL;
    if ((*inicio) == NULL) {
        (*inicio) = nuevo;
    } else {
        nuevo->siguiente2 = (*inicio);
        (*inicio) = nuevo;
    }
}

Extraer elemento de la pila

char mostrarPILA(PILA *inicio) {
    PILA q;
    char b;
    b = (*inicio)->pal2.palabra[0];
    if ((*inicio)->siguiente2 == NULL) {
        free(*inicio);
        (*inicio) = NULL;
    } else {
        q = (*inicio);
        (*inicio) = (*inicio)->siguiente2;
        q->siguiente2 = NULL;
        free(q);
    }
    return b;
}

Función principal

void main() {
    struct nodop pal;
    COLA inicio;
    COLA final;
    PILA inicio2;
    char a, b;
    int i, e, igual;
    igual = 0;
    i = 0;
    e = 0;
    clrscr();
    crear(&inicio, &final);
    crearPILA(&inicio2);
    printf("ingresar palabra : ");
    gets(pal.palabra);
    e = strlen(pal.palabra);

    do {
        a = pal.palabra[i];
        ingresar(&inicio, &final, a);
        ingresarPILA(&inicio2, a);
        i++;
    } while (i < e);

    while (!vacia(inicio) && igual == 0) {
        a = mostrar(&inicio, &final);
        b = mostrarPILA(&inicio2);
        printf("\na = %c - b = %c", a, b);

        if (a != b)
            igual = 1;
    }

    if (igual == 1)
        printf("\nNo es palindrome");
    else
        printf("\nSi es palindrome");

    getch();
}

Funcionamiento del programa

El algoritmo recorre la palabra ingresada y almacena cada carácter tanto en la cola como en la pila. Luego, extrae los caracteres de ambas estructuras: la cola entrega los caracteres en el orden original (FIFO), mientras que la pila los entrega en orden inverso (LIFO). Si en algún momento los caracteres extraídos no coinciden, la palabra no es un palíndromo; si todos coinciden, sí lo es.

Conclusión

Este ejemplo muestra cómo combinar estructuras de datos dinámicas, como colas y pilas, para resolver problemas clásicos de procesamiento de cadenas en C, como la detección de palíndromos.