Explorando los elementos que nos sirven para medir la eficiencia de un código - algoritmo. Conocer el tiempo que tarda en ejecutarse. Código muestra en C++

1. Eficiencia en uso de recursos y
memoria
Programación avanzada C++

2. Repaso
• Recordemos qué es un algoritmo

3. Un algoritmo es:
• Una secuencia de pasos para resolver un
problema, sus características son:
– Independiente: Del lenguaje de programación y de
la máquina.
– Definido: De pasos claros y concretos.
– Finito: En el número de pasos que usará.
– Preciso: Cada paso arroja un cálculo correcto.
– Recibe datos: Debe poseer datos de entrada.

4. Recursos necesarios para un programa
• Tiempo de procesador
• Memoria RAM
• Uso de recursos de procesador
• Los recursos no son infinitos, por eso se debe
analizar la eficiencia y desempeño de cada
algoritmo, para encontrar el equilibrio adecuado
entre realizar la tarea del programa usando la
menor cantidad de recursos posibles.

5. Tiempo de ejecución
• Tiempo de Ejecución
– El tiempo de Ejecución de un programa se mide
en función de N, lo que designaremos como T(N).
– Esta función se puede calcular físicamente
ejecutando el programa acompañados de un reloj,
o calcularse directamente sobre el código,
contando las instrucciones a ser ejecutadas y
multiplicando por el tiempo requerido por cada
instrucción.

6. Tiempo de ejecución (cont.)
• Así, un trozo sencillo de código como:
S1;
for(int x = 0; x < N; x++)
S2;
Va a tardar: T(N) = t1 + t2 * N
• Donde t1 es el tiempo que lleva ejecutar la
serie S1 de sentencias, y t2 es el que lleva la
serie S2.

7. Tiempo de ejecución (cont.)
• Habitualmente todos los algoritmos contienen
alguna sentencia condicional o selectiva,
haciendo que las sentencias ejecutadas
dependan de la condición lógica, esto hace
que aparezca más de un valor para T(N), es
por ello que debemos hablar de un rango de
valores:
Tmin(N) ≤ T(N) ≤ Tmax(N)

8. Ejemplo práctico para calcular tiempo
de ejecución.
#include <iostream>
#include <time.h> //librería para calcular tiempo de ejecución
#include <math.h> //librería para obtener números aleatorios
using namespace std;
void tiempoProc1(void);//procedimiento que contiene instrucciones para calcular
// tiempo que tarda cierto algoritmo
int main(){
tiempoProc1(); //procedimiento para calcular el tiempo que tarda cierto
//algoritmo
system("pause");
return 0;
}//fin main

9. void tiempoProc1(void){
int inicio, fin, t;
float tiempoSeg;
inicio = clock();//guarda tiempo inicial
/*Código a calcular el tiempo---lo podemos cambiar para ver
cómo se comportan diferentes algoritmos*/
for (int i = 0; i<1000; i++)
cout <<i<<"n";
/*Se puede poner el código al cuál queremos calcular el
tiempo*/
fin = clock();//guarda tiempo final
t = fin - inicio;//calcula tiempo transcurrido
tiempoSeg=((float)t) / CLOCKS_PER_SEC;//investiga qué
// significa esta línea
cout << "El tiempo transcurrido fue: " << tiempoSeg << "n";
}//fin tiempoProc1

10. Probemos este código con varios sub-algoritmos

11. Usando el ejemplo anterior,
investiga y responde lo siguiente

12. ¿Cuánto tarda en ejecutarse este ciclo
for?
for(int i=0; i<1000;i++)
cout <<i<<"n";

13. ¿Cuánto tarda este procedimiento de
arreglo estático?
void arregloEstatico(void){
int aE[10]; //aquí se declara el arreglo estático cuyo tamaño fijo
//está definido por la constante TAM
srand(5);//"semilla" para generar números aleatorios
cout << "nARREGLO ESTATICOn";
//ciclo para llenar el arreglo estático
for (int i = 0; i < 10; i++){
cout << "nElemento " << i << " del arreglo: ";
aE[i] = rand();
cout << aE[i];
} cout << "n";//imprime en pantalla una línea en blanco
//ciclo para mostrar arreglo estático
for (int i = 0; i < 10; i++)
cout << aE[i] << " ";
cout << "n";//imprime en pantalla una línea en blanco
}//fin procedimiento arregloEstatico

14. ¿Cuánto tarda este procedimiento de
arreglo dinámico?
void arregloDinamico(void){
int tamDin = 0; //variable para que el usuario indique el tamaño del arreglo que quiere
cout << "nARREGLO DINAMICOn";
cout << "Calcula el tamaño del arreglo de enteros: ";//indica a usuario tamaño deseado
srand(5);//"semilla" para generar números aleatorios
tamDin = rand(); //se guarda el tamaño en variable tamDin
cout << " " << tamDin << "n";//se muestra el tamaño aleatorio elegido
int *pArregloDin; //apuntador para guardar dirección de inicio del arreglo dinámico
pArregloDin = new int[tamDin]; //se aparta memoria dinámica para el arreglo pArregloDin
//ciclo para llenar los elementos del arreglo dinámico
for (int i = 0; i < tamDin; i++){
cout << "nElemento " << i << " ";//pide al usuario ingrese cada uno de
//los elementos del arreglo
pArregloDin[i] = rand();
}//fin for
cout << "n";//imprime en pantalla una línea en blanco
//ciclo para mostrar arreglo dinámico
for (int i = 0; i < tamDin; i++)
cout << pArregloDin[i] << " "; //fin for
cout << "n";//imprime en pantalla una línea en blanco
delete pArregloDin; //librea la memoria dinámica reservada para el arreglo
}//fin procedimiento arreglo dinámico

15. Fin del primer elemento de
eficiencia de uso