Aplicar eficientemente el principio LIFO para generar soluciones creativas a problemas de ingeniería.
Actividad: Suponga que unos libros están organizados en dos pilas; la primera pila está ordenada ascendentemente por título, y la segunda ordenada descendentemente, por título también. Elabore un programa que fusione ambas pilas en una tercera ordenada descendentemente. NOTA: no debe utilizar más de 3 pilas, pero si puede utilizar como base las funciones y métodos de pila vistos en clase. Por ejemplo, si la pila 1 contiene Como agua para chocolate, el Decamerón, Marianela; y la pila 2 contiene Verónica decide morir, Mi verdad, Cañitas. La pila resultante debe ser

Cañitas, 
Como agua para chocolate,
El Decamerón, 
Marianela 
Mi verdad 
Veronica decide morir

Consideraciones:

El programa debe mostrar el estado de la pila durante el proceso de fusión de las pilas.
La fusión de las pilas debe hacerse respetando el principio LIFO.
El programa debe mostrar el proceso de fusión paso a paso.
Las pilas deben fusionarse después de haberse capturado.
El lenguaje de programación a utilizar es C o Java. 
Evite utilizar variables globales.
El programa debe estar organizado en funciones o métodos.
No se pide que implemente métodos de ordenación, simplemente inserte los elementos de las pilas iniciales en el orden adecuado.
El programa debe repetirse N veces, hasta que el usuario elija la opción de salida.
El programa debe presentar mensajes apropiados.
El programa debe incluir una descripción completa, incluyendo comentarios.

Hola,

Como pide pilas estáticas y no más de 3, la implementación típica es un array fijo con un índice de tope, y las operaciones clásicas de pila (apilar, desapilar, ver la cima):

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

#define MAX 50

typedef struct {
    char datos[MAX][100];
    int tope;
} Pila;

void inicializar(Pila *p) {
    p->tope = -1;
}

int estaVacia(Pila *p) {
    return p->tope == -1;
}

void apilar(Pila *p, const char *valor) {
    p->tope++;
    strcpy(p->datos[p->tope], valor);
}

void desapilar(Pila *p, char *destino) {
    strcpy(destino, p->datos[p->tope]);
    p->tope--;
}

const char *cima(Pila *p) {
    return p->datos[p->tope];
}

void fusionar(Pila *pila1, Pila *pila2, Pila *pila3) {
    char temp[100];

    while (!estaVacia(pila1) && !estaVacia(pila2)) {
        if (strcmp(cima(pila1), cima(pila2)) > 0) {
            desapilar(pila1, temp);
        } else {
            desapilar(pila2, temp);
        }
        apilar(pila3, temp);
        printf("Apilado en pila3: %sn", temp);
    }

    while (!estaVacia(pila1)) {
        desapilar(pila1, temp);
        apilar(pila3, temp);
        printf("Apilado en pila3 (resto pila1): %sn", temp);
    }

    while (!estaVacia(pila2)) {
        desapilar(pila2, temp);
        apilar(pila3, temp);
        printf("Apilado en pila3 (resto pila2): %sn", temp);
    }
}

La idea clave: como las dos pilas de origen ya vienen ordenadas, en cada paso solo necesitas mirar la cima de cada una (no hace falta ver el resto) para saber cuál de las dos toca sacar primero. Eso es justo lo que permite resolverlo con pilas puras, sin arrays ni listas auxiliares: nunca necesitas mirar más allá del elemento de arriba de cada pila.

La comparación strcmp(cima(pila1), cima(pila2)) > 0 es la que decide el orden final. Con tus datos de ejemplo tendrás que probar si necesitas ese > 0 o el < 0 contrario según en qué sentido tengas apiladas pila1 y pila2 exactamente (si el primer elemento que se lee al hacer apilar queda abajo o arriba de la pila influye en el resultado); si el orden te sale al revés de lo que pide el enunciado, es tan sencillo como invertir esa comparación.

Los printf dentro de fusionar son los que cumplen el requisito de mostrar el estado del proceso paso a paso, uno por cada elemento que se mueve.

Un saludo,
David Carrero