Anlisis y Diseo de Algoritmos

Tema 1: Algoritmos y Complejidad

Titulacin: Grado en Ingeniera
Informtica

Contenido
Algoritmos
Caractersticas de los algoritmos
La importancia de los algoritmos
Calculabilidad, Diseo, Complejidad, Verificacin, Terminacin

Complejidad

Recursos computacionales
Tamao de la entrada, operaciones bsicas
Complejidad en el caso mejor, peor y medio
Clases de complejidad y notacin asinttica
Anlisis de algoritmos no recursivos: algoritmos de ordenacin
Anlisis de Algoritmos Recursivos
Resolucin de ecuaciones de recurrencia
El teorema maestro
Algoritmo de bsqueda binaria

Qu es un algoritmo?
Definicin:
Un algoritmo es una secuencia de instrucciones no
ambiguas que resuelven un problema, es decir, que
producen un salida correcta para cualquier entrada
correcta en un tiempo finito.
Nota Histrica: La palabra algoritmo es
de origen rabe y proviene del
matematico Abu Abdullah Muhammad
Bin Musa, quien tom como seudnimo
Al-Khwarizmi (780-850), lugar donde
haba nacido, el estado de Khowarizm,
en la actual repblica de Uzbiekistn.

Caractersticas de los algoritmos

Un problema puede tener muchos
algoritmos esencialmente distintos
que lo resuelvan
Cada algoritmo define un patrn de
comportamiento para resolver el
problema para distintos datos de
entrada
El algoritmo junto con los datos de
entrada es una instancia del
algoritmo
Existen muchas formas de describir
un mismo algoritmo: lenguaje
natural, pseudolenguaje, lenguaje
de programacion
La especificacin del algoritmo
debe ser completamente
compresible para el procesador que
va a ejecutarlo

Problema

Algoritmo 1

Algoritmo 2

Espec. 1
Espec. 2

Programa

Formalizacin
Formalmente, un problema es una funcin

donde E y S son el conjunto de entradas y salidas,

respectivamente, que deben ser a lo sumo numerables.

Ejemplo: Algoritmo de Euclides para el

clculo del mximo comn divisor
Euclides (324 aC a 265 aC) describi, en sus
famosos Elementos, un mtodo para calcular el
mximo comn divisor de dos nmeros enteros del
modo siguiente:

Especificacin en lenguaje natural

Algoritmo de Euclides para calcular mcd(a, b)

Paso 1. Si b = 0, la solucin es a, devolver a y parar.
Paso 2. Dividir a entre b y guardar el resto de la divisin en r.
Paso 3. Cambiar el valor de a por el de b, y el de b por r . Volver a 1.

Especificacin en pseudolenguaje
y en Java
Pseudolenguaje
Java

/**
* @param a y b: valores cuyo mcd calculamos
* @return el mcd de a y b mediante el algoritmo de Euclides.
*/
public static int euclides(int a,int b){
if (a<0 || b<0 || (a ==0) && (b==0))
throw new IllegalArgumentException("valores no vlidos");
while(b!=0){
int r = a % b;
a = b;
b = r;
}
return a;
}

Otros algoritmos para el clculo del

mcd(a,b)

Algoritmo 2 para calcular mcd(a, b)

Paso 1. Sea c = min(a,b).
Paso 2. Si c divide a a y a b, devolver c y parar.
Paso 3. sino decrementar c en 1 y volver al Paso 2.

Especificacin de mcd2 en Java

/**
* @param a>0 y b>0: valores cuyo mcd calculamos
* @return el mcd de a y b mediante una bsqueda lineal.
*/
public static int mcd2(int a,int b){
if (a==0 || b==0)
throw new IllegalArgumentException("valores no vlidos");
int c = Math.min(a,b);
boolean enc = false;
do{
if (a % c == 0 && b % c == 0) enc = true;
else c--;
}while (!enc);
return c;
}

Otros algoritmos para el clculo del

mcd(a,b)
Algoritmo escolar para calcular mcd(a, b)
Paso 1. Encontrar los factores primos de a
Paso 2. Encontrar los factores primos de b
Paso 3. Calcular los factores primos comunes de a y b (si p es un
factor comn que aparece pa y pb en a y b,
respectivamente, debe repetirse min{pa , pb } veces)
Paso 4. Calcular el producto de todos los factores comunes y
devolverlo

Por ejemplo, si a = 60 y b = 24
60 = 2 * 2 * 3 * 5
24 = 2 * 2 * 2 * 3
mcd(60,24) = 2 * 2 * 3 = 12

Otros algoritmos para el clculo del

mcd(a,b) Pero, cmo calculamos

los factores primos de un

nmero?

Algoritmo escolar para calcular mcd(a, b)

Paso 1. Encontrar los factores primos de a
Paso 2. Encontrar los factores primos de b
Paso 3. Calcular los factores primos comunes de a y b (si p es un
factor comn que aparece pa y pb en a y b,
respectivamente, debe repetirse min{pa , pb } veces)
Paso 4. Calcular el producto de todos los factores comunes y
devolverlo

Criba de Eratostenes (200 dC)

/**
* @param a>0: nmero cuyos factores primos calculamos
* @return la lista de los factores primos de a
*/
public static List<Integer> criba(int a){
if (a<=0)
throw new IllegalArgumentException("valor no vlido);
List<Integer> lista = new LinkedList<Integer>();
List<Integer> primos = new LinkedList<Integer>();
for (int i = 2; i<=a; i++){
lista.add(i);
}
while (!lista.isEmpty()){
int elem = lista.remove(0);
primos.add(elem);
int aux = elem;
while (aux <= a){
aux += elem;
lista.remove(new Integer(aux));
}
}
return primos;
}

Criba de Eratostenes (200 dC)

todos = [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
17, 18, 19, 20, 21, 22, 23, 24, 25]
primos =[]
todos = [3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25]
primos =[2]
todos = [5, 7, 11, 13, 17, 19, 23, 25]
primos =[2, 3]
todos = [7, 11, 13, 17, 19, 23]
primos =[2, 3, 5]
todos = [11, 13, 17, 19, 23]
primos =[2, 3, 5, 7]

todos = [13, 17, 19, 23]

primos =[2, 3, 5, 7, 11]
todos = [17, 19, 23]
primos =[2, 3, 5, 7, 11, 13]
todos = [19, 23]
primos =[2, 3, 5, 7, 11, 13, 17]
todos = [23]
primos =[2, 3, 5, 7, 11, 13, 17, 19]
todos = []
primos =[2, 3, 5, 7, 11, 13, 17, 19, 23]

La importancia de los algoritmos

Para hacer que un ordenador
ejecute una tarea hay que:
1.

2.

3.

Disear un algoritmo que

describa cmo resolver el
problema
Expresar el algoritmo como un
programa en un lenguaje de
programacin
Ejecutar el programa en un
ordenador

Problema

Algoritmo

Programa

La importancia de los algoritmos

Problema

Caractersticas de los algoritmos

1.

2.

Los algoritmos son

independientes de los lenguajes
en los que se expresan
Los algoritmos son
independientes de las mquinas
que los ejecutan

Algoritmo

Programa

La importancia de los algoritmos

Caractersticas de los algoritmos
1. Diseo

2.

Cmo encontrar un algoritmo que resuelva un problema dado?

Calculabilidad

3.

Existen algoritmos para todos los problemas que podemos formular?

Complejidad

4.

Cunto cuesta ejecutar un algoritmo? Podemos comparar dos algoritmos distintos

para un mismo problema y decidir cul es el mejor?

Correccin

5.

Podemos probar que un algoritmo calcula las salidas correctas para todas las
entradas posibles?

Terminacin

La ejecucin del algoritmo termina para todas las posibles entradas?

Introduccin a la Calculabilidad
David Hilbert (1862-1943) crea que toda afirmacin (problema)
descrita matemticamente podra demostrarse (calcularse), si era
cierta, o bien podra probarse su falsedad.

Kurt Gdel (1906-1978) public su Teorema de la Incompletitud

en 1931 demostrando que la afirmacin de Hilbert era falsa.
En cualquier sistema formal, lo suficientemente potente para
incluir a los naturales, hay afirmaciones que son ciertas pero que no
pueden ser probadas.
La tesis de Church-Turing establece la equivalencia
entre las distintas nociones de algoritmo que se han dado
hasta ahora, y que de forma razonable pueden
definirse en el futuro.
Alonso Church
1903-1995

Alan Turing
1912-1954

El teorema de la parada
Enunciado: No existe ningn algoritmo A que tenga como entrada otro
algoritmo B y unos datos D, y que devuelva S, si B(D) termina o No, si
B(D) no termina (tiene un bucle infinito).
Demostracin: Por reduccin al absurdo.
Supongamos que existe A, entonces su comportamiento sera
A(B,D) =

S, si B(D) termina
No, si B(D) no termina

Bajo esta hiptesis, definimos el algoritmo A

A(B) = A(B,B) =

S, si B(B) termina
No, si B(B) no termina

Finalmente, construimos el algoritmo Malo

Malo(B)=

Fin , sii A(B) = No, sii B(B) no termina (tiene un bucle infinito)
Bucle infinito, sii A(B) = S, sii B(B) termina

El teorema de la parada
Enunciado: No existe ningn algoritmo A que tenga como entrada otro
algoritmo B y unos datos D, y que devuelva S, si B(D) termina o No, si
B(D) no termina (tiene un bucle infinito).
Demostracin: (sigue)
Cul es el comportamiento de Malo(Malo)?
Por definicin:
Malo(Malo) =

Fin, A(Malo) = No, sii Malo(Malo) no termina (tiene un bucle infinito)

Bucle infinito, sii A(Malo) = S, sii Malo(Malo) termina

es decir,
Malo(Malo) = fin, sii Malo(Malo) no termina
Malo(Malo) = Bucle infinito, sii Malo(Malo) termina

Por lo tanto, un algoritmo como A no puede existir.

Absurdo

Correccin del algoritmo de Euclides

Cmo sabemos que el algoritmo mcd funciona
correctamente para todas sus entradas?

Hay que probar que las dos igualdades son siempre ciertas:

Terminacin del algoritmo de Euclides

Introduccin a la complejidad

Aunque hay problemas no

computables, existen unos cuantos
(muchos menos) para los que s
existe un algoritmo que los resuelva.
Los algoritmos hacen uso de
recursos:

Todos los problemas

tiempo y memoria

Slo aquellos algoritmos que utilizan

una cantidad razonable de recursos
son tiles en la prctica.
La teora de la complejidad
proporciona herramientas
matemticas para calcular el nmero
de recursos computacionales
necesitados para ejecutar un
algoritmo

Problemas computables
Problemas computables en la prctica

Recursos computacionales
1.
2.

Periodo de tiempo desde que

empieza a ejecutarse un
algoritmo hasta que termina
Cantidad de memoria
necesitada por el algoritmo
para ejecutarse, normalmente
para almacenar resultados
parciales.

Los algoritmos normalmente

aceptan unos datos de entrada y
producen unos datos de salida.
El tiempo y la memoria
necesitados para ejecutar un
algoritmo dependen en la
mayora de los casos del tamao
de los datos de entrada.

Ejemplo: Multiplicacin de dos nmeros

mediante el algoritmo escolar

Recursos computacionales: tiempo

Ejemplo: Multiplicacin de dos nmeros
mediante el algoritmo escolar

Tamao de la entrada =
nmero de dgitos a multiplicar

Recursos computacionales: espacio

Ejemplo: Multiplicacin de dos nmeros
mediante el algoritmo escolar
Dgitos que deben almacenarse

Otro algoritmo ms rpido para

multiplicar
C D
A B
19 84 x 67 13
A*C = 19 * 67 = 1273----(A+B)*(C+D)-A*C- B*D = 5875--B*D =
1092
13318592

Comparando complejidades
Algoritmo escolar

Las funciones de complejidad

en tiempo de los algoritmos
pueden compararse.
En la grfica se comprueba
que el crecimiento del
algoritmo DV es ms lento que
el del algoritmo escolar, por lo
que podemos decir que DV es
mejor que Escolar, porque
tarda menos tiempo.

Algoritmo DV

Complejidad: tamao de la entrada

Dado un algoritmo A, la complejidad se establece como una funcin que asocia a cada
entrada del algoritmo su tiempo de ejecucin.
Tamao de la entrada
Tiempo de ejecucin

Una cuestin importante es cmo medimos la entrada de un algoritmo

En muchos casos es fcil decidir cmo medir la entrada de un algoritmo, por ejemplo:

Habitualmente, cuanto ms grande es la entrada, el algoritmo tarda ms en ejecutarse.

Ordenacin o bsqueda en una lista: longitud de la lista
Evaluacin de un polinomio en un punto: grado del polinomio (los coeficiente no afectan de forma
determinante a la complejidad)

En otros casos, la decisin no es tan fcil

Multiplicacin de matrices cuadradas de tamao nxn:

La dimensin n de la matriz
El nmero de elementos de la matriz n*n

De forma general puede utilizarse el nmero de bits de la representacin binaria de la

entrada
En otras ocasiones puede ser que la funcin de la complejidad dependa de ms de un
parmetro de entrada.

Complejidad: operaciones bsicas

public class BusqSecuencial {
/**
* Bsqueda secuencial en un array de enteros
* @param a : array de elementos en el que buscar
* @param x : elemento buscado
* @return la posicin del elemento en el array,
* si est, -1, si el elemento no est
*/
public static int busqSec(int[] a,int x){
int i = 0;
while (i<a.length && a[i]!=x){
i++;
}
if (i<a.length) return i;
else return -1;
}
}

o
o

No es buena idea, pues depende del estilo del

programador

Contando el nmero de operaciones

bsicas?
o

No es buena idea, pues depende de la mquina

Contando el nmero de lneas?

o

o
0

Cmo calculamos la complejidad en

tiempo de un algoritmo?
Calculando el tiempo real de ejecucin?

cules son las operaciones bsicas?

Las operaciones bsicas dependen del

algoritmo que se est analizando y
normalmente no son difciles de
detectar:
En los algoritmos de ordenacin y
bsqueda, la comparacin y copia de
componentes
En los algoritmos de multiplicacin de
nmeros o matrices, el producto de
dgitos

Complejidad: operaciones bsicas

public class BusqSecuencial {
/**
* Bsqueda secuencial en un array de enteros
* @param a : array de elementos en el que buscar
* @param x : elemento buscado
* @return la posicin del elemento en el array,
* si est, -1, si el elemento no est
*/
public static int busqSec(int[] a,int x){
int i = 0;
while (i<a.length && a[i]!=x){
i++;
}
if (i<a.length) return i;
else return -1;
}
}

Complejidad: rdenes de crecimiento

/**
*
* @param a matriz bidimensional
* cuadrada
* @return true si es simtrica,
* false, en otro caso
*/
public static boolean esSimetrica(int[][] a){
for (int i = 0; i < a.length; i++){
for (int j = i+1; j < a[i].length; j++){
if (a[i][j]!=a[j][i]) return false;
}
}
return true;
}

cunto tardar en ejecutar el algoritmo

una mquina 10 veces ms rpida?

cunto tardar en ejecutarse el algoritmo

con una entrada de 2n elementos?
Las
constantes no
son
significativas

Complejidad: rdenes de crecimiento

complejidad
logartmica

La base de los
logaritmos y de las
exponenciales no es
relevante

complejidad
lineal

complejidad
cuadrtica

Complejidad
exponencial

Los algoritmos con una complejidad

exponencial slo son prcticos para
resolver problemas de pequeo tamao

Complejidad en el caso peor, medio y

mejor
La complejidad en el caso peor de un algoritmo es la
complejidad del algoritmo con la entrada/s de tamao n
con la se comporta peor (tarda ms en ejecutarse)
La complejidad en el caso mejor de un algoritmo es la
complejidad del algoritmo con la entrada/s de tamao con
la se comporta mejor (tarda menos en ejecutarse)
La complejidad en el caso medio de un algoritmo es la
media (calculada en funcin de la probabilidad de la
ocurrencia de las entradas) de las complejidades del
algoritmo con todas las entrada/s de tamao n

Complejidad en el caso peor y mejor de la

Bsqueda Secuencial
public class BusqSecuencial {
/**
* Bsqueda secuencial en un array de enteros
* @param a : array de elementos en el que buscar
* @param x : elemento buscado
* @return la posicin del elemento en el array,
* si est, -1, si el elemento no est
*/
public static int busqSec(int[] a,int x){
int i = 0;
while (i<a.length && a[i]!=x){
i++;
}
if (i<a.length) return i;
else return -1;
}
}

Complejidad en el caso medio de la

Bsqueda Secuencial

10

Clases de complejidad y
notacin asinttica: O(n)

Informalmente, O(g(n)) es el conjunto de funciones

acotadas superiormente por un mltiplo de g.
Se utiliza para probar que la complejidad de un
algoritmo como muy mal se va a comportar como la
funcin g, que se toma como referencia.
Observa que los valores iniciales de ambas funciones
no importan, lo que es relevante es que a partir de una
cierto nmero, f se comporte mejor o igual que un
mltiplo de f.

Clases de complejidad y
notacin asinttica: O(n)

Clases de complejidad y
notacin asinttica: (n)

Informalmente, (g(n)) es el conjunto de funciones

acotadas inferiormente por un mltiplo de g.
Se utiliza para probar que la complejidad de un
algoritmo como muy bien se va a comportar como la
funcin g, que se toma como referencia.
Como en el caso de O, los valores iniciales de ambas
funciones no importan, lo que es relevante es que a
partir de una cierto nmero, f se comporte peor o igual
que un mltiplo de g.

Clases de complejidad y
notacin asinttica: (n)

Clases de complejidad y
notacin asinttica: (n)

Informalmente, (g(n)) es el conjunto de funciones

con el mismo orden de complejidad que g.
Se utiliza para probar que la complejidad de un
algoritmo es igual asintticamente a la funcin g, que
se toma como referencia.
Como en los dos casos anteriores, los valores iniciales
de ambas funciones no importan, lo que es relevante
es que a partir de una cierto nmero, f crezca de forma
similar a g.

Clases de complejidad y
notacin asinttica: (n)

Notacin Asinttica: propiedades

Notacin Asinttica: propiedades

Complejidad: comparando las

complejidades