Foro de elhacker.net

/*
Cuando analizo la 1er ITERACIÓN ,LA ITERACiÓN 0, ME DÁ QUE
Top es 10 ( para mí es así a partir de lo explicado al lado de la línea arriba del " while " )
¿ Cómo puede ser esto ?
el if compara " if 10 < 10 " .... ESTO ES UNA INCOHERENCIA ( ? )

LAS SIGUIENTES ITERACIONES SON ENTENDIBLES YA QUE EN LA SGTE
3 ES MENOR QUE 10 , y se mantiene ese criterio hasta el final;
pero no comprendo lo de " if 10 < 10 "
*/

#include <iostream>
#include <conio.h>
#include <stack>
// PILAS " LIFO "
// Es como una Pila de Platos =
// PRIMERO sale ( o muestro ) el LAST último hasta llegar al
//                               FIRST primero
using namespace std;
 
stack <int> pila;
 
int menor;      // Declaro la Variable " menor" ya que
                // estoy buscando el Dato de tipo INT Menor de toda la Pila
 
int main( )
{
pila.push(35);
pila.push(40);
pila.push(20);
pila.push(3);
pila.push(10);
 
// A DIFERENCIA DE LAS " COLAS " EN LAS " PILAS " para
// mostrar el 1er Dato ( o sea, el 5to ) NO SE UTILIZA
// ''' front ''' SINO SE UTILIZA ''' top '''
 
menor = pila.top(); // Esta Linea es NECESARIA puesto que cuando se evalue
                    // " if ( pila.top() < menor ) ", si no definieramos previamente
                    // que '' menor '' tome el valor del Dato que este AL COMIENZO DE LA PILA
                    // " el IF " arrojaria '' 0 '' PUESTO QUE CUANDO AL PRINCIPIO DEFINIMOS
                    // '' int menor '' COMO VARIABLE GLOBAL ( Ya que la definimos antes del
                    // cuerpo de main ) ESTA SIEMPRE COMIENZA VALIENDO '' 0 ''
                    // -- no hay ningun Nro menor que 0 dentro de la Pila --
while ( pila.size() > 0 ) // pila.size() determina la cantidad de Elementos que
{                         // se encuentran en la Pila
 
if ( pila.top() < menor ) 
{
 
menor = pila.top();
 
}
pila.pop();           // " BORRO " el Elemento actual para que el Bucle EVALUE otro
                          // Elemento -- si no, seguiria siempre Evaluando a '' menor '' --
}
 
cout << menor << endl;
 
 
getch ();
}
 

Esta claro que tenes problemas con la logica, si te resulta imposible imaginar lo que va haciendo el programa entonces tenes que depurarlo linea por linea, que es lo ideal, o cuanto menos ayudarte generando una salida en pantalla.

cout << "menor " << menor << " pila.top " << pila.top() << endl;  
if ( pila.top() < menor ) 
{
  cout << "CAMBIANDO menor, era " << menor << " sera " << pila.top() << endl; 
  menor = pila.top();
}

El valor de retorno de top es 10, no por ese comentario, es 10 por el simple hecho de que en la linea 21 el ultimo llamado a push tuvo como parametro 10. ¿Como puede ser que? ¿Que menor sea 10? Se le asigna ese valor en la linea 27. No hay ninguna incoherencia y una vez asignado el resultado de pila.top a menor, linea 27, deberias llamar a pila.pop, esa primera comparacion que haces es futil.

Comparas y haces la pregunta:
¿Diez es menor que diez?
El programa te responde: No, por lo que no hago el cuerpo del if y ejecuto directamente pila.pop();
La siguiente iteración comparas y preguntas:
¿Tres es menor que diez?
El programa te responde: Sí, ejecuto el cuerpo del if y escribo en 'menor' el valor actual del top de la pila; después borro ese número del top.

Gracias ! .... sucede que pensaba que el algoritmo, por ser exigente " y por defecto " evaluaria el hecho de que
" 10 sea menor que 10 " como un error, por una
cuestión de comparar el mismo número sin que
haya una igualdad mediante.

---

Gracias, MAFUS : El siguiente Esquema Iterativo, qué te parece ? =
ITERACiÓN 0
Top es 10 ( 10 < " 10 menor " ) ( LA CONDICIÓN NO SE CUMPLE ) => menor =  10  && Se borró el 10( menor )
ITERACiÓN 1
Top es 3  ( 3  < " 10 menor " )                               => menor =   3  && Se borró el 10( pila.top )
ITERACiÓN 2
Top es 20 ( 20 <  " 3 menor " ) ( LA CONDICIÓN NO SE CUMPLE ) => menor =   3  && Se borró el 20
ITERACIÓN
Top es 40 ( 40 <  " 3 menor " ) ( LA CONDICIÓN NO SE CUMPLE ) => menor =   3  && Se borró el 40
ITERACiÓN 4
Top es 35 ( 35 <  " 3 menor " ) ( LA CONDICIÓN NO SE CUMPLE ) => menor =   3  && Se borró el 35

Esta mal en la segunda linea, lo que se borra de la pila es 3, no 10. Y en la primera linea no se borra menor, se borra siempre de la pila, coincide su valor con menor por obvias razones, por eso te dije antes que seria mas logico llamar a pop antes de empezar el bucle en lugar de comparar futilmente menor (que sabemos que es igual al resultado de top) con el resultado de top.