Análisis de Algoritmos Jeannette Galleguillos

MOTIVACION Muchas veces queremos comparar métodos de resolución de problemas (algoritmos) en cuanto a eficiencia Interesan TIEMPO MEMORIA Normalmente podemos mejorar uno empeorando el otro

El tiempo de ejecución de un programa depende de: La entrada El compilador El computador El algoritmo utilizado

El computador y el compilador afectan en un factor constante El computador y el compilador afectan en un factor constante. Será por lo tanto la entrada la que nos interesará. Usaremos el tamaño de la entrada como un parámetro de la función de tiempo: T(n)=cuánto demora para una entrada de tamaño n. Esto no es necesariamente cierto, en algunos casos el tiempo de ejecución depende de cuál es la entrada particular además de su tamaño.

Normalmente T(n) será una cota superior es decir no puede ser peor que eso. Muy poco se vé el caso promedio suponiendo todas las entradas de tamaño n equiprobables.

NOTACION Para independizarnos del computador y del compilador, nos interesará la tasa de crecimiento del tiempo de ejecución en función de n, más que de la forma explícita de la función. Diremos que: f(n)=O(g(n)) “de orden g(n)” Si existe c,n0 tal que para todo n>=n0 f(n) <=cg(n)

g(n) es una cota superior para la tasa de crecimiento de f(n). Como es obvio, nos interesará la cota superior más pequeña posible. Para que esto sea útil, g(n) debe resultar una función simple, ej: T(n)=n2

Ejercicios:

CALCULO TIEMPO DE EJECUCION La hipótesis es que basta comparar órdenes para comparar métodos. Pero: Qué pasa si las constantes son grandes y n típicamente pequeño Que el orden sea mejor quiere decir: Cuando la entrada crezca lo suficiente será mejor Cuando el computador sea más rápido este programa mejorará más su rendimiento que el otro

Normalmente consideraremos los siguientes casos: O(n) razonable O(n2) lento O(2n) demasiado lento O(log n) bueno (log en base 2)

Secuencia de instrucciones Cómo calcularlo Instrucción simple Toda instrucción simple es O(1) (asignar arreglos no es simple) Secuencia de instrucciones Si T(n)=T1(n) + T2(n) y T1(n)=O(f1(n)) y T2(n)=O(f2(n)) => T(n)=O(max(f1(n), f2(n))

Podemos ver: Secuencia de instrucciones simples es O(1) Una instrucción O(n2) seguida de una O(n3) es O(n3) Entonces importa la etapa más cara

Iteración Si una instrucción que demora T1(n)=O(f1(n)) se itera V(n)=O(f2(n)) Tenemos Si T(n)=T1(n)·V(n), T1(n)=O(f1(n)), V(n) =O(f2(n)) Entonces T(n)=O(f1(n)·f2(n)) De aquí: O(cf(n))=O(f(n))

Ejemplo: “Ordenamiento por selección” For k=1 to n do { //buscar mínimo entre k y n posmin=k; for i=k+1 to n do { if a[i]<a[posmin] posmin=i; // O(1) } aux=a[k]; a[k]=a[posmin]; a[posmin]=aux; n-k veces n veces O(1)

Esto quiere decir que toma un tiempo proporcional al cuadrado del número de elementos a ser ordenados Veremos que es posible ordenar en tiempo O(n log n) que es mucho mejor ya que para n grande log n es mucho más pequeño que n. En algunos casos es sencillo determinar cotas superiores precisas como en el caso anterior, pero hay muchos casos que aún no han sido resueltos y continúan siendo analizados.

for(j=1; j<=n;j++) O(n) printf(“algo\n”); //O(1) for(i=1;i>=n;i++) for(j=1; j<=n;j++) O(n) printf(“algo\n”); //O(1) Este algoritmo tiene orden O(n2) O(n)

la mayor de ambas (peor caso) Reglas Asignación, entrada, salida: O(1) Secuencia de instrucciones: O(max(f(n),g(n)) If-else: la mayor de ambas (peor caso) Ciclo: O(V(n)·T(n))

RECURSION Al analizar un programa recursivo llegamos a una ecuación de recurrencia. Ejemplo: Factorial Hay muchas técnicas para resolver recurrencias. Cuando son sencillas podemos expandirlas hasta entender cómo operan, transformándolas en sumatorias:

T(n)= T(n-1) + d = T(n-2) + 2d = T(n-3) + 3d ... = T(0) + nd = c + nd = O(n).

Ejemplos: Máximo de un arreglo de tamaño n:

Verificar que esta función calcula correctamente el máximo de los elementos del arreglo y resolver la función T(n). int max(int a[], int n) { int m; if n=1 max=a[1]; else { m=max(a,n-1); if m>a[n] max=m; max=a[n]; }

Ejercicio 1: Escriba una función recursiva que calcule la siguiente suma, y obtenga su T(n) y O(n): 1) 1 + 2 + 3 +...+ n 2) 2 + 4 + 6 ....+ 2n

Función: int valor ( int x) { if (x == 1) return 1; return ( n + valor(n-1)); }

T(n-2) +2 = ... = T(n-k)+k= ...=1 + n Es de orden O(n). 1 si n=1 T(n)= T(n-1) +1 T(n)= T(n-1) +1 T(n-2) +2 = ... = T(n-k)+k= ...=1 + n Es de orden O(n).

Dada la siguiente función recursiva obtenga su función T(n) y O(n) 1) int recu1(int x) { if (x==1) return 1; return( recu(x/2)) }

2) int recu2( int x) { if (x==1) {//algo de O(1) return 1; } recu2(x/2); Se deja como ejercicio obtener T(n) y O(n)

Se deja como ejercicio resolver la recurrencia y calcular O(n) c , si n=1 T(n)= 2T(n-1) +d, si n>1 Se deja como ejercicio resolver la recurrencia y calcular O(n)