Practico 3- Funciones - con correcciones

#include <stdio.h>
#include <stdlib.h>
#include "pila.h"

int main()
{

    Pila DADA;
    inicpila(&DADA);


    CargarPila (&DADA);
    AgregarOrden (&DADA, 4);


    printf("\n\t PILA DADA\n");
    mostrar (&DADA);

    return 0;
}

/*1. Hacer una función que permita ingresar varios elementos a una Pila, tantos como quiera el usuario*/

void CargarPila (Pila* a)
{

    char OP='s';
    while (OP=='s')
    {
        // para ponerle nombre a la pila en el printf necesito strings //
        printf("INGRESE UN VALOR A LA PILA\n");
        leer (a);
        printf("\n DESEA INGRESAR OTRO?  s/n\n");
        fflush(stdin);
        scanf("%c",&OP);
    }
}

/*2. Hacer una función que pase todos los elementos de una pila a otra*/

void PasarElementosIgual (Pila* a, Pila* b)
{
    Pila TEMP;
    inicpila (&TEMP);

    while (!pilavacia(a))
    {
        apilar (&TEMP, desapilar (a));
    }

    while (!pilavacia(&TEMP))
    {
        apilar (b, desapilar (&TEMP));
    }
}


/* 3.  Hacer  una  función  que  pase  todos  los  elementos  de  una  pila  a  otra,  pero  conservando  el orden.*/

void PasarElementos (Pila* a, Pila* b)
{
    while (!pilavacia(a))
    {
        apilar (b, desapilar (a));
    }
}


/*4. Hacer una función que encuentre el menor elemento de una pila y lo retorne.*/

int BuscarMenor (Pila* DADA)
{
    int MENOR;
    Pila  AUXDADA;
    //inicpila(&MENOR);
    inicpila(&AUXDADA);

    MENOR= desapilar (DADA);

    while (!pilavacia(DADA))
    {
        if (tope(DADA)< MENOR)
        {
            apilar (&AUXDADA, MENOR);
            MENOR=desapilar(DADA);
        }
        else
        {
            apilar (&AUXDADA, desapilar (DADA));
        }
    }

    while (!pilavacia(&AUXDADA))
    {
        apilar (DADA, desapilar (&AUXDADA));
    }
return MENOR;

}


/* 5. Hacer una función que pase los
elementos de una pila a otra, de manera que se genere una nueva pila ordenada.
 Usar la función del ejercicio 4. */

void OrdenarPila (Pila *DADA, Pila *Ordenada)
{
    while (!pilavacia (DADA))
    {
        apilar (Ordenada, BuscarMenor(DADA));
    }
}

/* 6.  Hacer  una  función  que  inserte  en  una  pila  ordenada  un  nuevo  elemento,  conservando  el orden de esta. */

void AgregarOrden (Pila *DADA, int nuevo)
{
    Pila POTATO;
    inicpila (&POTATO);

    while (!pilavacia(DADA)&& tope(DADA)> nuevo)
    {
        apilar (&POTATO, desapilar (DADA));
    }

    apilar (DADA, nuevo);

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

/*7. Hacer una función que pase los elementos de una pila a otra,
 de manera que se genere una nueva pila ordenada. Usar la función del ejercicio 6*/