EjercicioPilas1_pract

#include <stdio.h>
#include <stdlib.h>
#include "pila.h"
#include <conio.h>
#include <time.h>
#include <windows.h>

/*
1)1. Cargar desde el teclado una pila DADA con 5 elementos.
Pasar los tres primeros elementos a la pila AUX1 y los dos
restantes a la pila AUX2, ambas pilas inicializadas en vacío.

    Pila DADA, AUX1, AUX2;
    inicpila(&DADA);
    inicpila(&AUX1);
    inicpila(&AUX2);

    leer(&DADA);
    leer(&DADA);
    leer(&DADA);
    leer(&DADA);
    leer(&DADA);

    printf("Pila DADA\n");
    mostrar(&DADA);

    apilar(&AUX1, desapilar(&DADA));
    apilar(&AUX1, desapilar(&DADA));
    apilar(&AUX1, desapilar(&DADA));

    printf("Pila AUX1\n");
    mostrar(&AUX1);


    while(!pilavacia(&DADA)){
        apilar(&AUX2, desapilar(&DADA));

    }

    printf("Pila AUX2\n");
    mostrar(&AUX2);

-------------------------------------------------------------
-------------------------------------------------------------
2)2. Cargar desde el teclado la pila ORIGEN e inicializar en
vacío la pila DESTINO. Pasar todos los elementos de la pila
ORIGEN a la pila DESTINO.

    Pila ORIGEN, DESTINO;
    inicpila(&ORIGEN);
    inicpila(&DESTINO);
    char stop='s';

    do{
        leer(&ORIGEN);
        printf("Si desea continuar presione s \n");
        fflush(stdin);
        scanf("%c", &stop);
    }while (stop== 's');

    printf("Pila ORIGEN\n");
    mostrar(&ORIGEN);

    while(!pilavacia(&ORIGEN)){
        apilar(&DESTINO, desapilar(&ORIGEN));
    }

    printf("Pila ORIGEN despues de desapilarla\n");
    mostrar(&ORIGEN);
    printf("Pila DESTINO\n");
    mostrar(&DESTINO);
-------------------------------------------------------------
-------------------------------------------------------------
3. Cargar desde teclado una pila DADA y pasar a la pila
DISTINTOS todos aquellos elementos distintos al valor 8.

    Pila DADA, DISTINTOS, AUX;
    inicpila(&DADA);
    inicpila(&DISTINTOS);
    inicpila(&AUX);
    char stop='s';

    do{
        leer(&DADA);
        printf("Si desea continuar presione s \n");
        fflush(stdin);
        scanf("%c", &stop);
    }while (stop== 's');

    printf("Pila ORIGEN\n");
    mostrar(&DADA);

    while(!pilavacia(&DADA)){

            if(tope(&DADA)!= 8){
                apilar(&DISTINTOS, desapilar(&DADA));
            }else {
                apilar(&AUX, desapilar(&DADA));

            }
    }
    while(!pilavacia(&AUX)){
        apilar(&DADA, desapilar(&AUX));
    }
    printf("Pila ORIGEN despues de desapilarla\n");
    mostrar(&DADA);

    printf("Pila DISTINTOS A 8\n");
    mostrar(&DISTINTOS);

-------------------------------------------------------------
-------------------------------------------------------------
4. Cargar desde el teclado la pila ORIGEN e inicializar
en vacío la pila DESTINO. Pasar los elementos de la pila
ORIGEN a la pila DESTINO, pero dejándolos en el mismo orden.

    Pila ORIGEN, DESTINO, AUX;
    inicpila(&ORIGEN);
    inicpila(&DESTINO);
    inicpila(&AUX);
    char stop='s';

    do{
        leer(&ORIGEN);
        printf("Si desea continuar presione s \n");
        fflush(stdin);
        scanf("%c", &stop);
    }while (stop== 's');

    printf("Pila ORIGEN\n");
    mostrar(&ORIGEN);

    /////////////////////////////////////////////////////////
    TENGO QUE DESAPILAR ORIGEN Y APILAR EN AUXILIAR: 1 2 3 4
    CUANDO APILO EN AUXILIAR SE APILA: 4 3 2 1
    DESAPILO AUXILIAR Y APILO EN DESTINO: 1 2 3 4
    /////////////////////////////////////////////////////////

    while(!pilavacia(&ORIGEN)){

            apilar(&AUX, desapilar(&ORIGEN));
        }

    while(!pilavacia(&AUX)){
            apilar(&DESTINO, desapilar(&AUX));
    }

    printf("Pila DESTINO: \n");
    mostrar(&DESTINO);
-------------------------------------------------------------
-------------------------------------------------------------
5. Cargar desde el teclado la pila DADA. Invertir la pila
de manera que DADA contenga los elementos cargados
originalmente en ella, pero en orden inverso
    Pila DADA, DESTINO, AUX;
    inicpila(&DADA);
    inicpila(&DESTINO);
    inicpila(&AUX);
    char stop='s';

    do{
        leer(&DADA);
        printf("Si desea continuar presione s \n");
        fflush(stdin);
        scanf("%c", &stop);
    }while (stop== 's');

    printf("Pila DADA\n");
    mostrar(&DADA);

    ////////////////////////////////////////////////////////
    TENGO QUE DESAPILAR DADA Y APILAR EN AUXILIAR: 1 2 3 4
    CUANDO APILO EN AUXILIAR SE APILA: 4 3 2 1
    DESAPILO AUXILIAR Y APILO EN DESTINO: 1 2 3 4
    DESAPILO DESTINO Y APILO EN DADA: 4 3 2 1
    ///////////////////////////////////////////////////////

    while(!pilavacia(&DADA)){

            apilar(&AUX, desapilar(&DADA));
        }

    while(!pilavacia(&AUX)){
            apilar(&DESTINO, desapilar(&AUX));
    }

    while(!pilavacia(&DESTINO)){
            apilar(&DADA, desapilar(&DESTINO));
    }

    printf("Pila DADA: \n");
    mostrar(&DADA);

-------------------------------------------------------------
-------------------------------------------------------------

6. Pasar el primer elemento (tope) de la pila DADA a su última
posición (base), dejando los restantes elementos en el mismo orden.
    Pila DADA, DESTINO, AUX;
    inicpila(&DADA);
    inicpila(&DESTINO);
    inicpila(&AUX);
    char stop='s';

    do{
        leer(&DADA);
        printf("Si desea continuar presione s \n");
        fflush(stdin);
        scanf("%c", &stop);
    }while (stop== 's');

    printf("Pila DADA\n");
    mostrar(&DADA);

/////////////////////////////////////////////////////

    CARGO DADA: 1 2 3 4
    TENGO QUE DESAPILAR DADA Y APILAR EN AUXILIAR: 4
    CUANDO APILO EN AUXILIAR SE APILA: 4
    DESAPILO DADA Y APILO EN DESTINO: 3 2 1
    DESAPILO AUXILIAR EN DADA: 4
    DESAPILO DESTINO Y APILO EN DADA: 4 3 2 1

/////////////////////////////////////////////////////


    apilar(&AUX, desapilar(&DADA));


    while(!pilavacia(&DADA)){
            apilar(&DESTINO, desapilar(&DADA));
    }

    while(!pilavacia(&AUX)){
            apilar(&DADA, desapilar(&AUX));
    }

    while(!pilavacia(&DESTINO)){
            apilar(&DADA, desapilar(&DESTINO));
    }


    printf("Pila DADA: \n");
    mostrar(&DADA);

OPCION2
    Pila DADA, DESTINO, AUX;
    inicpila(&DADA);
    inicpila(&DESTINO);
    inicpila(&AUX);
    char stop='s';

    do{
        leer(&DADA);
        printf("Si desea continuar presione s \n");
        fflush(stdin);
        scanf("%c", &stop);
    }while (stop== 's');

    printf("Pila DADA\n");
    mostrar(&DADA);

    if(!pilavacia(&DADA)){
        apilar(&AUX, desapilar(&DADA));
        while(!pilavacia(&DADA)){
            apilar(&DESTINO, desapilar(&DADA));
        }
        apilar(&DADA, desapilar(&AUX));
        while(!pilavacia(&DESTINO)){
            apilar(&DADA, desapilar(&DESTINO));
        }
    }
    mostrar(&DADA);


-------------------------------------------------------------
-------------------------------------------------------------
7. Pasar el último elemento (base) de la pila DADA a su primera
posición (tope), dejando los restantes elementos en el mismo orden.

    Pila DADA, DESTINO, AUX;
    inicpila(&DADA);
    inicpila(&DESTINO);
    inicpila(&AUX);
    char stop='s';

    do{
        leer(&DADA);
        printf("Si desea continuar presione s \n");
        fflush(stdin);
        scanf("%c", &stop);
    }while (stop== 's');

    printf("Pila DADA\n");
    mostrar(&DADA);

//////////////////////////////////////////////////
DESAPILO LOS ELEMENTOS EN AUXILIAR
EN AUXILIAR QUEDA LA BASE COMO TOPE: 4 3 2 1
EN DESTINO APILO EL TOPE DE AUXILIAR: 1
APILO EN DADA LOS ELEMENTOS DE AUXILIAR: 2 3 4
DESDE DESTINO APILO EN DADA 2 3 4 1
//////////////////////////////////////////////////

    while(!pilavacia(&DADA)){
            apilar(&AUX, desapilar(&DADA));
    }

    apilar(&DESTINO,desapilar(&AUX));

    while(!pilavacia(&AUX)){
            apilar(&DADA, desapilar(&AUX));
    }

    while(!pilavacia(&DESTINO)){
        apilar(&DADA, desapilar(&DESTINO));
    }
    printf("Pila DADA: \n");
    mostrar(&DADA);
-------------------------------------------------------------
OPCION2

    Pila DADA, DESTINO, AUX;
    inicpila(&DADA);
    inicpila(&DESTINO);
    inicpila(&AUX);
    char stop='s';

    do{
        leer(&DADA);
        printf("Si desea continuar presione s \n");
        fflush(stdin);
        scanf("%c", &stop);
    }while (stop== 's');

    printf("Pila DADA\n");
    mostrar(&DADA);

    if(!pilavacia(&DADA)){
        while(!pilavacia(&DADA)){
            apilar(&AUX, desapilar(&DADA));
        }
        apilar(&DESTINO,desapilar(&AUX));
        while(!pilavacia(&AUX)){
            apilar(&DADA, desapilar(&AUX))
        }
        apilar(&DADA,desapilar(&DESTINO));
    }
    printf("Pila DADA: \n");
    mostrar(&DADA);

-------------------------------------------------------------
-------------------------------------------------------------

8. Repartir los elementos de la pila MAZO en las pilas
JUGADOR1 y JUGADOR2 en forma alternativa.
#define s 83 ////la letra s corresponde a la tecla 83
int main()
{
    Pila MAZO, J1, J2;
    inicpila(&MAZO);
    inicpila(&J1);
    inicpila(&J2);
    int i;
    srand(time(NULL));
    int limite= 20; //CANTIDAD DE ELEMENTOS QUE VA A TENER LA PILA

    printf("Cargando mazo: \n");
    Sleep(1500);
    printf(".....................\n");
    Sleep(1500);
    printf(".....................\n");
    Sleep(1500);
    ///////LLENO LA PILA DE NUMEROS ALEATORIOS
    for(i=0; i< limite ; i++){
            apilar(&MAZO, rand()%15);
    }

    printf("\nMAZO\n");
    mostrar(&MAZO);
//////////////////////////////////////////////
DESAPILO EN J1 Y EN J2 LA PILA MAZO
MIENTRAS MAZO NO ESTE VACIA DESAPILO EL TOPE AL J1
SI SIGUE CON ELEMENTOS DESAPILO EL TOPE EN J2
Y ASI SUCESIVAMENTE HASTA QUE NO TENGA MAS ELEMENTOS
//////////////////////////////////////////////
    while (!pilavacia(&MAZO)){
        apilar(&J1, desapilar(&MAZO));
        if(!pilavacia(&MAZO)){
            apilar(&J2, desapilar(&MAZO));
        }
    }

    printf("Cartas J1\n");
    mostrar(&J1);

    printf("Cartas J2\n");
    mostrar(&J2);

-------------------------------------------------------------
-------------------------------------------------------------
9. Comparar la cantidad de elementos de las pilas A y B.
Mostrar por pantalla el resultado.

OPCION1:
    Pila aux, A1, B1;
    inicpila(&aux);
    inicpila(&A1);
    inicpila(&B1);
    char stop='s';

     do{
        leer(&A1);
        printf("Si desea continuar cargando la pila A presione s\n");
        fflush(stdin);
        scanf("%c",&stop);
    }while(stop=='s');

    mostrar(&A1);
    do{
        leer(&B1);
        printf("Si desea continuar cargando la pila B presione s\n");
        fflush(stdin);
        scanf("%c",&stop);
    }while(stop=='s');

    mostrar(&B1);

    while(!pilavacia(&A1)&& !pilavacia(&B1)){
        apilar(&aux, desapilar(&A1));
        apilar(&aux, desapilar(&B1));
    }
    if(pilavacia(&A1) && pilavacia(&B1)){
        printf("Las Pilas A y B tienen la misma cantidad de elementos\n");
    }else{
        printf("Las Pilas A y B tienen diferente cantidad de elementos\n");
        }
--------------------------------------------------------------------------------------------------------------------------
OPCION2:

int main()
{
    Pila aux, A1, B1;
    inicpila(&aux);
    inicpila(&A1);
    inicpila(&B1);
    srand(time(NULL));
    int limite;
    int i;

    printf("Ingrese la cantidad de elementos que quiera en la pila A\n");
    fflush(stdin);
    scanf("%i",&limite);

    for(i=0; i< limite ; i++){
            apilar(&A1, rand()%15);
    }
    mostrar(&A1);

    system("cls");

    printf("Ingrese la cantidad de elementos que quiera en la pila B\n");
    fflush(stdin);
    scanf("%i",&limite);

    for(i=0; i< limite ; i++){
            apilar(&B1, rand()%15);
    }
    mostrar(&B1);

    while(!pilavacia(&A1)&& !pilavacia(&B1)){
        apilar(&aux, desapilar(&A1));
        apilar(&aux, desapilar(&B1));
    }
    if(pilavacia(&A1) && pilavacia(&B1)){
        printf("Las Pilas A y B tienen la misma cantidad de elementos\n");
    }else{
        printf("Las Pilas A y B tienen diferente cantidad de elementos\n");
        }
-------------------------------------------------------------
-------------------------------------------------------------

10. Comparar las pilas A y B, evaluando si son completamente iguales
 (en cantidad de elementos, valores que contienen y posición de los
  mismos). Mostrar por pantalla el resultado.
OPCION1:
    Pila aux, A1, B1;
    inicpila(&aux);
    inicpila(&A1);
    inicpila(&B1);
    srand(time(NULL));
    int limite;
    int i;

    printf("Ingrese la cantidad de elementos que quiera en la pila A\n");
    fflush(stdin);
    scanf("%i",&limite);

    for(i=0; i< limite ; i++){
            apilar(&A1, rand()%15);
    }
    mostrar(&A1);

    printf("Ingrese la cantidad de elementos que quiera en la pila B\n");
    fflush(stdin);
    scanf("%i",&limite);

    for(i=0; i< limite ; i++){
            apilar(&B1, rand()%15);
    }
    mostrar(&B1);

    while(!pilavacia(&A1)&& !pilavacia(&B1) && (tope(&A1)==tope(&B1))){
        apilar(&aux, desapilar(&A1));
        apilar(&aux, desapilar(&B1));
    }
    if(pilavacia(&A1) && pilavacia(&B1)){
        printf("Las Pilas A y B son IGUALES \n");
    }else{
        printf("Las Pilas A y B son DIFERENTES \n");
        }
-------------------------------------------------------------
OPCION2

    Pila aux, A1, B1;
    inicpila(&aux);
    inicpila(&A1);
    inicpila(&B1);
    char stop='s';

     do{
        leer(&A1);
        printf("Si desea continuar cargando la pila A presione s\n");
        fflush(stdin);
        scanf("%c",&stop);
    }while(stop=='s');

    mostrar(&A1);

    do{
        leer(&B1);
        printf("Si desea continuar cargando la pila B presione s\n");
        fflush(stdin);
        scanf("%c",&stop);
    }while(stop=='s');

    mostrar(&B1);


    while(!pilavacia(&A1)&& !pilavacia(&B1) && (tope(&A1)==tope(&B1))){
        apilar(&aux, desapilar(&A1));
        apilar(&aux, desapilar(&B1));
    }
    if(pilavacia(&A1) && pilavacia(&B1)){
        printf("Las Pilas A y B son IGUALES \n");
    }else{
        printf("Las Pilas A y B son DIFERENTES \n");
        }

-------------------------------------------------------------
-------------------------------------------------------------

11. Suponiendo la existencia de una pila MODELO que no esté vacía,
eliminar de la pila DADA todos los elementos que sean iguales al
tope de la pila MODELO.

    Pila aux, MODELO, DADA, reserva;
    inicpila(&aux);
    inicpila(&MODELO);
    inicpila(&DADA);
    inicpila(&reserva);


    srand(time(NULL));
    int limite;
    int i;
    char stop= 's';

    printf("Ingrese la cantidad de elementos que quiera en la pila DADA\n");
    fflush(stdin);
    scanf("%i",&limite);

    for(i=0; i< limite ; i++){
            apilar(&DADA, rand()%15);
    }
    mostrar(&DADA);

    do{
        leer(&MODELO);
        printf("Si desea continuar cargando la pila MODELO presione s\n");
        fflush(stdin);
        scanf("%c",&stop);
    }while(stop=='s');

    mostrar(&MODELO);

    while(!pilavacia(&DADA)){
            if(tope(&DADA) == tope(&MODELO)){
                apilar(&aux, desapilar(&DADA));
            }else{
                apilar(&reserva, desapilar(&DADA));
            }
        }
        while(!pilavacia(&reserva)){
            apilar(&DADA, desapilar(&reserva));
        }
    printf("Pila DADA\n");
    mostrar(&DADA);

    printf("Elemento eliminado repetido \n");
    mostrar(&aux);

    return 0;
    }

-------------------------------------------------------------
-------------------------------------------------------------

12. Suponiendo la existencia de una pila MODELO (vacía o no),
 eliminar de la pila DADA todos los elementos que existan en MODELO.

    Pila aux, MODELO, DADA, reserva, DESCARTE;
    inicpila(&aux);
    inicpila(&MODELO);
    inicpila(&DADA);
    inicpila(&reserva);
    inicpila(&DESCARTE);


    srand(time(NULL));
    int limite;
    int i=0;

    printf("Ingrese la cantidad de elementos que quiera en la pila DADA\n");
    fflush(stdin);
    scanf("%i",&limite);

    for(i=0; i< limite ; i++){
            apilar(&DADA, rand()%15);
    }
    mostrar(&DADA);

    printf("Ingrese la cantidad de elementos que quiera en la pila DADA\n");
    fflush(stdin);
    scanf("%i",&limite);

    for(i=0; i< limite ; i++){
            apilar(&MODELO, rand()%15);
    }
    mostrar(&MODELO);

    while(!pilavacia(&MODELO)) {
        while(!pilavacia(&DADA)){
                if(tope(&DADA) == tope(&MODELO)){
                    apilar(&aux, desapilar(&DADA));
            }   else{
                    apilar(&reserva, desapilar(&DADA));
                    }
        }

            while(!pilavacia(&reserva)){
                apilar(&DADA, desapilar(&reserva));
        }
        apilar(&DESCARTE, desapilar(&MODELO));
    }

    printf("Pila DADA\n");
    mostrar(&DADA);

    printf("Elementos eliminados repetidos en ambas pilas\n");
    mostrar(&aux);


-------------------------------------------------------------
-------------------------------------------------------------

13. Suponiendo la existencia de una pila LÍMITE, pasar los
elementos de la pila DADA que sean mayores o iguales que el
tope de LIMITE a la pila MAYORES, y los elementos que sean
menores a la pila MENORES

    Pila DADA, DESCARTE, LIMITE, MAYORES,MENORES;

    inicpila(&DADA);
    inicpila(&DESCARTE);
    inicpila(&LIMITE);
    inicpila(&MAYORES);
    inicpila(&MENORES);
    srand(time(NULL));
    int limite;
    int i=0;

    printf("Ingrese la cantidad de elementos que quiera en la pila DADA\n");
    fflush(stdin);
    scanf("%i",&limite);

    for(i=0; i< limite ; i++){
            apilar(&DADA, rand()%15);
    }
    mostrar(&DADA);

    printf("Ingrese la cantidad de elementos que quiera en la pila DADA\n");
    fflush(stdin);
    scanf("%i",&limite);

    for(i=0; i< limite ; i++){
            apilar(&LIMITE, rand()%15);
    }
    mostrar(&LIMITE);

    while(!pilavacia(&LIMITE)&& !pilavacia(&DADA)){
                if(tope(&DADA)>= tope(&LIMITE)){
                    apilar(&MAYORES, desapilar(&DADA));
            }   else{
                    apilar(&MENORES, desapilar(&DADA));

                    }
        apilar(&DESCARTE, desapilar(&LIMITE));
    }



    printf("Pila MAYORES\n");
    mostrar(&MAYORES);
    printf("Pila MENORES\n");
    mostrar(&MENORES);
-------------------------------------------------------------
-------------------------------------------------------------

14. Determinar si la cantidad de elementos de la pila DADA es par.
Si es par, pasar el elemento del tope de la pila AUX a la pila PAR
y si es impar pasar el tope a la pila IMPAR (EN EL MAIN)

-------------------------------------------------------------
-------------------------------------------------------------

15. La condición es que mientras la pila PILA1 no esté vacía, se desapilen
los elementos de la pila DESCARTE y se apilen en PILA2. El ciclo finaliza
al vaciar P1.
-------------------------------------------------------------
-------------------------------------------------------------
16. Mientras que PILA1 no se vacíe, si el tope de Pila1 es igual a 5, se desapila y se apila en la pila
aux, luego se desapila su tope y se apila en la pila result.
-------------------------------------------------------------
-------------------------------------------------------------
17. ERRORES:
Solo se leerá un elemento a la hora de cargar la pila.
Solo si carga el valor 5 funcionará el resto del programa.
Falta incluir librerías

//librerias
#include <stdio.h>
#include <stdlib.h>
#include"pila.h"
//main
int main()
{
//Declaración de las Pilas a utilizar
    Pila origen, distinto;
//Inicialización de las Pilas
    inicpila(&origen);
    inicpila(&distinto);
//Declaración de variable de tipo char
    char stop='s';
//Algoritmo de carga de elementos a Pila
    do{
        leer(&origen);
        printf("Si desea continuar cargando elementos presionar s y enter\n");
        fflush(stdin);
        scanf("%c",&stop);
    }while(stop=='s');
//Algoritmo de manejo de Pila utilizando condicional (if) y bucle while
//Utilización de funciones de Pilas: tope, pilavacia, desapilar, apilar
    if(!pilavacia(&origen)){
        while(tope(&origen)!= 5){
            apilar(&distinto, desapilar(&origen));
        }

    }
//muestra por pantalla de las pilas
    mostrar(&origen);
    mostrar(&distinto);

}
-------------------------------------------------------------
-------------------------------------------------------------

18. La condición es que la Pila1 y la Pila2 no estén vacías, en caso de que una
esté vacía y la otra no,el programa dejará de ejecutar el ciclo while ya que es
una condición excluyente que AMBAS no estén vacías.
Puede que ambas queden vacías o que una de ellas quede con elementos y la otra vacía.

*/

int main()
{
    Pila DADA, AUX, PAR,IMPAR;

    inicpila(&DADA);
    inicpila(&AUX);
    inicpila(&PAR);
    inicpila(&IMPAR);
    char stop ='s';

    do{
       leer(&DADA);
       printf("Si desea continuar cargando la PILA DADA presione s\n");
       fflush(stdin);
       scanf("%c", &stop);
    }while(stop=='s');

    mostrar(&DADA);
//////////////////////////////////////////////
/*PASOS:
MIENTRAS QUE LA PILA DADA NO ESTE VACIA ,DESAPILO SU TOPE
Y LO PASO A LA PILA AUX
SI SIGUE CON ELEMENTOS LA PILA DADA (1° IF) DESAPILO EL TOPE Y LO PASO
A AUX DE NUEVO
PREGUNTO SI LA PILA SE VACIÓ, SI ES AFIRMATIVO
APILO EN PAR EL TOPE DE AUX (si no tiene mas elementos es porque tenia cantidad par
: esto lo verificamos al hacer 2 pasadas )
EN CASO DE QUE SE VACIE ANTES DE HACER LA 2DA REVISION
PASAMOS EL TOPE DE AUX A LA PILA IMPAR

*/

/////////////////////////////////////////////
    while (!pilavacia(&DADA)){
        apilar(&AUX, desapilar(&DADA));

        if(!pilavacia(&DADA))
        {
            apilar(&AUX, desapilar(&DADA));

            if(pilavacia(&DADA))
            {
                apilar(&PAR, desapilar(&AUX));
            }

        }
        else
            {
            apilar(&IMPAR,desapilar(&AUX));
            }
    }

        if(!pilavacia(&IMPAR)){
            printf("DADA tenia cantidad de elementos impares\n");
    }

        else if (!pilavacia(&PAR)) {
            printf("DADA tenia cantidad de elementos pares\n");
    }
        else{
            printf("La pila DADA no tenia elementos en su pila\n");
    }

}