La Eficiencia de Los Algoritmos

La eficiencia de los algoritmos
TEMA 1
# "

#

LA EFICIENCIA DE LOS ALGORITMOS

& ' ( ) *+ &"
(+, +-%+
INDICE

!
"
#$%

1 2
!"#$%

. -

'

'/ '

0112 %' 3 ' &'()*
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. AddisonWesley Iberoamericana, 1988. S. Sahni: Concepts in Discrete Mathematics. The Camelot Publishing Company, 1985.
4$4$5 67

+, +./5 8 99:
6+!+ )
.!, 99;
#
BIBLIOGRAFA COMPLEMENTARIA
3 4

Normalmente, un problema se puede resolver por mtodos distintos, con distintos grados de eficiencia. Ejemplo: bsqueda de un nmero en una gua telefnica. Cuando se usa un ordenador es importante limitar el consumo de recursos. Recursos: Tiempo: Aplicaciones informticas que trabajan en tiempo real: requieren que los clculos se realicen en el menor tiempo posible. Aplicaciones que manejan un gran volumen de informacin: si no se tratan adecuadamente pueden necesitar tiempos impracticables. Problemas intrnsecamente complejos. Espacio: Las mquinas tienen una memoria limitada.

COSTE = Consumo de estos recursos por parte de un algoritmo.
En esta asignatura nos interesa el estudio del coste temporal.
Si un programa se va a usar una o muy pocas veces, puede darse el caso de que lo ms importante sea que sea fcil de entender, codificar y depurar.
A medida que se dispone de ordenadores ms rpidos, se pretende resolver problemas ms grandes y complejos, por lo que el uso de algoritmos eficientes sigue siendo importante.
FACTORES DE LOS QUE DEPENDEN LOS PARAMETROS DEL COSTE:
APROXIMACIONES AL ANLISIS DE LA EFICIENCIA DE LOS ALGORITMOS (memoria y tiempo de ejecucin): Anlisis experimental o "a posteriori" (se ver en la prcticas de laboratorio). Consiste en ejecutar casos de prueba, haciendo medidas para: una mquina concreta,
A - Factores propios del problema: procedimiento de resolucin del problema, y los datos. B - Factores dependientes de la mquina: tipo de computador, lenguaje de programacin, carga del sistema, etc.
un lenguaje concreto, un compilador concreto y datos concretos. Anlisis terico o "a priori" (se ver en las clases tericas). Consiste en obtener una expresin que indique el comportamiento del algoritmo en funcin de los parmetros que influyan. Interesante porque: La prediccin del coste puede evitar una implementacin posiblemente laboriosa. Es aplicable en la etapa de diseo de los algoritmos, constituyendo uno de los factores fundamentales a tener en cuenta.
En esta asignatura nos interesan los factores propios del problema.
EJEMPLOS:

COMPLEJIDAD (O COSTE) DE UN ALGORITMO: Es una medida de la cantidad de recursos (tiempo, memoria) que el algoritmo necesita. La complejidad de un algoritmo se expresa en funcin del tamao o talla del problema. TALLA DE UN PROBLEMA: Es cualquier parmetro en funcin del cual se pueda expresar la complejidad del problema: N de datos de entrada N de datos de salida Valor de las variables numricas Una funcin de los anteriores Suele guardar relacin con el volumen de los datos a tratar, y por ello se le suele llamar tamao del problema.
1.- Algoritmo de ordenacin: la talla del problema ser el nmero de elementos a ordenar. 2.- Algoritmo de bsqueda de un elemento en una secuencia: la talla del problema ser el nmero de elementos de la secuencia. 3.- Algoritmo del clculo del factorial de un nmero: la talla ser el valor del nmero.
COMO CALCULAR LA COMPLEJIDAD TEMPORAL DE UN ALGORITMO? Contando el nmero de operaciones elementales o pasos de programa que realiza. De esta forma: coste(n) = Nmero de pasos de programa en funcin de n. Es independiente de la mquina concreta utilizada.
10

Son aquellas cuyo tiempo de ejecucin est acotado superiormente por una constante que no depende de la talla del problema. EJEMPLOS DE PASOS DE PROGRAMA: x := y + z 1 paso x := y + z x := x * x 2 pasos ( tambin 1 paso) si x = 0 entonces y := y + 1 sino y := y - 1 fsi 1 paso ( tambin 2 pasos) si x = 0 entonces y := y + 1 fsi 1 paso
EJEMPLOS DE COSTES:
x := x + y coste = 1 paso.
para i := 1 hasta n hacer x := x + y fpara talla = n, coste(n) = n pasos.
para i := 1 hasta n hacer para j := 1 hasta n hacer x := x + y fpara fpara talla = n, coste(n) = n2 pasos.
11
12
GRFICAS DE FUNCIONES
TABLA DE TIEMPOS DE EJECUCIN Tiempos de ejecucin en un mquina capaz de ejecutar 109 pasos de programa por segundo para tallas (n) y costes (en nmero de pasos) dados.
n (Talla) Pasos log2n n nlog2n n
2
1 < 1 ns 1 ns < 1 ns 1 ns 1 ns 2 ns 1 ns 1 ns
8 3 ns 8 ns 24 ns 64 ns 512 ns 256 ns 40 s 17 ms
32 5 ns 32 ns 160 ns 1 s 33 s 4.3 s > 1018 aos > 1031 aos
103 10 ns 1 s 10 s 1 ms
106 20 ns 1 ms 20 ms
109 30 ns 1s 30 s
17 min 38 aos
n3 2n n! nn
> 1010 aos > 10291 > 10300K > 10300M aos aos aos > 102K > 105M >109000M aos aos aos >103K > 106M >109000M aos aos aos 1 s 38 aos
Problemas inabordables
13
14
TALLAS PARA DOS ORDENADORES DE DIFERENTE POTENCIA Talla (n) del problema que puede ejecutarse en un tiempo prefijado, en funcin de la velocidad del computador (que aumenta de V a 10V). N de pasos 300 log2n 100 n 5 n2 n3 / 2 2n n! / 100 nn / 100 n para 10V n para 10V n para V 1010 109 100 10 45 3.2 27 2.3 13 1.3 10 1.1 7 1

De qu depende la complejidad de un algoritmo A? 1. De la talla del problema: n. 2. Para una talla fija, de la instancia del problema. En general obtendremos una expresin del coste distinta para cada instancia: costeA(I,n) = Nmero de pasos de programa para una talla n y una instancia I
n para V 10 10 14 12 10 9 7
A medida que se baja en la tabla, aumenta ms despacio la talla del problema que es posible tratar usando una mquina 10 veces ms rpida. Cuando el coste es lineal (100 n en esta tabla) una mquina 10 veces ms rpida permitir tratar un problema 10 veces ms grande.

Nos interesan las instancias significativas: Ip: peor de los casos. Cuando son necesarios el mximo nmero de clculos. Im: mejor de los casos. Cuando son necesarios el mnimo nmero de clculos.
15
16
Sean: n la talla del problema de A S(n) = { I : I Instancia talla(I) = n } entonces: costeA (n) = mx {costeA(I,n) : I S(n)} = costeA(Ip,n) (coste peor) costeA
m p
EJEMPLOS DE INSTANCIAS 1.- Bsqueda secuencial de un elemento x en un vector a: funcin buscar ( x: elemento; a: vector ndice
de entero; n: ndice) devuelve ndice;
(n) = mn { costeA(I,n) : I S(n)} = costeA(Ip,n)
(coste mejor) costeA

Med
(n) = S(n) P(I) * costeA(I,n)
(coste medio)
{1n k:1kn:ak=x} var i:ndice fvar; i:=1; mientras a[i]x hacer i:=i+1 fmientras; devuelve i {1in ai=x j:1j<i:a[jx} ffuncin
Talla del problema: n. Instancias: x x Caso mejor Caso genrico
Caso peor
17
18
2.- Bsqueda del mximo de un vector a:
funcin mximo(a: vector; n: ndice) devuelve entero;

Una forma alternativa de calcular la complejidad en el peor caso consiste en la identificacin y seguimiento de una instruccin crtica. La instruccin crtica de un algoritmo es la instruccin (o comprobacin) que ms veces se ejecuta independientemente de casos. Si es posible identificar una instruccin crtica en un algoritmo, el coste se puede calcular como el nmero de veces que se repite esta instruccin.
{ 1n } var max:elem; i:ndice fvar; i:=2; max:=a[1]; mientras i<n hacer si a[i] > max entonces max := a[i ] fsi; i := i + 1 fmientras; devuelve max { (j:1jn:a[jmax) (j:1jn:a[j=max) } ffuncin
Talla del problema: n. No existen diferentes instancias significativas (en cualquier caso se recorre todo el vector).
Ejemplo: en el algoritmo de bsqueda del

mnimo podramos tomar la instruccin Si_entonces ya que es la instruccin que ms veces se ejecuta (n-1 veces)
19
20
Ejemplos:

Determinar exactamente costeA y coste A puede resultar difcil; no tiene mucho sentido si hablamos de pasos de programa; puede resultar excesivamente laborioso si slo necesitamos calcular la complejidad de un algoritmo para compararlo con otros durante la fase de diseo, antes de conocerlo en detalle.
p m
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 ms eficiente que A'. Pero el uso de un ordenador suficientemente rpido para ejecutar A hara que este algoritmo se ejecutase siempre en menos tiempo que A en el ordenador original. Por lo tanto, los avances tecnolgicos podran 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 ms eficiente que A para n = 1, 2; A y A son igual de eficientes para n = 3; A es ms eficiente que A para n > 3.
21
22
CONSIDERACIONES: Interesa estudiar el comportamiento de un algoritmo para tallas relativamente grandes: complejidades asintticas. Interesa comparar los comportamientos de los algoritmos segn el orden de magnitud de sus complejidades. Interesa hacer estudios de la complejidad independientes de la velocidad del computador donde se programa el algoritmo desarrollado. Esto significa que funciones de complejidad que difieren en un factor constante se consideran idnticas a efectos de medidas de costes. Por lo tanto, para el clculo de la complejidad adoptaremos un CRITERIO ASINTOTICO.
/0
Objetivo: obtener una notacin clara y simple para expresar el coste de un algoritmo para valores grandes de la talla y con independencia de la velocidad del ordenador utilizado. En lo que sigue, f, g, f1, f2, y f3 sern funciones de N en R+. (R+ = { x R: x > 0 } en este tema.)
23
24
NOTACION O Definicin. Se dice que - f es como mucho del orden de g, o que - f crece ms lentamente o igual que g, o que - g es una cota superior de f, sii c>0, n0 N: f(n) c g(n) n
n0 Definicin. O(g(n)) = { funciones que son como mucho del orden de g(n) } Ejemplos. 1.- 3n O(n): Si se toma C=3 y n0=0 se tiene f(n) = 3n 3n = Cg(n) n0. 2.- 3n O(n ): Si se toma C=3 y n0=0 se tiene f(n) =3n Cg(n) = 3n n0.
2 2
NOTACION Definicin. Se dice que - f es como mnimo del orden de g, o que - f crece ms rpidamente o igual que g, o que - g es una cota inferior de f, sii c>0, n0 N: c g(n) f(n) n
n0 Definicin. (g(n)) = { funciones que son como mnimo del orden de g(n) } Ejemplos. 1.- 3n (n): Si se toma C=1 y n0=0 se tiene Cg(n) = 1n 3n = f(n) n0. 2.- n2 (3n): Si se toma C=1 y n0=3 se tiene Cg(n) = 13nn2 = f(n) n3.
25
26
NOTACION Definicin. Se dice que - f es del orden de g, o que - f crece igual de rpidamente que g, o que - 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 Definicin. (g(n)) = { funciones que son del orden de g(n) }
b) 3n (n) ( Definicin. Se dice que
).
- f es de menor orden que g, o que - f crece ms lentamente que g, sii f(n) O(g(n)) pero f(n) (g(n)).
Definicin. Se dice que - f es de mayor orden que g, o que - f crece ms rpidamente que g, sii f(n) (g(n)) pero f(n) (g(n)).
!

Proposicin. 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)) Ejemplo. 3n (n), pues a) 3n O(n) (visto anteriormente).
TEOREMA. 1- f es de menor orden que g sii O(f(n)) O(g(n)). 2- f es de mayor orden que g sii (f(n)) (g(n)). Nota: denota en este tema la inclusin estricta.
27
28
Los siguientes teoremas son tiles para comparar tasas de crecimiento de funciones.
COROLARIO a. Si p es un polinomio de grado r, entonces p es del mismo orden que nr. b. n , con >1 constante, crece rpidamente que cualquier polinomio. ms
TEOREMA
f (n) K 0 (f(n)) (g(n)) n g ( n) lim
c. Si 1>K2>1, entonces n crece ms rpidamente que n, pero log(n) es del mismo orden que log(n). d. Cualquier polinomio crece ms rpidamente que log(n).
(f y g son del mismo orden).
TEOREMA
n
e. n! crece ms rpidamente que n.

f(n ) crece ms rpidamente que g(n),
lim
g (n)
f ( n)
f.
nn crece ms rpidamente que n!.
o lo que es lo mismo: O(g(n)) O(f(n)).
TEOREMA
n
lim
g (n)
f ( n)
0 g(n ) crece ms rpidamente que f(n).
o lo que es lo mismo: O(f(n)) O(g(n)).
29
30
"

Muchas veces las notaciones asintticas pueden aparecer dentro de expresiones, por ejemplo:
&1&%#"#"2(& Para calcular el coste de un algoritmo: En primer lugar hay que determinar la talla del algoritmo. En los algoritmos en los que el coste temporal sea independiente de las instancias, es decir, cuando el caso mejor y el peor coincidan, utilizaremos directamente la notacin para estimar la complejidad del algoritmo: coste (n) (f(n)). En los algoritmos en los que el coste temporal vare en funcin de las instancias, podremos distinguir: Peor caso y Mejor caso.
f(n ) = n2 + O(1/n)
significa que f(n ) es una funcin cuadrtica ms un trmino asinttico menor que 1/n. Se debe de entender como suma de conjuntos de funciones.
f(n ) n2 + O(1/n)
#$%

COROLARIO a) De menor a mayor orden: O(1) O(log(n)) O(n) O(nlog(n)) O(n )O(n ) ... O(K ) O(n!) O(n ). b) De mayor a menor orden: (1) (log(n)) (n) (nlog(n)) (n ) (n ) ... (K ) (n!) (n ).
2 3 n n 2 3 n n
31
32
PEOR CASO: Utilizaremos la notacin (o la si fuera necesario) para estimar la complejidad del algoritmo en el peor de los casos: costep (n) (f(n)), con lo que obtendremos una cota superior de la complejidad del algoritmo: costeA(n) (f(n)).
EJEMPLOS. 1. Para el algoritmo de bsqueda secuencial: Talla del problema: n. Instancias significativas: caso mejor, caso peor. costep(n) (n) costem(n) (1) Por lo tanto: coste(n) (n)
MEJOR CASO: Utilizaremos la notacin (o la si fuera necesario) para estimar la complejidad del algoritmo en el mejor de los casos: costeA (n) (g(n)), con lo que obtendremos una cota inferior de la complejidad del algoritmo: costeA(n) (g(n)).
m
coste(n) (1)
2. Bsqueda del mximo de un vector: Talla del problema: n. Instancias: no hay instancias significativas que afecten al coste. En cualquier caso se recorre todo el vector. coste(n) (n).
33
34

#"131/"#%/"2&"!//
2&"!///"&%1%#(41"%
Procedimiento a seguir: 1. Determinar qu parmetro(s) nos da(n) la talla o tamao del problema, en funcin de la cual se expresar la complejidad. 2. Identificar el caso peor y el caso mejor de comportamiento del algoritmo en cuanto a consumo de tiempo (o de espacio si se estudia la complejidad espacial). 3. Aplicar un mtodo de obtencin de las cotas de complejidad. Vamos a estudiar la complejidad de las siguientes instrucciones: operaciones bsicas, secuencia de instrucciones, sentencia alternativa, y sentencia iterativa.
Complejidad Temporal: se calcula contando el nmero de pasos de programa de cada instruccin en funcin de la talla del problema.
Operaciones bsicas. Se van a considerar como pasos de programa las operaciones bsicas: asignacin, comparacin, operaciones aritmticas, 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
Secuencia de instrucciones ( S = S1 ; S2). coste( S ) = coste( S1 ) + coste( S2 ) Caso especial: para grandes tallas, puede darse que una de las instrucciones tenga coste despreciable frente a la otra, con lo que se podr aplicar el siguiente resultado: coste( S 1 ) ( f1 ) coste( S2 ) ( f2 ) O( f1 ) O( f2 ) Ejemplos. 1. Supongamos que: coste( S1 ) = 2n + 3 (n), coste( S2 ) = 5n + 1 (n). Entonces coste( S1 ; S2 ) = 7n + 4 (n). 2. Supongamos que: coste( S1 ) = 3n + 1 (n), coste( S2 ) = 7n2 (n2). Entonces coste( S1 ; S2 ) (n2). coste( S ) ( f2 )
Sentencia alternativa si .. fsi. Si B entonces S1 sino S2 fsi
coste( SI ) = coste( B ) + coste( S1 S2 ), dependiendo de la accin (S1 S2) que se ejecute: B cierta se ejecutar S1 coste( SI ) = coste( B ; S1 ) B falsa se ejecutar S2 coste( SI ) = coste( B ; S2 ) Si denotamos: coste( B ) ( g ), coste( S1 ) ( f1 ), coste( S2 ) ( f2 ), en la prctica se suelen dar los siguientes casos: Costes parciales O( g ) O( f1 ) = O( f2 ) O( g ) O( f1 ) O( f2 ) coste( SI ) ( f1 ) ( f1 ), O( f2 )
37
38
Sentencia iterativa mientras ... fmientras. Mientras B hacer S fmientras
Casos Prcticos Caso 1. Se realizan n iteraciones, y la i-sima p iteracin (guarda + cuerpo) tiene un coste i , con p constante.
n
Sea n el nmero de iteraciones que de hecho se ejecutan la ejecucin de la instruccin anterior ser equivalente en efectos y en coste a la ejecucin de: 1 iteracin B ; S; ... n iteracin B ; S; (falla B) B
Coste =
i 1
ip
n p 1 n p (n p1 ) p1 2
Coste (np+1)
(Nota: B es una funcin y no un procedimiento, por lo que el cuadro anterior contiene una imprecisin.) coste( Mientras ) = i = 1..n coste( B(i) ; S(i) ) + coste( B(i+1) ) donde
(i)
Ejemplo: Para i := n decreciendo hasta 1 hacer escribe_letra(a, i) fpara, en donde escribe_letra(a, i) escribe i veces el carcter a y tiene un coste (i). La talla del problema es n, y su coste ser: coste =
hace referencia a la i-sima iteracin.
Puesto que los costes parciales anteriores pueden ser distintos en cada iteracin del bucle, la casustica que puede presentarse es muy variada.
i (n
i 1
).
39
40
Son habituales los siguientes subcasos:
p=0 p=1 p=2
1 n ( n ) .
i 1 n
Ejemplo: bsqueda ordenado.
dicotmica
en
un
vector
i
i 1 n

n( n 1) ( n 2 ) . 2 n(n 1)(2n 1) ( n 3 ) . 6
i
i 1
Caso 2: Medidas logartmicas. Supongamos que en cada iteracin la talla n se reduce en un factor c, hasta llegar a una talla mnima n0 >0 para la que se da la condicin de salida del bucle. Tras la 1 iteracin: la talla pasa a n/c 2 Tras la 2 " : " n/c ..................................................... y tras una q-sima iteracin, la talla se reduce a n0. Como se tendr que n/c iteraciones ser:
k
{ v est ordenado } procedimiento dicotmica (v: vector 1..n

de entero; n, x: entero; sal est: lgico; sal m: entero) es var i,j: entero fvar; i:=1 ; j:=n; est := falso; repetir m := (i+j) div 2; opcin v[m] > x: j := m - 1; v[m] < x: i := m + 1; v[m] = x: est := verdadero; fopcin hasta que i>j est fprocedimiento {1mn((est vm=x) (est k:1kn:vkx)}
La talla del problema es la dimensin del vector. Se puede considerar la talla como un valor dinmico que tras cada iteracin es la longitud de la zona del vector donde an no se ha descartado que pueda estar x.
= n0, el nmero de
k = logc (n/n0).
41
42
Caso peor: x no est en el vector, y por lo tanto en nmero de iteraciones es mximo. costep(n) = 1 + coste_iteracin = 1 + (1 + coste_si + coste_guarda)*(n iteraciones) = 1 + K*(n iteraciones). El clculo del nmero de iteraciones en este caso es un ejemplo de reduccin logartmica. Tras cada iteracin se reduce la talla aproximadamente a la mitad, hasta llegar a un tamao 1. Por ello, el nmero de iteraciones es log2n. Luego costep(n) = 1 + Klog2n (log2n).
&!
!

( <3 ' /
/ '
-
'
.

=
(//
>
+ Definicin del problema

!""# !""" $
Caso mejor: se encuentra de inmediato el elemento y la iteracin cesa: costem(n) (1). En resumen: coste(n) O(log2n), coste(n) (1).
43
44
: vector x entero x entero lgico Para v1 vector, i,j entero ordenado(v1) = ( k: i k <j: v[k
v[k+1
)
: vector x vector x entero x entero lgico Para v1,v2 vector, i,j entero perm(v1,v2,i,j)= ( k: i k j: (( t: i t j: v1[k
=v2[t
) nveces(v1[k
, v1,i,j) = nveces(v1[k
,v2,i,j) ))
Estrategia para la ordenacin:

1.- Considerar el vector dividido en dos zonas: - elementos que ya estn ordenados - elementos por reubicar.
2.- Se utiliza una variable i para marcar el lmite entre ambas zonas.
INVARIANTE:
1 i-1 i n
/: TipoBase x vector x entero x entero entero Para e TipoBase, v vector, i,j entero nveces(e,v,i,j) = k: i k j: igual (v[k
,e) ' : TipoBase x TipoBase {1,0} Para x,y TipoBase igual(x,y)= 1 sii igual(x,y)=0 sii x=y xy designa las posiciones que contienen elementos ordenados entre s, posiciones cuyos necesariamente ordenados. elementos no estn k : 1 k < i - 1: v[k] v[k+1] 1 i 1 n
Funcin limitadora t = n - i + 1
45
46
Diseo del algoritmo a partir del invariante:

- El invariante se cumple inicializando i a 2, ya que inicialmente el primer elemento est ordenado con respecto a si mismo

- La iteracin debe acabar cuando el vector est totalmente ordenado.
1 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

- El cuerpo de la iteracin, S, deber conseguir que en cada pasada se reduzca la zona desordenada funcin limitadora, t = n -i +1 ? El problema es lo suficientemente complejo como para que esta instruccin sea a su vez una iteracin ! Las diferentes propuestas que se pueden hacer para S conducen a diferentes algoritmos de ordenacin
RESUMEN: Estructura algortmica general para la ordenacin
P = {v = V} i:=2; mientras i n hacer S; i:=i+1 fmientras
Q = {ordenado(V, 1, n) v = perm(V)}
i-1 i
Invariante Funcin limitadora t = n -i +1
49
50
Ordenacin por insercin

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

{
1pi
v[i]
>v[i]
x := v[i]; 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
los pasos 1 y 2 se pueden realizar de forma simultnea! Reformulacin en un paso de insertar ordenadamente v[i] en v[1 .. i - 1] {i n ordenado(v, 1, i-1) v[1 .. i-1] = perm(V, 1, i-1)} p:=i; x:=v[i]; mayor:=true; mientras (p>1) mayorhacer si v[p-1]<=x entonces mayor:=false sino v[p]:=v[p-1]; p:=p-1
> ?@A?
( B '% B@ C0D2 E =

D? 02? 1 1 (1)
1 i 1

( B
%3% B@ C0D2 E > F(
@ > F(
@ G > DF(
@D?H @D?H
D? 02? 1 i (i)
j 1 i
fsi; fmientras; {p = 1 !(mayor)} v[p]:= x; {(i n) ordenado(v, 1, i) v[1 .. i] = perm(V, 1, i)}
53
54
i := 2; mientras i n hacer insertar ordenadamente v[i] en v[1..i-1]; i := i + 1 fmientras > ? ( El vector est ya ordenado coste(n) (n)
( El vector est ordenado al revs coste(n) (n2) ( El vector est ya ordenado C0D2 E F(
@ > F(
@ > F(
@ G > DF(
@0DA2?H @D@?H
D?@
" 5insertar ordenadamente v[i] en v[1..i-1],

67 02? 1 n 1 (n)
i 1 n 1

( / /< " 5insertar ordenadamente v[i] en v[1..i-1],58

69 7
= F0?20/IJ/2 = F0?20/IJ/2 G = - 0?20/IJ@/2@
67 =
i
i 1
n 1
(n 1) (1 (n 1)) (n 2 ) 2
Ejercicio: Disear el algoritmo para insertar ordenadamente v[i] en v[1 .. i - 1] utilizando bsqueda binaria. En este caso, el mtodo de ordenacin se conoce con el nombre de Insercin binaria. Comprese el diseo obtenido con el presentado anteriormente.
55
56
Ordenacin por seleccin

El algoritmo de ordenacin por seleccin propone para S una iteracin basada en la siguiente idea:
1 i-1 i n

- El invariante se cumple inicializando i a 1, para que pueda buscar el primer mnimo en el intervalo [1 .. n]
1 n
I= I= Tras cada iteracin, cualquier elemento de menor o igual que cualquier elemento de Esto es, se aumenta el tamao de la zona ordenada situando en la posicin i el mnimo de v[i .. n] es
- La iteracin debe acabar cuando el vector est totalmente ordenado. Recordemos que mnimo(v, n, n) = v[n] el ltimo elemento YA estar ordenado! Por tanto, realizamos n-1 pasadas de ordenacin y terminamos cuando i = n
" k : 1 k < i-1 :v[k] v[k+1] 1 i n m : 1< i m n : v[i-1] v[m]} tn-i+1
!B = (i = n)
B = ( i n -1)
- Para poder disminuir el tamao de la zona desordenada, pos_min := mnimo(v, i, n); x:= v[pos_mn]; v[pos_mn]:=v[i]; v[i]:=x; i:=i+1
57 58
donde mnimo(v,i,n):
algoritmo mnimo (DATOS v:vector[1..n]de TipoBase; inicio,fin:1..n; RESULTADOS p:inicio..fin) var siguiente:entero fvar siguiente:=inicio+1; p:=inicio; mientras siguiente<=fin hacer si v[siguiente]< v[p] entonces p:=siguiente; siguiente:=siguiente+1; fmientras devuelve p falgoritmo
0 2?
1 ( m )
i 1
m 1
algoritmo ordenar (DATOS v:vector[1..n]de TipoBase; RESULTADOS v: vector [1..n] de TipoBase) var i:entero fvar i:=1; mientras i<n hacer p:=mnimo(v,i,n); intercambiar(v[i],v[p]); i:=i+1; fmientras falgoritmo
0/2

mientras siguiente<=fin hacer si v[siguiente]< v[p] entonces p:=siguiente; siguiente:=siguiente+1; fmientras
Talla = n
C0D2 E > F(
@ > F(
@ G > DF(
@D? @D?
D?@ " 5
. :6;5575 8
9 = F0?2 0/2 = F0?2 0/2@ G
60
Talla = fin - inicio +1=m

C0D2 E F(
@ > F(
@ G > DF(
@0DA2?H @D@?H
D? @
59
= - 0?@2 0/@2

n1 i 1 n1 i 1
5.2- Otros algoritmos sobre vectores. 5.2.1La bandera nacional holandesa
02?
(n (i 1)) n i 1 (n )

2
Sea una fila de n bolas de color blanco, rojo y azul. Sea un brazo mecnico capaz de efectuar las operaciones: color(i): averigua el color de la bola que se encuentra en la posicin i-sima de la fila.
"

algoritmo ordenar (DATOS v:vector[1..n]de TipoBase; RESULTADOS v: vector [1..n] de TipoBase) var siguiente: entero fvar para siguiente:=1 hasta n-1 hacer para j:=n descendiendo hasta siguiente+1 hacer si v[j] < v[j-1] entonces intercambiar(v[j],v[j-1]) fsi fpara fpara falgoritmo
perm(i,j): posiciones.
permuta
las
bolas
de
estas
Se pide un algoritmo iterativo que en una sola pasada sobre la fila, realizando como mucho n intercambios, y sin utilizar una fila auxiliar, deje a las bolas formando la bandera nacional holandesa. 1. ESPECIFICACION. Precondicin: la fila est constituida nicamente por bolas rojas, blancas y azules, dispuestas en cualquier orden.
1 ? n
K

( 02?
1 n (i 1) 1 n i
i 1 j i 1 i 1 i 1
n 1
n 1
n 1
Postcondicin:
1 azul blanco rojo n
n 1 i ( n 2 )
i 1 i 1
n 1
n 1
en donde alguna de las zonas puede estar vaca.
61
62
2. INVARIANTE. En un estado intermedio cualquiera, en la fila -Hay tres bandas formadas por bolas ya revisadas y situadas en una posicin adecuada. -Entre unas posiciones v y x est una banda indefinida formada por aquellas bolas que an no se han revisado. -El color de cualquier bola de la fila es blanco, rojo o azul. Si se indica con
1 ? u v x r
coincide con toda la fila. En el estado final, la zona indefinida est vaca.
3a) El invariante se cumple al empezar la iteracin si se inicializa: u:=0; v:=1; x:=n
0 1
u v
la zona indefinida:
n
Invariante: i:1iu:color(i)=azul j:u<j<v:color(j)=blanco k:x<kn:color(k)=rojo vx+1
3b) Para que se cumpla la postcondicin, en el invariante se tiene que dar que la zona indefinida est vaca, es decir, v>x Por ello, se propone como guarda v x Al finalizar el bucle se tendr v=x+1:
1 azul blanco rojo n
x v
Ntese que: Los estados inicial y final aparecen como casos particulares de este invariante. En el estado inicial, las bandas de colores estn vacas, y la zona indefinida
63
64
1 ? r x
color(v)=blancocolor(v)=azul color(v)=rojo

1 ? r x n
Invariante
Invariante 3c) El invariante debe progresar hacia la postcondicin con cada iteracin. Para ello, la zona indefinida debe decrecer. De hecho, el tamao (nmero de bolas) de esta zona se puede tomar como funcin limitadora del bucle: t=x-v+1 En efecto, I vx ->t>0. El cuerpo de la iteracin deber consistir de unas instrucciones tales que, manteniendo el invariante, disminuyan la funcin limitadora: opcin: color(v) = blanco: v:=v+1; color(v) = azul: u:=u+1; perm(v,u); v:=v+1;
u v 1 u v
Para cada opcin, cuando se parte de un estado en que se cumple IB, la ejecucin de la accin correspondiente conduce de nuevo al invariante: I vx color(v)=blanco:
1 ? x r n
v+1
I vx color(v)=azul:

intercambio n ? x r
color(v) = rojo: perm(v,x); x:=x-1 fopcin Veamos que la "opcin" es correcta y mantiene el invariante: Siempre se cumple alguna de las guardas. Cabe recordar que el invariante afirma que cualquiera de las bolas es de uno de los tres colores que se citan, luego
u+1 v+1
I vx color(v)=rojo:

intercambio 1 ? u v v+1 x x-1 r n
65
66
Es inmediato comprobar que en cualquier caso de la "opcin", la funcin limitadora decrece.
5.2.2 Bsqueda binaria. Enunciado del problema:
El algoritmo queda escrito como sigue:

u:=0; v:=1; x:=n; mientras vx hacer opcin: color(v) = blanco: v:=v+1; color(v) = azul: u:=u+1; perm(v,u); v:=v+1; color(v) = rojo: perm(v,x); x:=x-1 fopcin fmientras
> Bsqueda de un elemento que tiene un valor dado X. > Inicialmente el vector se encuentra ordenado (ascendentemente) > Supondremos, por simplicidad, que: - el vector es de enteros - la cota inferior del vector es 1 - la cota superior del vector es N
Definicin del problema Talla = n (tamao del vector) algoritmo bsqueda_binaria
Coste(n)=
1 ( n )
i 1
(datos v: Vector[b1 .. bn ] de TipoBase; x:TipoBase; resultados est: lgico) P = {x = X v = V ordenado(V) } Q = {est = ( i: 1 i N: x = v[i]}
67
68
Estrategia: como el vector est ordenado ascendentemente, la bsqueda binaria se plantea como una bsqueda en el subvector donde se puede encontrar el elemento buscado, subvector de bsqueda.
En cada iteracin de la bsqueda: > Acceder al elemento central v[m] del subvector de bsqueda > SI: X = v[m] bsqueda finalizada
Diseo del algoritmo a partir del invariante

El invariante se cumple al empezar la iteracin?
En efecto, al inicio el subvector de bsqueda coincide con el vector v, por lo que izq := 1; der:= N; m : = (izq + der) div 2
X < v[m] buscar en subvector izquierdo X > v[m] buscar en subvector derecho
v[1] v[2]
...
v[m ] m
v[n]
izq
der
v[1] v[2]
...
v[m ] izq m der
v[N ] N
Por tanto
P inicioI
I {( i:1 i < izq: v[i] < X)# i:der $i N : X< v[i]) 1izqN 1derN 1mN m=(izq+der)div2} t = der -izq + 1 nmero de elementos del subvector de bsqueda
69 70
El invariante se cumple al terminar la iteracin?
Se cumple el invariante tras cada iteracin? Las instrucciones que conforman el cuerpo de la iteracin deben hacer que el invariante progrese hacia la postcondicin con cada iteracin. Con ello, el tamao del subvector de bsqueda debe decrecer. I (v[m] <> X) #izq $der) t = der -izq + 1 Cuerpo_iteracin I Por tanto, en la primer iteracin
La postcondicin Q = {est = ( i: 1 i N: x = v[i]} se puede alcanzar de dos formas tras salir del bucle: est = true v[m] = X est = false i: 1 i N : X<> v[i] Equivalentemente, se termina sii v[m] = X izqder
v[1] v[2]
...
v[m ] <>x m
v[n]
izq
der
Por tanto, seguiremos buscando si B = (v[m] <> X) #izq $der)
Si v[m] $x, el elemento estar en [m+1 .. der]

v[1] v[2] ... v[m ] <>x m izq v[n]
der
Si v[m]x, el elemento estar en [izq .. m-1]
71
72
v[1] v[2]
...
v[m ] <>x der m
v[n]
Por tanto, el cuerpo de la iteracin sera opcin
izq
v[m] $x: izq:= m + 1 v[m] x: der:= m - 1 fopcin m := (izq + der) div 2
Veamos que la "opcin" es correcta y mantiene el invariante y hace decrecer la funcin limitadora: Siempre se cumple alguna de las guardas: si v[m] <> X entonces (v[m] $x) (v[m] x) Para cada opcin, cuando se parte de un estado en que se cumple IB, la ejecucin de la instruccin correspondiente conduce de nuevo al invariante Opcin 1 I v[m] < X izq < der izq:= m + 1 m := (izq + der) div 2 I y la funcin limitadora decrece
73 74
Opcin 2 I v[m] X izq < der der:= m - 1 m := (izq + der) div 2 I? y la funcin limitadora decrece CUIDADO! Supongamos que - izq y der son consecutivos: izq = der -1. Por tanto, m = izq - izq =1. Por tanto m = 1 - v[m] X
v[1] v[2]
Este problema se soluciona re-escribiendo la opcin opcin v[m] $x: izq:= m + 1 v[m] x: der:= m fopcin m := (izq + der) div 2
Ejercicios: 1.- Comprobar que con la modificacin realizada, la funcin limitadora decrece cuando v[m] x (pista: si est dentro del bucle izq der - 1) 2.- Comprobar que si izq y der son consecutivos, pero v[m] $x no hay problemas. Por tanto, la bsqueda binaria queda como sigue:
izq= m = 1 der funcin bsqueda_binaria(v:Vector[1..N]de enteros; x:entero) devuelve Lgico
Al ejecutar la instruccin der :=m -1

var est:Lgico; m, izq, der :entero fvar
der := 0! No se cumple el invariante!
izq := 1; der := N;
75
76
m := (izq + der) div 2; mientras (v[m] <> x) #izq $der) hacer opcin v[m] $x: izq:= m + 1 v[m] x: der:= m fopcin m := (izq + der) div 2 fmientras devuelve est := (v[m] = x) ffuncion
B 0 2% / C0D2
E > F(
M > F(
M
> D@< ? M )?D? '
L
/ 02 B %<9 =
> C0D2 E =

D?
log 2 n
67?
1 log
i 1
n (log 2 n)
"
(
67?
1 1 (1)
i 1
77
coste(n) O(log2n), coste(n) (1).
78

La Eficiencia de Los Algoritmos

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

La Eficiencia de Los Algoritmos

Cargado por

Copyright:

Formatos disponibles

La eficiencia de los algoritmos