Version:0.9 StartHTML:0000000105 EndHTML:0000007186 StartFragment:0000000152 EndFragment:0000007152
/******************************************************/
/*************** Isidro Pastor Jorda ******************/
/*************** Noemi Ruth Moya Hinojo ***************/
/******************************************************/
/****************** Telematica ************************/
/******************** FPII ****************************/
/****************** Practica 3 ************************/
/******************************************************/

#include <iostream.h>
#include <stdlib.h>
#include <cstdlib>              //include para utilizar las funcion rand();
#include "PilaE.h"

typedef int Vector[TALLAMAX];

bool Ordenar (Vector v);

int main()
{
    int i;
    Vector v;

    i = 0;

    while(i <= TALLAMAX -1)   // Bucle para generar el vector de numeros aleatorios
    {
        v[i] = (1 + rand()%20 ) - 3; // Hacemos la resta para incluir numeros negativos en el vector a ordenar
        cout << v[i] << " ";
        i++;
    }

    if (Ordenar (v) )
    {
        cout << endl << " El vector ordenado es: ";
        for (i = 0; i <= TALLAMAX - 1; i++)
            cout << v[i] << " ";
        cout << endl << endl;
    }
    else
        cerr << endl << " Se Produjeron errores durante la ordenacion" << endl;

    system("PAUSE");
    return 0;
}


/*****************************************************************************
* Funcion: Ordenar
* Descripcion: Ordena un vector pasado como paramtro a la funcion utilizando
*              el metodo de insercion directa usando la clase pila. Creamos
*              dos pilas donde iremos haciendo la ordenacion, parte opcional
*              no vaciamos totalmente la pila b despues de cada insercion
*
*
* Parametros:
*
* Nombre        E/S       Descripcion
* ------       -----      -----------
*  v           E/S       Vector a ordenar
*
*
*
* Valor devuelto:
*       bool, cierto si se ha podido ordenar el vector correctamente y falso
*       si se produjeron errores durante la ordenacion.
*****************************************************************************/

bool Ordenar (Vector v)
{
    int i, x, cima;
    bool ok, apilado;
    Pila a, b;

    ok = true;
    i = 0;

    while ( i <= TALLAMAX-1 && ok)
    {
        apilado = false;
        x = v[i];
        do
        {
            if ( a.PilaVacia() )
                apilado = a.Apilar(x);
            else
            {
                a.CimaPila(cima);

                if ( x < cima )
                {
                    b.Apilar(cima);
                    a.Desapilar();
                }
                else
                {
                    if ( b.PilaVacia() )        // si no apilamos en a y la pila b esta vacia apilamos aqui
                        apilado = b.Apilar(x);
                    else   // en caso de estar la pila b con elementos comparamos su cima con x
                    {
                        b.CimaPila(cima);
                        if ( x > cima )  // Si el elemento a apilar es mayor que la cima de b desapilamos en b
                        {
                            ok = a.Apilar(cima);
                            b.Desapilar();
                        }
                        else
                            apilado = b.Apilar(x);  // si el elemento ya es menor que la cima de b apilamos x en b
                    } // else
                } // else
            } // else
        }
        while (!apilado && ok); // repetiremos el proceso hasta haber apilado x
        i++;
    } // while

    if (ok)
    {

         /******************************************************
         * Una vez hayamos apilado el elemento en la pila a    *
         * movemos todos los elementos que tengamos en la pila *
         * b a la pila a                                       *
         *******************************************************/

        while ( !(b.PilaVacia()) )
        {
            b.CimaPila(cima);
            ok = a.Apilar(cima);
            b.Desapilar();
        }

        for ( i = 0; i <= TALLAMAX - 1; i++) // y volcamos el contenido de la pila al vector
        {
            a.CimaPila( v[i] );
            a.Desapilar();
        } // Al final del bucle for tendremos el vector ordenador de mayor a menor


    } // if

    return (ok);
};