La eficiencia de los algoritmos La eficiencia de los algoritmos

#
 "


TEMA 1
#
 

LA EFICIENCIA &
 ' (
) *+
DE LOS &"
  (+, 
ALGORITMOS +-%+

INDICE


    
 



 



 
  

  



 
 
 
 

 
!
 
"

#$%

 

1 2

La eficiencia de los algoritmos La eficiencia de los algoritmos

A.V. Aho, J.E. Hopcroft, J.D. Ullman: “The

 !"#$% design and analysis of computer algorithms”.
Addison-Wesley, 1974.

 
 A.V. Aho, J.E. Hopcroft, J.D. Ullman:
. - 
   “Estructuras de datos y algoritmos”. Addison-
Wesley Iberoamericana, 1988.

 ' 
S. Sahni: “Concepts in Discrete Mathematics”.

 The Camelot Publishing Company, 1985.

 '/ 
 '   
  


  


 0112  
%' 3 
 ' 

 &'()*

4$4$5 67

 +, -
+./5 8

99:
 

6+!+ )
  
.!, 
99;
 
#
BIBLIOGRAFÍA COMPLEMENTARIA

3 4
 La eficiencia de los algoritmos La eficiencia de los algoritmos


    



 

 

 COSTE = Consumo de estos recursos por parte

Normalmente, un problema se puede resolver por de un algoritmo.
métodos distintos, con distintos grados de
eficiencia. Ejemplo: búsqueda de un número en
una guía telefónica.
En esta asignatura nos interesa el estudio del
coste temporal.

Cuando se usa un ordenador es importante limitar
el consumo de recursos.

Si un programa se va a usar una o muy pocas

Recursos: veces, puede darse el caso de que lo más
importante sea que sea fácil de entender, codificar

Tiempo:
y depurar.

Aplicaciones informáticas que trabajan “en
tiempo real”: requieren que los cálculos se
realicen en el menor tiempo posible.
A medida que se dispone de ordenadores más
rápidos, se pretende resolver problemas más

Aplicaciones que manejan un gran grandes y complejos, por lo que el uso de
volumen de información: si no se tratan algoritmos eficientes sigue siendo importante.
adecuadamente pueden necesitar tiempos
impracticables.

Problemas intrínsecamente complejos.

Espacio: Las máquinas tienen una memoria
limitada.

5 6

La eficiencia de los algoritmos La eficiencia de los algoritmos

FACTORES DE LOS QUE DEPENDEN LOS

APROXIMACIONES AL ANÁLISIS DE LA
PARAMETROS DEL COSTE:
EFICIENCIA DE LOS ALGORITMOS (memoria y
tiempo de ejecución):
A - Factores propios del problema:

Análisis experimental o "a posteriori" (se verá

procedimiento de resolución del problema, y en la prácticas de laboratorio). Consiste en

los datos. ejecutar casos de prueba, haciendo medidas para:

una máquina concreta,
B - Factores dependientes de la máquina:
un lenguaje concreto,

tipo de computador,
un compilador concreto y

lenguaje de programación,

datos concretos.

carga del sistema,

etc.

Análisis teórico o "a priori" (se verá en las
clases teóricas). Consiste en obtener una
En esta asignatura nos interesan los factores propios
expresión que indique el comportamiento del
del problema.
algoritmo en función de los parámetros que
influyan. Interesante porque:

La predicción del coste puede evitar una
implementación posiblemente laboriosa.

Es aplicable en la etapa de diseño de los
algoritmos, constituyendo uno de los factores
fundamentales a tener en cuenta.

7 8
 La eficiencia de los algoritmos La eficiencia de los algoritmos

EJEMPLOS:

    
 1.- Algoritmo de ordenación: la talla del problema
 será el número de elementos a ordenar.

2.- Algoritmo de búsqueda de un elemento en una

secuencia: la talla del problema será el número de

COMPLEJIDAD (O COSTE) DE UN ALGORITMO: elementos de la secuencia.
Es una medida de la cantidad de recursos (tiempo, 3.- Algoritmo del cálculo del factorial de un número:
memoria) que el algoritmo necesita. la talla será el valor del número.
La complejidad de un algoritmo se expresa en
función del tamaño o talla del problema.

¿COMO CALCULAR LA COMPLEJIDAD
TEMPORAL DE UN ALGORITMO?

TALLA DE UN PROBLEMA:
Contando el número de operaciones elementales o
Es cualquier parámetro en función del cual se pasos de programa que realiza.
pueda expresar la complejidad del problema:
De esta forma:

Nº de datos de entrada

Nº de datos de salida coste(n) = Número de pasos de programa

Valor de las variables numéricas en función de n.

Una función de los anteriores
 Es independiente de la máquina concreta
Suele guardar relación con el volumen de los datos utilizada.
a tratar, y por ello se le suele llamar “tamaño” del
problema.

9 10

La eficiencia de los algoritmos La eficiencia de los algoritmos

  


EJEMPLOS DE COSTES:

Son aquellas cuyo tiempo de ejecución está

acotado superiormente por una constante que no x := x + y
depende de la talla del problema.
 coste = 1 paso.

EJEMPLOS DE PASOS DE PROGRAMA:

para i := 1 hasta n hacer
x := y + z x := x + y
fpara
 1 paso

x := y + z  talla = n, coste(n) = n pasos.

x := x * x

 2 pasos (ó también 1 paso) para i := 1 hasta n hacer

para j := 1 hasta n hacer
si x = 0 entonces
y := y + 1 x := x + y
sino fpara
y := y - 1 fpara
fsi

 1 paso (ó también 2 pasos)  talla = n, coste(n) = n2 pasos.

si x = 0 entonces
y := y + 1
fsi

 1 paso

11 12
 La eficiencia de los algoritmos La eficiencia de los algoritmos

GRÁFICAS DE FUNCIONES TABLA DE TIEMPOS DE EJECUCIÓN

Tiempos de ejecución en un máquina capaz de

ejecutar 109 pasos de programa por segundo para
tallas (n) y costes (en número de pasos) dados.

n (Talla)

Pasos 1 8 32 103 106 109

log2n < 1 ns 3 ns 5 ns 10 ns 20 ns 30 ns

n 1 ns 8 ns 32 ns 1 s 1 ms 1s

nlog2n < 1 ns 24 ns 160 ns 10 s 20 ms 30 s

2
n 1 ns 64 ns 1 s 1 ms 17 min 38 años

n3 1 ns 512 ns 33 s 1 s 38 años > 1010

años
2n 2 ns 256 ns 4.3 s > 10291 > 10300K > 10300M
años años años
n! 1 ns 40 s > 1018 > 102K > 105M >109000M
años años años años
nn 1 ns 17 ms > 1031 >103K > 106M >109000M
años años años años

Problemas
inabordables

13 14

La eficiencia de los algoritmos La eficiencia de los algoritmos

TALLAS PARA DOS ORDENADORES DE


DIFERENTE POTENCIA

Talla (n) del problema que puede ejecutarse en un

tiempo prefijado, en función de la velocidad del
¿De qué depende la complejidad de un
computador (que aumenta de V a 10V). algoritmo A?

1. De la talla del problema: n.

n para 10V
Nº de
n para V n para 10V  2. Para una talla fija, de la instancia del
pasos
n para V problema.
300 log2n 10 1010 109
100 n 10 100 10
En general obtendremos una expresión del
5 n2 14 45 3.2 coste distinta para cada instancia:
n3 / 2 12 27 2.3
2n 10 13 1.3 costeA(I,n) =
n! / 100 9 10 1.1 Número de pasos de programa
nn / 100 7 7 1 para una talla n y una instancia I

A medida que se baja en la tabla, aumenta más 
 

    
despacio la talla del problema que es posible tratar
usando una máquina 10 veces más rápida. 
  
Cuando el coste es lineal (100 n en esta tabla) una
máquina 10 veces más rápida permitirá tratar un
problema 10 veces “más grande”.

Nos interesan las instancias significativas:

Ip: peor de los casos. Cuando son
necesarios el máximo número de cálculos.

Im: mejor de los casos. Cuando son

necesarios el mínimo número de cálculos.

15 16
 La eficiencia de los algoritmos La eficiencia de los algoritmos

Sean:
EJEMPLOS DE INSTANCIAS

n la talla del problema de A
1.- Búsqueda secuencial de un elemento x en un

S(n) = { I : I  Instancia  talla(I) = n } vector a:

función buscar
entonces: ( x: elemento;
p a: vector índice
de entero;

costeA (n) = máx {costeA(I,n) : I  S(n)}
n: índice)
= costeA(Ip,n) devuelve índice;
(coste peor) {1
n  k:1
k
n:ak=x}
m var i:índice fvar;

costeA (n) = mín { costeA(I,n) : I  S(n)} i:=1;
= costeA(Ip,n) mientras a[i]x hacer
i:=i+1
(coste mejor) fmientras;
devuelve i
Med

costeA (n) =  S(n) P(I) * costeA(I,n) {1
i
n  ai=x  j:1
j<i:a[jx}
ffunción
(coste medio)

• Talla del problema: n.

• Instancias:

x Caso mejor

x Caso genérico

x Caso peor

17 18

La eficiencia de los algoritmos La eficiencia de los algoritmos

2.- Búsqueda del máximo de un vector a:

     
función máximo(a: vector; 
n: índice)
devuelve entero;

Una forma alternativa de calcular la complejidad
{ 1
n } en el peor caso consiste en la identificación y
var max:elem; i:índice fvar; seguimiento de una instrucción crítica.
i:=2;
max:=a[1];
La instrucción crítica de un algoritmo es la
mientras i<n hacer instrucción (o comprobación) que más veces se
si a[i] > max entonces ejecuta independientemente de casos.
max := a[i ]
fsi;
i := i + 1
Si es posible identificar una instrucción crítica en
fmientras; un algoritmo, el coste se puede calcular como el
devuelve max número de veces que se repite esta instrucción.
{ (j:1
j
n:a[j
max) 
 Ejemplo: en el algoritmo de búsqueda del
(j:1
j
n:a[j=max) } mínimo podríamos tomar la instrucción
ffunción Si_entonces ya que es la instrucción que más
veces se ejecuta (n-1 veces)
• Talla del problema: n.
• No existen diferentes instancias significativas
(en cualquier caso se recorre todo el vector).

19 20
 La eficiencia de los algoritmos La eficiencia de los algoritmos

Ejemplos:


p m

Determinar exactamente costeA y coste A

puede resultar difícil;

no tiene mucho sentido si hablamos de pasos de
programa;

puede resultar excesivamente laborioso si sólo
necesitamos calcular la complejidad de un
algoritmo para compararlo con otros durante la
fase de diseño, antes de conocerlo en detalle.
21
La eficiencia de los algoritmos

CONSIDERACIONES:

Interesa estudiar el comportamiento de un
algoritmo para tallas relativamente grandes:
Sean A y A' dos algoritmos que resuelven el mismo
problema.

Si costeA (n) = 2n y costeA' (n) = 3n, podremos
decir que A y A' tienen una eficiencia parecida.

Si costeA(n) = 2n y costeA' (n) = 100n, A será
más eficiente que A'. Pero el uso de un
ordenador suficientemente rápido para ejecutar
A’ haría que este algoritmo se ejecutase
siempre en menos tiempo que A en el
ordenador original. Por lo tanto, los avances
tecnológicos podrían justificar el uso de A’ si
éste poseyera suficientes ventajas secundarias
sobre A.

Si costeA(n) = n2 y costeA' (n) = 3n, podremos
decir que:

A es más eficiente que A’ para n = 1, 2;

A y A’ son igual de eficientes para n = 3;

A’ es más eficiente que A para n > 3.
22
La eficiencia de los algoritmos

/0
complejidades asintóticas.

Objetivo: obtener una notación clara y simple para

Interesa comparar los comportamientos de los
expresar el coste de un algoritmo para valores
algoritmos según el orden de magnitud de sus
grandes de la talla y con independencia de la
complejidades.
velocidad del ordenador utilizado.

Interesa hacer estudios de la complejidad
En lo que sigue, f, g, f1, f2, y f3 serán funciones de N
independientes de la velocidad del en R+. (R+ = { x  R: x > 0 } en este tema.)
computador donde se programa el algoritmo
desarrollado. Esto significa que funciones de
complejidad que difieren en un factor constante
se consideran idénticas a efectos de medidas de
costes.

Por lo tanto, para el cálculo de la complejidad

adoptaremos un CRITERIO ASINTOTICO.

23 24
 La eficiencia de los algoritmos La eficiencia de los algoritmos

NOTACION O
NOTACION 

Definición. Se dice que
Definición. Se dice que

- f es como mucho del orden de g, o que - f es como mínimo del orden de g, o que
- f crece más lentamente o igual que g, o que - f crece más rápidamente o igual que g,
- g es una cota superior de f, o que

sii c>0, n0 N: f(n)
c g(n) n

n0 - g es una cota inferior de f,

sii c>0, n0 N: c g(n)
f(n) n

n0

Definición.
O(g(n)) = { funciones que son como
Definición.
mucho del orden de g(n) }
(g(n)) = { funciones que son como
mínimo del orden de g(n) }

Ejemplos.
1.- 3n  O(n):
Ejemplos.
Si se toma C=3 y n0=0 se tiene 1.- 3n  (n):
f(n) = 3n  3n = C·g(n) n0. Si se toma C=1 y n0=0 se tiene

2.- 3n  O(n ):
2 C·g(n) = 1·n  3n = f(n) n0.

Si se toma C=3 y n0=0 se tiene 2.- n2  (3n):

2
f(n) =3n C·g(n) = 3n  n0. Si se toma C=1 y n0=3 se tiene
C·g(n) = 1·3nn2 = f(n) n3.

25 26

La eficiencia de los algoritmos La eficiencia de los algoritmos

b) 3n  (n) ( “ “ ).

NOTACION 

Definición. Se dice que

Definición. Se dice que
- f es de menor orden que g, o que
- f es del orden de g, o que
- f crece más lentamente que g, sii
- f crece igual de rápidamente que g, o que
f(n)  O(g(n)) pero f(n)  (g(n)).
- g es una cota superior e inferior de f, sii

c,d>0, n0 N: c g(n)
f(n)
d g(n) n

n0

Definición. Se dice que

Definición.
- f es de mayor orden que g, o que
(g(n)) = { funciones que son del orden
de g(n) } - f crece más rápidamente que g, sii

f(n)  (g(n)) pero f(n)  (g(n)).

!
 
 TEOREMA.
1- f es de menor orden que g sii O(f(n))  O(g(n)).

Proposición.
2- f es de mayor orden que g sii (f(n))  (g(n)).

f(n) (g(n))  f(n) O(g(n))  f(n)  (g(n))

f(n) (g(n))  f(n) O(g(n))  g(n) O(f(n))
Nota:  denota en este tema la inclusión estricta.

Ejemplo.
3n  (n), pues
a) 3n  O(n) (visto anteriormente).

27 28
 La eficiencia de los algoritmos La eficiencia de los algoritmos

COROLARIO
Los siguientes teoremas son útiles para comparar
tasas de crecimiento de funciones. a. Si p es un polinomio de grado r, entonces
p es del mismo orden que nr.
b. n , con >1 constante, crece más
rápidamente que cualquier polinomio.
TEOREMA
c. Si 1>K2>1, entonces
f (n)
lim  K  0  (f(n))  (g(n))
n
 g ( n) n crece más rápidamente que n, pero
log
(n) es del mismo orden que log(n).
(f y g son del mismo orden).
d. Cualquier polinomio crece más rápidamente
que log(n).
TEOREMA
e. n! crece más rápidamente que n.
f ( n)
lim    f(n ) crece más rápidamente que g(n), f. nn crece más rápidamente que n!.
n
 g (n)

o lo que es lo mismo: O(g(n))  O(f(n)).

TEOREMA
f ( n)
lim  0  g(n ) crece más rápidamente que f(n).
n
 g (n)

o lo que es lo mismo: O(f(n))  O(g(n)).

29 30

La eficiencia de los algoritmos La eficiencia de los algoritmos

"
 &1&%#"#"2(&


Para calcular el coste de un algoritmo:
Muchas veces las notaciones asintóticas pueden

En primer lugar hay que determinar la talla del
aparecer dentro de expresiones, por ejemplo:
algoritmo.

f(n ) = n2 + O(1/n)
En los algoritmos en los que el coste temporal sea

independiente de las instancias, es decir, cuando
significa que f(n ) es una función cuadrática más un el caso mejor y el peor coincidan, utilizaremos
término asintótico menor que 1/n. Se debe de directamente la notación  para estimar la
entender como suma de conjuntos de funciones. complejidad del algoritmo:

f(n ) n2 + O(1/n) coste (n) (f(n)).

En los algoritmos en los que el coste temporal

#$%
 varíe en función de las instancias, podremos
distinguir:
COROLARIO
a) De menor a mayor orden:
Peor caso y

O(1)  O(log(n)) O(n)  O(nlog(n)) 
Mejor caso.

2 3 n n
O(n )O(n ) ...  O(K ) O(n!) O(n ).
b) De mayor a menor orden:
(1)  (log(n))  (n)  (nlog(n)) 
2 3 n n
(n ) (n ) ...  (K )  (n!)  (n ).

31 32
 La eficiencia de los algoritmos La eficiencia de los algoritmos

PEOR CASO: EJEMPLOS.

Utilizaremos la notación  (o la  si fuera 1. Para el algoritmo de búsqueda secuencial:

necesario) para estimar la complejidad del • Talla del problema: n.
algoritmo en el peor de los casos:
• Instancias significativas: caso mejor,
costep (n) (f(n)), caso peor.
con lo que obtendremos una cota superior de costep(n)  (n)
la complejidad del algoritmo:
costem(n)  (1)
costeA(n) (f(n)). Por lo tanto:
coste(n) (n)

MEJOR CASO: coste(n) (1)

Utilizaremos la notación  (o la  si fuera

necesario) para estimar la complejidad del
algoritmo en el mejor de los casos:
2. Búsqueda del máximo de un vector:
m
costeA (n) (g(n)), • Talla del problema: n.

con lo que obtendremos una cota inferior de la • Instancias: no hay instancias significativas que
complejidad del algoritmo: afecten al coste. En cualquier caso se recorre
todo el vector.
costeA(n) (g(n)).
coste(n)  (n).

33 34

La eficiencia de los algoritmos La eficiencia de los algoritmos


  #"131/"#%/"2&"!//
2&"!///"&%1%#(41"%
Procedimiento a seguir:

1. Determinar qué parámetro(s) nos da(n) la talla Vamos a estudiar la complejidad de las siguientes
o tamaño del problema, en función de la cual instrucciones:
se expresará la complejidad.

operaciones básicas,
2. Identificar el caso peor y el caso mejor de
comportamiento del algoritmo en cuanto a
secuencia de instrucciones,
consumo de tiempo (o de espacio si se estudia
la complejidad espacial).
sentencia alternativa, y

sentencia iterativa.
3. Aplicar un método de obtención de las cotas de
complejidad.

Operaciones básicas. Se van a considerar como

Complejidad Temporal: se calcula contando el pasos de programa las operaciones básicas:
número de pasos de programa de cada instrucción asignación, comparación, operaciones aritméticas,
en función de la talla del problema. lectura/escritura...

 Coste de un paso de programa  (1)

Ejemplo. Las siguientes instrucciones tienen un

coste (1):

x := y + z;

b := x  y  (a  b);

escribir(‘Un texto constante como éste’).

35 36
 La eficiencia de los algoritmos La eficiencia de los algoritmos

Secuencia de instrucciones ( S = S1 ; S2).
Sentencia alternativa “si .. fsi”.

 coste( S ) = coste( S1 ) + coste( S2 ) Si B entonces S1 sino S2 fsi

Caso especial: para grandes tallas, puede

darse que una de las instrucciones tenga  coste( “SI “ ) = coste( B ) + coste( S1 ó S2 ),
coste despreciable frente a la otra, con lo que dependiendo de la acción (S1 ó S2) que se ejecute:
se podrá aplicar el siguiente resultado:

B cierta  se ejecutará S1
coste( S 1 )  ( f1 )
 coste( “SI” ) = coste( B ; S1 )
coste( S2 )  ( f2 )  coste( S )  ( f2 )

B falsa  se ejecutará S2
O( f1 )  O( f2 )
 coste( “SI” ) = coste( B ; S2 )
Ejemplos. Si denotamos:

1. Supongamos que: coste( B )  ( g ),

coste( S1 ) = 2n + 3  (n), coste( S1 )  ( f1 ),

coste( S2 ) = 5n + 1  (n). coste( S2 )  ( f2 ),
Entonces coste( S1 ; S2 ) = 7n + 4  (n).
en la práctica se suelen dar los siguientes casos:
2. Supongamos que: Costes parciales coste( “SI” )

coste( S1 ) = 3n + 1  (n),
O( g )  O( f1 ) = O( f2 )  ( f1 )

coste( S2 ) = 7n2  (n2).
O( g )  O( f1 )  O( f2 )  ( f1 ), O( f2 )
Entonces coste( S1 ; S2 )  (n2).

37 38

La eficiencia de los algoritmos La eficiencia de los algoritmos

Sentencia iterativa “mientras ... fmientras”. Casos Prácticos

Caso 1. Se realizan n iteraciones, y la i-ésima
p
Mientras B hacer S fmientras iteración (guarda + cuerpo) tiene un coste i , con p
constante.

Sea n el número de iteraciones que de hecho se n n p 1 n p

ejecutan  la ejecución de la instrucción anterior  Coste =  ip    (n p1 )
será equivalente en efectos y en coste a la ejecución i 1 p1 2
de:

 Coste  (np+1)
1ª iteración nª iteración (falla B)
B ; S; ... B ; S; B

(Nota: B es una función y no un procedimiento, por Ejemplo:

lo que el cuadro anterior contiene una imprecisión.)
Para i := n decreciendo hasta 1 hacer
escribe_letra(“a”, i)
fpara,
coste( “Mientras” ) =
i = 1..n coste( B(i) ; S(i) ) + coste( B(i+1) ) en donde escribe_letra(“a”, i) escribe i
(i) veces el carácter “a” y tiene un coste (i). La talla
donde hace referencia a la i-ésima iteración.
del problema es n, y su coste será:
n

Puesto que los costes parciales anteriores pueden coste =  i  (n

i 1
2
).
ser distintos en cada iteración del bucle, la casuística
que puede presentarse es muy variada.

39 40
 La eficiencia de los algoritmos La eficiencia de los algoritmos

Son habituales los siguientes subcasos: Ejemplo: búsqueda dicotómica en un vector

n ordenado.
p=0  
1  n  (n) .
i 1
{ v está ordenado }
procedimiento dicotómica
n
n( n  1) (v: vector 1..n

p=1  
i
i 1
1

2
 ( n 2 ) .
de entero;
n, x: entero;
n
n(n  1)(2n  1) sal está: lógico;
p=2  
i
i 1
2

6
 ( n 3 ) . sal m: entero) es
var i,j: entero fvar;
i:=1 ; j:=n; está := falso;
repetir
Caso 2: Medidas logarítmicas. m := (i+j) div 2;
opción
Supongamos que en cada iteración la talla n se v[m] > x: j := m - 1;
reduce en un factor c, hasta llegar a una talla mínima v[m] < x: i := m + 1;
n0 >0 para la que se da la condición de salida del v[m] = x: está := verdadero;
bucle. fopción
hasta que i>j  está
Tras la 1ª iteración: la talla pasa a n/c fprocedimiento
2
Tras la 2ª " : " n/c {1
m
n((está  vm=x) 
.....................................................
(está  k:1
k
n:vkx)}
y tras una q-ésima iteración, la talla se reduce a n0.

Como se tendrá que n/c

k
= n0, el número de • La talla del problema es la dimensión del vector. Se
puede considerar la talla como un valor dinámico
iteraciones será:
que tras cada iteración es la longitud de la zona del
k = logc (n/n0). vector donde aún no se ha descartado que pueda
estar x.

41 42

La eficiencia de los algoritmos La eficiencia de los algoritmos

Caso peor: x no está en el vector, y por lo tanto en

número de iteraciones es máximo.

costep(n) = 1 + coste_iteración &!  

= 1 + (1 + coste_si + coste_guarda)*(nº iteraciones)
! 
  
(
= 1 + K*(nº iteraciones).
El cálculo del número de iteraciones en este caso es
<3 ' /
 /
un ejemplo de reducción logarítmica.
'
  

 -  
 
Tras cada iteración se reduce la talla  ' 
aproximadamente a la mitad, hasta llegar a un
tamaño 1. Por ello, el número de iteraciones es
log2n. Luego

.    
costep(n) = 1 + Klog2n  (log2n).

= 
  (//
Caso mejor: se encuentra de inmediato el elemento   
>
+
y la iteración cesa: costem(n)  (1).    
En resumen:
Definición del problema
coste(n)  O(log2n), coste(n)  (1).





 
 
















 
   
 






 
!""
# !"""

$


43 44
 La eficiencia de los algoritmos La eficiencia de los algoritmos

  Estrategia para la ordenación:

: vector x entero x entero  lógico
Para v1  vector, i,j  entero 1.- Considerar el vector dividido en dos zonas:

ordenado(v1) = ( k: i k <j: v[k

 v[k+1
) - elementos que ya están ordenados
- elementos por reubicar.

 : vector x vector x entero x entero  lógico
Para v1,v2  vector, i,j  entero 2.- Se utiliza una variable “i” para marcar el límite
entre ambas zonas.
perm(v1,v2,i,j)= ( k: i  k j:
(( t: i  t  j: v1[k
=v2[t
) 
INVARIANTE:
nveces(v1[k
, v1,i,j) = nveces(v1[k
,v2,i,j) ))
1 i-1 i n
/: TipoBase x vector x entero x entero 
entero
Para e TipoBase, v  vector, i,j  entero  k : 1  k < i - 1: v[k]  v[k+1] 1  i 1  n
nveces(e,v,i,j) = k: i k  j: igual (v[k
,e)
designa las posiciones que contienen elementos
ordenados entre sí,
' : TipoBase x TipoBase {1,0}
posiciones cuyos elementos no están
Para x,y  TipoBase
necesariamente ordenados.
igual(x,y)= 1 sii x=y
Función limitadora t = n - i + 1
igual(x,y)=0 sii xy

45 46

La eficiencia de los algoritmos La eficiencia de los algoritmos

Diseño del algoritmo a partir del Diseño del algoritmo a partir del
invariante: invariante:

- El invariante se cumple inicializando “i” a 2, ya que - La iteración debe acabar cuando el vector esté
inicialmente el primer elemento está ordenado con totalmente ordenado.
respecto a si mismo 1 n

1 2 n

 k : 1  k < n : v[k]  v[k + 1]

En efecto, formalmente:
Por tanto:
!B = (i = n + 1)
 k : 1  k < i - 1 : v[k]v[k+1] 1  i 1  n i
=2
B = ( i  n)

 k : 1  k < 1 : v[k]  v[k+1] 1  1  n

47 48
 La eficiencia de los algoritmos La eficiencia de los algoritmos

Diseño del algoritmo a partir del RESUMEN: Estructura algorítmica

invariante: general para la ordenación

- El cuerpo de la iteración, S, deberá conseguir que en

cada pasada se reduzca la zona desordenada ó función
limitadora, t = n -i +1
¿? P = {v = V}

¡El problema es lo suficientemente complejo como para i:=2;

que esta instrucción sea a su vez una iteración ! mientras i  n hacer
S;
Las diferentes propuestas que se pueden hacer
para S conducen a diferentes algoritmos de i:=i+1
ordenación fmientras

Q = {ordenado(V, 1, n)  v = perm(V)}

1 i-1 i n

Invariante

Función limitadora t = n -i +1

49 50

La eficiencia de los algoritmos La eficiencia de los algoritmos

Para insertar ordenadamente v[i] en v[1 .. i - 1]

Ordenación por inserción
1.- buscar secuencialmente la posición p
correspondiente a v[i] en v[1 .. i - 1].
El algoritmo de ordenación por inserción propone para S
una iteración basada en la siguiente idea: 2.- desplazar hacia la derecha todos los elementos
entre esta posición e i-1 inclusive, para situar v[i] en
"se escoge el primer elemento de la zona por su emplazamiento definitivo.
ordenar y se inserta en el lugar correspondiente en
la zona ya ordenada" i := 2;
mientras i  n hacer

i := 2; buscar la posición p correspondiente a v[i];

mientras i  n hacer 1 p i-1 i n
{
1
p
i }
insertar ordenadamente v[i] en v[1..i-1];

v[i] >v[i]
i := i + 1
x := v[i];
fmientras
desplazar hacia la derecha todos los
elementos de v[p .. i - 1];

v[p] := x;
1 i-1 i n
{ }

i:=i+1

fmientras

51 52
 La eficiencia de los algoritmos La eficiencia de los algoritmos

¡los pasos 1 y 2 se pueden realizar de forma

> ?@
A
?
simultánea!   (   B 
'%   B
@

Reformulación en un paso de insertar ordenadamente
v[i] en v[1 .. i - 1] C0D2   
E

{i  n  ordenado(v, 1, i-1) v[1 .. i-1] = perm(V, 1, i-1)} = 

 
 
 D?

02? 1  1 (1)
1

p:=i; i
1

x:=v[i];  

(   B 
mayor:=true;

%3%   B
@

mientras (p>1) mayorhacer
C0D2   
si v[p-1]<=x entonces mayor:=false E
sino
v[p]:=v[p-1]; > 
F(  
@

p:=p-1
> F(  
@
fsi;
G
fmientras; > DF(  
@D?H
@D?H
 D?
{p = 1  !(mayor)} i

02? 
1  i  (i)
j 1

v[p]:= x;

{(i  n)  ordenado(v, 1, i)  v[1 .. i] = perm(V, 1, i)}

53 54

La eficiencia de los algoritmos La eficiencia de los algoritmos

"  5insertar ordenadamente v[i] en

i := 2; v[1..i-1],


67
mientras i  n hacer
n 1

insertar ordenadamente v[i] en v[1..i-1]; 02? 
1  n  1 (n)

i 1

i := i + 1  
( /
fmientras /<
"  5insertar ordenadamente v[i] en
> ? v[1..i-1],58


69 
 ( El vector está ya ordenado  7
 coste(n)  (n)
= 
F0?20/IJ

/2


( El vector está ordenado al revés
= F0?20/IJ
/2
coste(n)  (n2) G
= -  0?20/IJ
@
/2@

 ( El vector está ya ordenado n 1

(n  1)
C0D2   
67 = i i 1 2
(1  (n  1))  (n 2 )
E
 
F(  
@

> 
F(  
@ Ejercicio: Diseñar el algoritmo para insertar
> F(  
@ ordenadamente v[i] en v[1 .. i - 1] utilizando búsqueda
G binaria. En este caso, el método de ordenación se conoce
> DF(  
@0DA
2?H con el nombre de “Inserción binaria”. Compárese el
diseño obtenido con el presentado anteriormente.
@D@
?H
 D?@

55 56
 La eficiencia de los algoritmos La eficiencia de los algoritmos

Ordenación por selección Diseño del algoritmo a partir del

invariante:
El algoritmo de ordenación por selección propone para S
una iteración basada en la siguiente idea: - El invariante se cumple inicializando “i” a 1, para que
pueda buscar el primer mínimo en el intervalo [1 .. n]
1 i-1 i n
1 n
I=
I=

“Tras cada iteración, cualquier elemento de es

- La iteración debe acabar cuando el vector esté
menor o igual que cualquier elemento de ”
totalmente ordenado. Recordemos que mínimo(v, n, n) =
Esto es, v[n]

¡ el último elemento YA estará ordenado!

“se aumenta el tamaño de la zona ordenada situando
en la posición “i” el mínimo de v[i .. n] ”
Por tanto, realizamos n-1 pasadas de ordenación y
terminamos cuando i = n
" k : 1  k < i-1 :v[k]  v[k+1] 1  i  n
!B = (i = n) ó B = ( i  n -1)
 m : 1< i  m  n : v[i-1]  v[m]}

- Para poder disminuir el tamaño de la zona desordenada,

tn-i+1
pos_min := mínimo(v, i, n);

x:= v[pos_mín]; v[pos_mín]:=v[i]; v[i]:=x;

i:=i+1

57 58

La eficiencia de los algoritmos La eficiencia de los algoritmos

m 1

0 2?  1  ( m )
i 1
donde mínimo(v,i,n):

algoritmo mínimo algoritmo ordenar (DATOS v:vector[1..n]de

(DATOS v:vector[1..n]de TipoBase; TipoBase;
inicio,fin:1..n; RESULTADOS v: vector [1..n] de TipoBase)
RESULTADOS p:inicio..fin) var i:entero fvar
var siguiente:entero fvar i:=1;
siguiente:=inicio+1; p:=inicio; mientras i<n hacer
mientras siguiente<=fin hacer p:=mínimo(v,i,n);
si v[siguiente]< v[p] intercambiar(v[i],v[p]);
entonces p:=siguiente; i:=i+1;
siguiente:=siguiente+1; fmientras
fmientras falgoritmo
devuelve p
falgoritmo

Talla = n
  0/2
C0D2  E
mientras siguiente<=fin hacer
si v[siguiente]< v[p] entonces p:=siguiente;
siguiente:=siguiente+1; > 
F(  
@

fmientras
> F(  
@
G
Talla = fin - inicio +1=m > DF(  
@D?

C0D2  E

@D?

 D?@

 
F(  

 @
"    5    
.
> 
F(  
 @ :6;5575 8  
   
G 9  
> DF(  
 @0DA
2?H
= 
F0?
2  0/
2
@D@
?H
 D? @
= F0?2  0/2@

G

59 60
 La eficiencia de los algoritmos La eficiencia de los algoritmos

= -  0?@
2  0/@
2

5.2- Otros algoritmos sobre vectores.

5.2.1La bandera nacional holandesa
n1 n1
Sea una fila de n bolas de color blanco, rojo y azul. Sea un
02?  (n  (i 1))   n  i 1 (n )
i 1 i 1
2
brazo mecánico capaz de efectuar las operaciones:
• color(i): averigua el color de la bola que se
encuentra en la posición i-ésima de la fila.
" 
• perm(i,j): permuta las bolas de estas
posiciones.
algoritmo ordenar (DATOS v:vector[1..n]de TipoBase;
RESULTADOS v: vector [1..n] de TipoBase)
var siguiente: entero fvar Se pide un algoritmo iterativo que en una sola pasada
para siguiente:=1 hasta n-1 hacer sobre la fila, realizando como mucho n intercambios, y
para j:=n descendiendo hasta siguiente+1 hacer
si v[j] < v[j-1] entonces
sin utilizar una fila auxiliar, deje a las bolas formando la
intercambiar(v[j],v[j-1]) bandera nacional holandesa.
fsi
fpara
fpara 1. ESPECIFICACION.
falgoritmo
Precondición: la fila está constituida únicamente por
bolas rojas, blancas y azules, dispuestas en cualquier
K       orden.

  ( 1 n
?
n
1 n n
1 n
1
02?  

1   n  (i  1)  1   n  i 
i 1 j i 1  i 1  i 1
Postcondición:
1 n

n
1 n
1 azul blanco rojo

 n  1   i  ( n 2 )
i 1 i 1 en donde alguna de las zonas puede estar vacía.

61 62

La eficiencia de los algoritmos La eficiencia de los algoritmos

coincide con toda la fila. En el estado final, la zona

2. INVARIANTE. indefinida está vacía.
En un estado intermedio cualquiera, en la fila
-Hay tres bandas formadas por bolas ya revisadas y
3a) El invariante se cumple al empezar la iteración si se
situadas en una posición adecuada.
inicializa:
-Entre unas posiciones “v” y “x” está una banda
u:=0; v:=1; x:=n
indefinida formada por aquellas bolas que aún no se
han revisado.
0 1 n
-El color de cualquier bola de la fila es blanco, rojo o
azul.
u v x

Si se indica con la zona indefinida:

1 n 3b) Para que se cumpla la postcondición, en el
? r invariante se tiene que dar que la zona indefinida
esté vacía, es decir, v>x Por ello, se propone como
u v x guarda
Invariante: v x

i:1iu:color(i)=azul  j:u<j<v:color(j)=blanco Al finalizar el bucle se tendrá v=x+1:

 1 n
azul blanco rojo
 k:x<kn:color(k)=rojo  vx+1

u x v

Nótese que:
Los estados inicial y final aparecen como casos
particulares de este invariante. En el estado inicial, las
bandas de colores están vacías, y la zona indefinida

63 64
 La eficiencia de los algoritmos La eficiencia de los algoritmos

1 n color(v)=blancocolor(v)=azul  color(v)=rojo

? r 1 n
? r
Invariante u v x

Invariante u v x

• Para cada opción, cuando se parte de un estado en que

3c) El invariante debe progresar hacia la postcondición
se cumple IB, la ejecución de la acción
con cada iteración. Para ello, la zona indefinida debe
correspondiente conduce de nuevo al invariante:
decrecer. De hecho, el tamaño (número de bolas) de esta
zona se puede tomar como función limitadora del bucle: I vx color(v)=blanco:
t=x-v+1 1 n
? r
En efecto, I vx ->t>0.
u v x
El cuerpo de la iteración deberá consistir de unas v+1
instrucciones tales que, manteniendo el invariante,
disminuyan la función limitadora: I vx color(v)=azul:
opción: intercambio

1 n
color(v) = blanco: v:=v+1; ? r

color(v) = azul: u:=u+1; perm(v,u); v:=v+1;

u v x
color(v) = rojo: perm(v,x); x:=x-1 u+1 v+1

fopción I vx color(v)=rojo:

Veamos que la "opción" es correcta y mantiene el intercambio
invariante: 1 n
? r
• Siempre se cumple alguna de las guardas. Cabe
recordar que el invariante afirma que cualquiera de las u v x
bolas es de uno de los tres colores que se citan, luego v+1 x-1

65 66

La eficiencia de los algoritmos La eficiencia de los algoritmos

• Es inmediato comprobar que en cualquier caso de la

"opción", la función limitadora decrece. 5.2.2 Búsqueda binaria.

Enunciado del problema:

El algoritmo queda escrito como sigue:
> Búsqueda de un elemento que tiene un valor dado X.
u:=0; v:=1; x:=n;

mientras vx hacer > Inicialmente el vector se encuentra ordenado

opción:
(ascendentemente)

color(v) = blanco: v:=v+1; > Supondremos, por simplicidad, que:

color(v) = azul: u:=u+1; perm(v,u); v:=v+1;
- el vector es de enteros
color(v) = rojo: perm(v,x); x:=x-1 - la cota inferior del vector es 1
fopción - la cota superior del vector es N
fmientras

Definición del problema

Talla = n (tamaño del vector)

algoritmo búsqueda_binaria
n

Coste(n)=  1 (n)
i 1
(datos v: Vector[b1 .. bn ] de TipoBase;
x:TipoBase;

resultados está: lógico)

P = {x = X  v = V ordenado(V) }

Q = {está = (  i: 1 i  N: x = v[i]}

67 68
 La eficiencia de los algoritmos La eficiencia de los algoritmos

Estrategia: como el vector está ordenado Diseño del algoritmo a partir del
ascendentemente, la búsqueda binaria se plantea como invariante
una búsqueda en el subvector donde se puede encontrar
el elemento buscado, subvector de búsqueda. ¿El invariante se cumple al empezar la iteración?
En cada iteración de la búsqueda:
En efecto, al inicio el subvector de búsqueda coincide con
> Acceder al elemento central v[m] del subvector de el vector v, por lo que
búsqueda
izq := 1; der:= N; m : = (izq + der) div 2
> SI:

X = v[m] búsqueda finalizada

X < v[m] buscar en subvector izquierdo v[1] v[2] ... v[m v[n]
]

X > v[m] buscar en subvector derecho izq 2 m der

v[1] v[2] ... v[m v[N Por tanto P inicioI

] ]

1 2 izq m der N

I  {( i:1 i < izq: v[i] < X)# i:der $i N : X<

v[i])
1izqN 1derN 1mN m=(izq+der)div2}

t = der -izq + 1 ó número de elementos del

subvector de búsqueda

69 70

La eficiencia de los algoritmos La eficiencia de los algoritmos

¿El invariante se cumple al terminar la iteración? ¿Se cumple el invariante tras cada iteración?

Las instrucciones que conforman el cuerpo de la iteración

La postcondición deben hacer que el invariante “progrese” hacia la
postcondición con cada iteración. Con ello, el tamaño del
Q = {está = (  i: 1 i  N: x = v[i]} subvector de búsqueda debe decrecer.

se puede alcanzar de dos formas tras salir del bucle: I (v[m] <> X) #izq $der) t = der -izq + 1

está = true v[m] = X Cuerpo_iteración


está = false  i: 1 i N : X<> v[i] I

Por tanto, en la primer iteración

Equivalentemente, se termina sii
v[1] v[2] ... v[m v[n]
v[m] = X izqder ]
<>x

izq 2 m der

Por tanto, seguiremos buscando si

Si v[m] $x, el elemento estará en [m+1 .. der]
B = (v[m] <> X) #izq $der)
v[1] v[2] ... v[m v[n]
]
<>x

1 2 m izq der

Si v[m]x, el elemento estará en [izq .. m-1]

71 72
 La eficiencia de los algoritmos La eficiencia de los algoritmos

Por tanto, el cuerpo de la iteración sería

v[1] v[2] ... v[m v[n]
]
<>x opción
izq 2 der m N
v[m] $x: izq:= m + 1

v[m] x: der:= m - 1

fopción

m := (izq + der) div 2

Veamos que la "opción" es correcta y mantiene el

invariante y hace decrecer la función limitadora:

• Siempre se cumple alguna de las guardas:

si v[m] <> X entonces (v[m] $x)  (v[m] x)

• Para cada opción, cuando se parte de un estado en que

se cumple IB, la ejecución de la instrucción
correspondiente conduce de nuevo al invariante

Opción 1
I v[m] < X izq < der

izq:= m + 1
m := (izq + der) div 2

I
y la función limitadora decrece

73 74

La eficiencia de los algoritmos La eficiencia de los algoritmos

Opción 2 Este problema se soluciona re-escribiendo la opción

I v[m]  X izq < der opción

der:= m - 1 v[m] $x: izq:= m + 1

m := (izq + der) div 2 v[m] x: der:= m

¿I? fopción

y la función limitadora decrece m := (izq + der) div 2

¡CUIDADO!

Supongamos que Ejercicios:

- izq y der son consecutivos: izq = der -1. Por tanto, 1.- Comprobar que con la modificación realizada, la
m = izq función limitadora decrece cuando v[m] x (pista: si
está dentro del bucle izq  der - 1)
- izq =1. Por tanto m = 1
- v[m]  X 2.- Comprobar que si izq y der son consecutivos, pero
v[m] $x no hay problemas.
v[1] v[2]
Por tanto, la búsqueda binaria queda como sigue:
izq= m = der función búsqueda_binaria(v:Vector[1..N]de enteros;
1
x:entero) devuelve Lógico
Al ejecutar la instrucción der :=m -1
var está:Lógico; m, izq, der :entero fvar
¡der := 0!
izq := 1;
¡No se cumple el invariante!
der := N;

75 76
 La eficiencia de los algoritmos La eficiencia de los algoritmos

m := (izq + der) div 2;

mientras (v[m] <> x) #izq $der) hacer B 0 2% 
opción
   /

v[m] $x: izq:= m + 1

v[m] x: der:= m C0D2   

E
fopción

m := (izq + der) div 2 > 
F(  

M
fmientras
> F(  
M


devuelve está := (v[m] = x)
ffuncion > D@<   ?
M
L  
     /
02 )?
D? '

B 
log 2 n

%<9 =

>
67? 1  log
i 1
2 n  (log 2 n)
C0D2   
E
= 
 
 
 D?

"
(
1 coste(n)  O(log2n), coste(n)  (1).
67?
1  1 (1)
i 1

77 78