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. 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:

)3()(

)2()(3)(

)()(

0,)( 01

1

n

nn

k

kk

kk

k

OnT

OnTNonT

nOnT

aconanananT

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)

• Cómo calcularlo

• Instrucción simple– Toda instrucción simple es O(1)

(asignar arreglos no es simple)

• Secuencia de instruccionesSi 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;• }

O(1)

n-k veces n veces

• 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(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)

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:

0si

0si

,)1()(

n

n

dnT

cnT

• 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:

])[),1,((2

1],1[),(

nanaMaxMax

nsianaMax

• 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;• else• max=a[n];• }• }

Verificar que esta función calcula

correctamente el máximo de los elementos del

arreglo y resolver la función T(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));

• }

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 + nEs 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); recu2(x/2);}Se deja como ejercicio obtener T(n) y 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)