Departamento de Informtica Universidad de Valladolid Campus de Segovia ______________________

TEMA 5: COMPLEJIDAD ALGORTMICA

COMPLEJIDAD ALGORTMICA
Conceptos bsicos. Medidas de comportamiento asinttico. Reglas prcticas para hallar el coste tiles matemticos Complejidad de algoritmos de bsqueda y ordenacin

DEFINICIN DE ALGORITMO
Un algoritmo implica la descripcin precisa de los pasos a seguir para alcanzar la solucin de un problema dado. Por pasos se entiende el conjunto de acciones u operaciones que se efectan sobre ciertos objetos. Algoritmo: Entrada Proceso Salida

CARACTERSTICAS DE UN ALGORITMO

Un algoritmo debe poseer las siguientes caractersticas:

Precisin: Un algoritmo debe expresarse sin ambigedad. Determinismo: Todo algoritmo debe responder del mismo modo antes las mismas condiciones. Finito: La descripcin de un algoritmo debe ser finita.

CUALIDADES DE UN ALGORITMO
Un algoritmo debe ser adems:
General: Es deseable que un algoritmo sea capaz de resolver una clase de problemas lo ms amplia posible. Eficiente: Un algoritmo es eficiente cuantos menos recursos en tiempo, espacio (de memoria) y procesadores consume.

Por lo general es difcil encontrar un algoritmo que rena ambas por lo que se debe alcanzar un compromiso que satisfaga lo mejor posible los requisitos del problema.

COMPLEJIDAD ALGORITMICA.
La complejidad algortmica representa la cantidad de recursos (temporales) que necesita un algoritmo para resolver un problema y por tanto permite determinar la eficiencia de dicho algoritmo. Los criterios que se van a emplear para evaluar la complejidad algortmica no proporcionan medidas absolutas sino medidas relativas al tamao del problema.

EL TIEMPO EMPLEADO POR EL ALGORITMO SE MIDE EN PASOS

La medida del tiempo tiene que ser independiente:
de la mquina del lenguaje de programacin del compilador de cualquier otro elemento hardware o software que influya en el anlisis.

Para conseguir esta independencia una posible medida abstracta puede consistir en determinar cuantos pasos se efectan al ejecutarse el algoritmo.

COMPLEJIDAD ALGORITMICA. CONCEPTOS BSICOS

El tiempo empleado por el algoritmo se mide en pasos. El coste depende del tamao de los datos. A la hora de evaluar el coste se debe de tener en consideracin tres posibles casos:
El coste esperado o promedio El coste mejor El coste peor

Si el tamao de los datos es grande lo que importa es el comportamiento asinttico de la eficiencia.

EL COSTE EN TIEMPO DEPENDE DEL TAMAO DE LOS DATOS

El tiempo requerido por una algoritmo es funcin del tamao de los datos. Por esta razn la complejidad temporal se expresa de la siguiente forma:
T(n)

Dependiendo del problema, el tamao del dato representa cosas diferentes:

el nmero en s el nmero de dgitos o elementos que lo compone.

Otra caracterstica importante es que no todos los datos, dentro de un problema, poseen la misma importancia de cara a la complejidad algortmica.

EL COSTE EN TIEMPO DEPENDE DEL TAMAO DE LOS DATOS

Ejemplo 1: Algoritmo que determina la paridad de un nmero restando 2 sucesivamente mientras el resultado sea mayor que 1 para finalmente comprobar el resultado.
El problema tendr n DIV 2 restas (depende de n).

Ejemplo 2: Algoritmo de suma lenta

while b>0 do begin a:=a+1; b:=b-1; end; En este caso T=T(b).

EL COSTE ESPERADO, EL MEJOR Y EL PEOR

Otra caracterstica es que la complejidad algortmica no slo depende del tamao sino del propio dato en s.

EL COSTE ESPERADO, EL MEJOR Y EL PEOR

type tintervalo=0..N; tvector=array[1..N] of integer FUNCTION Busquedasecord(v:tvector;elem:telem):tintervalo var i:tintervalo; begin En este algoritmo se pueda i:=0; dar las siguientes situaciones: repeat - Caso mejor: el elemento este en la primera posicin. i:=i+1; - Caso peor: Se tenga que until (v[i]>=elem) or (i=N); recorrer todo el vector. if v[i]=elem then - Caso promedio o esperado: Puesto que todas la posiciones Busquedasecord:=i son equiprobables el tiempo else ser n/2 pasos. Busquedasecord:=0 End;

EL COSTE ESPERADO, EL MEJOR Y EL PEOR. NOTACIN

Tmax(n): Representa la complejidad temporal en el peor de los casos. Tmin(n): Representa la complejidad en el mejor de los casos posibles. Tmed(n): Expresa la complejidad temporal en el caso promedio. Para su clculo se suponen que todas las entradas son equiprobables.

EL COSTE ESPERADO, EL MEJOR Y EL PEOR. EJEMPLO

Clculo de Tmax, Tmin, y Tmed para el algoritmo de bsqueda secuencial ordenada: Nomenclatura del tiempo constante empleado por las siguientes operaciones:
suma:s comparacin: c asignacin: a

EL COSTE ESPERADO, EL MEJOR Y EL PEOR. EJEMPLO

Tmin: Este tiempo se calcula cuando v[1]>=elem.
Tmin=3a+3c+s=constante

Tmax:Este tiempo se calcula cuando v[n]<=elem

Tmax=a +n(s+2c+a)+c+a=n(s+2c+a)+2a+c Tmax=K1n+K2

EL COSTE ESPERADO, EL MEJOR Y EL PEOR. EJEMPLO

Tmed:Este tiempo se calcula considerando cualquier entrada equiprobable. Si T(j)=jK1+K2 Entonces:
T T = T (n ) = (n ) =
n

med

T ( j)P + k =

donde

P = 1 n

j =1

med

( jk
j =1

)1

= + 1 )n + k 2

med

j =1

k1 n

j + k

j =1

k 2 n + 1

k1 n k
2

(n
=

(n ) =

(n

)+

k1n k1 + + k 2 2

= c1n + c

LO IMPORTANTE ES EL COMPORTAMIENTO ASINTTICO

Tiempos empleados para el clculo de algoritmos con distintos ordenes, considerando que el computador en cuestin ejecuta 1 Milln de operaciones por segundo (1MHz).
n T(n)

log n
3.3 10-6 5.6 10-6 6.6 10-6 10-5 1.3 10-5 1.6 10-5 2 10-5

n
10-5 5 10-5 10-4 0.001 0.01 0.1 1

n log n
3.3 10-5 2.8 10-4 6.6 10-4 0.01 0.13 1.6 19.9

n2
10-4 0.0025 0.01 1 100 104 106

n3
0.001 0.125 1 1000 106

2n
0.001

n!
3.63

10 50 100 103 104 105 106

intratable intratable intratable intratable intratable intratable intratable intratable

intratable intratable intratable intratable intratable intratable

MEDIDAS DEL COMPORTAMIENTO ASINTTICO EJEMPLO

60 50 40 Pasos 30 20 10 0 1 2 3 Tamao datos 4 5

en

2n2 8n 20lg n

300 250 200 Pasos 150 100 50 0 1 3 5 7 9 11 13 15 17 19 21 23 Tamao dato 25

en

2n2

8n 20lg n

MEDIDAS DEL COMPORTAMIENTO ASINTTICO

El orden de la funcin T(n) expresa el comportamiento dominante para los datos de gran tamao. Para poder determinar y expresar correctamente el comportamiento asinttico es conveniente disponer de una adecuada notacin. A continuacin se presentan las notaciones:
O mayscula Mayscula mayscula

NOTACIN O MAYSCULA
Definicin: Sean f,g:Z+ R+ , se dice que fO(g) o que f es del orden de g si existen constantes no Z+ y R+ tales que:
f(n) g(n) para todo nno

Esto significa que f no crece ms deprisa que g. De esta forma acotamos superiormente el comportamiento asinttico de la funcin salvo constantes. Para el algoritmo de Bsqueda secuencial ordenada:
Tmax(n)=k1n+k2 O(n) ya que k1n+k2 n para todo nk2/(-k1)

Todas las funciones de tiempo constante son O(1).

PROPIEDADES DE LAS NOTACIN. ESCALABILIDAD

O(logan)=O(logbn) Por esta razn no es necesario especificar la base del logaritmo: O(log n).

PROPIEDADES DE LAS NOTACIN. REGLA DE LA SUMA

Regla de la suma: Si f1O(g1) y f2O(g2) entonces f1+f2 O(max(g1,g2)). La generalizacin de esta regla junto con la propiedad de la escalabilidad se expresa de la siguiente forma:
Si fi O(f) para todo i=1....k entonces: c1f1+......+ckfk O(f). De donde cualquier polinomio pk(n) O(nk)

PROPIEDADES DE LAS NOTACIN. REGLA DEL SUMATORIO

Regla del sumatorio: Si fO(g) y la funcin g es creciente entonces:

i=1

f (i) O

n +1

g ( x ) dx

Si f(i)=i.

i =

(n

i=1

+ 1 )n 2

n 2 n + 2 2

n + 1

x dx

x 2 = 2

n +1

=
1

(n + 1) 2

1 = 2

n 2 + n 2

De donde cualquier polinomio pk(n) O(nk)

CONSECUENCIA TIL DE LA REGLA DEL SUMATORIO

n +1

(n

k +1

)
+1

i=1

dx

x k +1 = k + 1

n +1

=
1

(n + 1) k k + 1

1 k + 1

1 (n

+ 1

)k + 1

+ k

(n

k +1

JERARQUA DE RDENES DE FRECUENTE APARICIN

Los comportamientos asintticos de ms frecuente aparicin se pueden ordenar de menor a mayor crecimiento de la siguiente forma: 1<<log n<<n<<n log n<<n2<<n3<<.....<<2n<<n!

REGLAS PRCTICAS PARA HALLAR EL COSTE DE UN ALGORITMO

Lo que se presenta a continuacin son reglas generales para el clculo de la complejidad temporal en el peor de los casos. Estas reglas debern tener en consideracin los costes de:
Las instrucciones simples La composicin de instrucciones Las instrucciones de seleccin De los bucles Los subprogramas

INSTRUCCIONES SIMPLES
Se considera que se ejecuta en tiempo constante:
La evaluacin de las expresiones aritmticas siempre que los datos sean de tamao constante as como las comparaciones de datos simples. Las operaciones de asignacin, lectura y escritura de datos simples. Las operaciones de acceso a una componente de un array, a un campo de un registro y a la siguiente posicin de un registro de un archivo.

Todas estas operaciones se consideran de (1).

COMPOSICIN DE INSTRUCCIONES

Si suponemos que las instrucciones I1 e I2 poseen complejidades temporales, en el peor de los casos de T1(n) y T2(n) respectivamente entonces el coste de la composicin de ambas instrucciones ser:
TI1,I2(n)=T1(n)+T2(n)

Que aplicando la regla de la suma es el mximo de ambos.

INSTRUCCIONES DE SELECCIN
Para la instruccin condicional:
if <condicin> then I1 else I2 Tseleccin(n)=Tcondicin(n)+max(T1(n),T2(n)) Case <expresin> of
caso1: I1; caso2: I2; ..... ..... cason: In;

end; {case} Tseleccin(n)=Texpresin(n)+max(T1(n),....,Tn(n))

INSTRUCCIONES DE ITERACIN: BUCLES

El caso ms sencillo es el bucle for:
for i:=1 to m do I

bucle

(n ) = m +

j =1

(n )

Donde m representa las m veces que se incrementa i y la comprobacin de si est entre los extremos inferior y superior. Si el campo interior consume un tiempo constante entonces la ecuacin anterior se escribe de la siguiente forma:

bucle

(n ) = m ( + T 1

(n )

Los bucles while y repeat no poseen una norma general

SUBPROGRAMAS

El coste de un subprograma se deriva de las reglas anteriores. Si el subprograma es recursivo entonces hay que distinguir entre los casos base y recurrentes.

SUBPROGRAMAS
FUNCTION Fac(n:integer):integer; Begin if n=0 then Fac:=1 else Fac:=n*Fac(n-1) End;{Fac} El caso base posee un coste constante: Tfac(0)=1 Para los casos recurrentes:
Tfac(n)=1+Tfac(n-1)= Tfac(n)=1+1+Tfac(n-2)= ..................................... Tfac(n)=1+1+....+1+Tfac(0) = n+1O(n)

TILES MATEMTICOS
Para el clculo de la complejidad es til saber como calcular trminos generales de sucesiones en las que los trminos se definen en funcin de los trminos anteriores.

Frmulas con sumatorios Sucesiones de recurrencia lineales de primer orden

FORMULAS CON SUMATORIOS

Sucesin aritmtica x

i=1

(x 1

+ x 2

)n

= x

n 1

+ r

1 + x + x

+ ... + x

n 1

1 x n = 1 x
1 1 x si x < 1

=1 + x + x

+ ... =

i=1

i=1

x i = e i !

( 1 )
i=1

x i

= log

SUCESIONES DE RECURRENCIA LINEALES DE PRIMER ORDEN

x n = c x n 1 = c n x 0
x n = b n x n 1 para un n 1

x n = b 1 b 2 .... b n x 0

x n = b n x n 1 + c n : realizando el cambio x n = b 1 b 2 .... b n y n en la recurrencia de x n + 1 x n +1 = b n +1 x n + c n +1 xn

(1 b n ) = b n x0 + c (1 b )b n

ALGORITMOS DE BSQUEDA Y ORDENACIN

Algoritmos de bsqueda en arrays
Secuencial Secuencial ordenada Binaria

Ordenacin de vectores
Seleccin directa Insercin directa Intercambio directo Ordenacin rpida (Quick Sort) Ordenacin por mezcla (Merge Sort)

ALGORITMOS DE BSQUEDA EN ARRAYS

Surgen de la necesidad de conocer tanto si un dato se encuentra o no dentro de una coleccin como de la posicin que ocupa. Bsqueda(vector,elemento):
i{1,....,n} si existe tal elemento 0 en otro caso

Estructura de datos:
const N=100; type tIntervalo=0..N; tvector=array[1..N] of tElem {tipo ordinal}

ALGORITMOS DE BSQUEDA EN ARRAYS

Algoritmos de bsqueda:
Bsqueda secuencial Bsqueda secuencial ordenada Bsqueda binaria

BSQUEDA SECUENCIAL
La bsqueda secuencial consiste en comparar secuencialmente el elemento deseado con los valores contenidos en las posiciones 1,....,n. El proceso termina cuando o bien encontramos el elemento o bien se alcanza el final del vector. Un primer nivel de diseo:
ind:=0 buscar elemento en vector si vector[ind]=elemento entonces busquedasecuencial:=ind sino busquedasecuencial:=0

BSQUEDA SECUENCIAL,
IMPLEMENTACIN EN PASCAL
FUNCTION Busquedasec(v:tvector ; elem:telem):tIntervalo; {Dev. 0 si el elemento no est en v o i si v[]=elem} VAR i:tIntervalo; BEGIN i:=0; repeat i:=i+1; until (v[i]=elem) or (i=N); if v[i]=elem then busquedasec:=i else busquedasec:=0 END; {busquedasec}

El nmero de veces que se ejecuta El algoritmo depender del bucle. En el peor de los casos ser de orden O(n).

BSQUEDA SECUENCIAL ORDENADA

El algoritmo anterior puede ser mejorado si el vector v esta ordenado (i.e. Creciente). De esta forma si durante la bsqueda se alcanza una componente con mayor valor que elem, podremos asegurar que no se encuentra dentro de la coleccin.

BSQUEDA SECUENCIAL ORDENADA,

IMPLEMENTACIN EN PASCAL
FUNCTION Busquedasecord(v:tvector ; elem:telem):tIntervalo; {Dev. 0 si el elemento no est en v o i si v[]=elem} VAR i:tIntervalo; BEGIN i:=0; repeat i:=i+1; until (v[i]elem) or (i=N); if v[i]=elem then busquedasecord:=i else busquedasecord:=0 END; {Busquedasecord} *Este algoritmo en el peor de los casos es de orden O(n).

BSQUEDA BINARIA
El hecho de que el vector este ordenado se puede, tambin, aprovechar para conseguir una mayor eficiencia planteando el siguiente algoritmo.
Comparar elem con el elemento central del vector. Si este es el elemento buscado se finaliza. Si no se sigue buscando en la mitad del vector que determine la relacin entre el valor del elemento central y el buscado. Este algoritmo finaliza cuando se localiza el elemento o se termina el vector.

Debido a que el vector es dividido sucesivamente en dos se denomina bsqueda binaria.

BSQUEDA BINARIA,
IMPLEMENTACIN EN PASCAL
FUNCTION Busquedabinaria(v:tvector ; elem:telem):tIntervalo; {Prec. V esta ordenado crecientemente} {Dev. 0 si el elemento no est en v o i si v[]=elem} VAR einf,esup,posmed:tIntervalo; encontrado:boolean; BEGIN einf:=1; esup:=N; encontrado:=false; while not encontrado and (esupeinf) do begin posmed:=(esup+einf) DIV 2; if elem=v[posmed] then encontrado:=true else if elem>v[posmed] then einf:=postmed+1 else esup:=postmed-1 end {while}

BSQUEDA BINARIA,
IMPLEMENTACIN EN PASCAL

if encontrado then busquedabinaria:=posmed else busquedabinaria:=0 END; {Busquedabinaria}

BSQUEDA BINARIA
La complejidad algortmica de la bsqueda binaria es:
Teniendo en cuenta que: 2k N2k+1 entonces en el peor de los casos: T(n)O[logN] 2k N de donde log2k logN k logN

ORDENACIN DE VECTORES
Como se ha presentado con anterioridad, disponer de una coleccin de datos ordenados facilita la operacin de bsqueda. A continuacin se presentan algunos de los algoritmos de ordenacin ms frecuentes: Algoritmos cuadrticos:
Seleccin directa Insercin directa Intercambio directo

Algoritmos avanzados de bsqueda:

Algoritmo rpido (Quick Sort) Algoritmo de mezcla (Merge Sort)

SELECCIN DIRECTA

Procedimiento: Recorre el vector y selecciona en cada uno de los recorridos el menor elemento para situarlo en su lugar correspondiente.

SELECCIN DIRECTA
1. Se sita en v[1] el menor elemento de entre v[1],...,v[n]. Para ello se intercambian los valores de v[1] y v[i] {v[i]=min(v)}

4 5 7 1 9 8 2

2. Se sita en v[2] el menor elemento de entre v[2],...,v[n]. Para ello se intercambian los valores de v[2] y v[i] {v[i]=min(v)}

1 5 7 4 9 8 2
(n-1). Se sita en v[n-1] el menor elemento de entre v[n-1] y v[n]. Para ello se intercambian los valores de v[n-1] y v[n].

1 2 4 5 7 8 9

SELECCIN DIRECTA,
IMPLEMENTACIN EN PASCAL
PROCEDURE Selecciondirecta( var v:tvector); {Efecto. Se ordena v ascendentemente} VAR i, j,posmenor:tIntervalo; valmenor,aux:telem; BEGIN for i:=1 to N-1 do begin valmenor:=v[i] posmenor:=i for j:=i+1 to N do if v[j]<valmenor then begin valmenor:=v[j]; posmenor:=j end; {if }

Busca el menor elemento de entre i+1,....,N

SELECCIN DIRECTA,
IMPLEMENTACIN EN PASCAL
if posmenor<>i then begin aux:=v[i]; v[i]:=v[posmenor]; v[posmenor]:=aux end {if} end{for i} END; {Selecciondirecta}

Intercambio si posmenor es diferente de i

INSERCIN DIRECTA

Procedimiento: Recorre el vector v insertando el elemento v[i] en su lugar correcto entre los ya ordenados.

INSERCIN DIRECTA
1. Se considera v[1] como primer elemento. 2. Se inserta v[2] en su posicin correspondiente en relacin a v[1] y v[2]. 3. Se inserta v[3] en su posicin correspondiente en relacin a v[1], v[2] y v[3]. i. Se inserta v[i] en su posicin correspondiente en relacin con v[1],...,v[i]. n. Se repite la operacin con el ltimo elemento del vector.

INSERCIN DIRECTA,
IMPLEMENTACIN EN PASCAL
PROCEDURE Inserciondirecta( var v:tvector); {Efecto. Se ordena v ascendentemente} VAR i, j:tIntervalo; aux:telem; BEGIN for i:=2 to N do begin aux:=v[i] Desplazamiento del j:=i-1 menor valor while (j1) and (v[j]>aux) do begin v[j+1]:=v[j]; Colocacin del valor j:=j-1 en su lugar correspondiente end; {while} v[j+1]:=aux end {for} END; {inserciondirecta}

INTERCAMBIO DIRECTO

Procedimiento: Recorre el vector v buscando el menor elemento desde la ltima posicin hasta la actual y lo inserta en dicha posicin.

INTERCAMBIO DIRECTO
1. Situar el elemento menor en la primera posicin.
Para ello se compara el ltimo elemento con el penltimo intercambiando los valores si estn en orden decreciente. Se repite esta operacin hasta llegar a la primera posicin. (el elemento menor se encuentra en la primera posicin).

2. Situar el segundo menor elemento en la segunda posicin.

Para ello se procede como antes finalizando al alcanzar al segunda posicin.

3. Repetir este proceso con la tercera, cuarta,...,y con la ensima posicin intercambiando si procede en cada caso.

INTERCAMBIO DIRECTO,
IMPLEMENTACIN EN PASCAL
PROCEDURE Intercambiodirecto( var v:tvector); {Efecto. Se ordena v ascendentemente} VAR i, j:tIntervalo; aux:telem; BEGIN for i:=1 to N-1 do for j:=N downto i+1 {se busca el menor desde atrs y se sita en vi} if v[j-1]>v[j] then begin aux:=v[j]; v[j]:=v[j-1]; v[j-1]:=aux; end; {if} END; {intercambiodirecto}

Intercambio

ALGORITMOS DE BSQUEDA AVANZADA

Ordenacin rpida (Quick sort) Ordenacin por mezcla (Merge sort)

ORDENACIN RPIDA
El algoritmo consiste en dividir el vector que se desea ordenar en dos bloques. En el primero se sitan todos los elementos que son menores que un cierto valor que se toma como referencia (pivote), mientras que en segundo iran el resto. Este procedimiento se repite dividiendo a su vez cada uno de estos bloques y repitiendo la operacin anteriormente descrita. La condicin de parada se da cuando el bloque que se desea ordenar est formado por un nico elemento (bloque ordenado). El esquema seguido por este algoritmo es el de divide y venceras.

ORDENACIN RPIDA, PSEUDOCDIGO

Si v es de tamao 1 entonces el vector v ya est ordenado sino dividir v en dos bloques A y B con todos los elementos de A menores que los de B fin {si} Ordenar A y B usando Quick Sort Devolver v ya ordenado.

Donde dividir v en dos bloques se puede refinar:

Elegir un elemento como pivote de v para cada elemento de v hacer: si el elemento es < pivote colocarlo en A en otro caso situarlo en B.

ORDENACIN RPIDA,
IMPLEMENTACIN EN PASCAL
PROCEDURE Quicksort( var v:tvector); {Efecto. Se ordena v ascendentemente} PROCEDURE Sortdesdehasta(var v:tvector;izq,der:tintervalo); {Efecto. Se ordena v[izq..der] ascendentemente} {siguiente pgina} BEGIN {Quicksort} Sortdesdehasta(v,1,n); END; {Quicksort} PROCEDURE Sortdesdehasta(var v:tvector;izq,der:tintervalo); {Efecto. Se ordena v[izq..der] ascendentemente} VAR i, j:tIntervalo; p,aux:telem; BEGIN ............

ORDENACIN RPIDA,
IMPLEMENTACIN EN PASCAL
BEGIN i:=izq; j:=der; p:=v[(izq+der) DIV 2]; while i<j do begin {se reorganizan los vectores} while v[i]<p do i:=i+1; while p<v[j] do j:=j-1; if i j then begin {intercambio de elementos} aux:=v[i]; v[i]:=v[j]; Intercambio v[j]:=aux; i:=i+1; j:=j-1; {ajuste posiciones} end; {if} end; {while} if izq<j then sortdesdehasta(v, izq, j); if i<der then sortdesdehasta(v, i, der); END; {Sortdesdehasta}

ORDENACIN RPIDA,
TRAZA DE UN EJEMPLO
V=[0,5,15,9,11] 1. Sortdesdehasta(v,1,5) p=v[3]=15 i=1 [0,5,15,9,11] 0<15 i=2 [0,5,15,9,11] 5<15 i=3 [0,5,15,9,11] 15 not <15 i=3 j=5 [0,5,15,9,11] 11 not >15 i=4 j=4 [0,5,11,9,15] intercambio. Salida bucle 1.1.sortdesdehasta(v,1,4) p=v[2]=5 i=1 [0,5,11,9] 0<5 i=2 [0,5,11,9] 5 not< 5 i=2 j=4 [0,5,11,9] 9>5 i=2 j=3 [0,5,11,9] 11>5 i=2 j=3 [0,5,11,9] 5 not>5 i=3 j=1 [0,5,11,9] intercambio. Salida bucle

ORDENACIN RPIDA,
TRAZA DE UN EJEMPLO
1.1.1.sortdesdehasta(v,3,4) i=3 [11,9] i=4 [11,9] i=4 j=3 [9,11] p=v[3]=11 11 not <11 9 not> 11 intercambio. Salida bucle

V=[0,5,15,9,11] 1.2 Sortdesdehasta(v,4,5) p=v[4]=11 i=4 [11,15] 11 not <11 i=4 j=5 [11,15] 15>11 i=4 j=4 [11,15] 11 not >11 i=5 j=3 [11,15] intercambio. Salida bucle izq=4 not <j=3 i=5 not <der=5 termina recursin vector ordenado: [0,5,9,11,15]

ORDENACIN RPIDA,
TRAZA DE UN EJEMPLO

Sortdesdehasta(v,1,5)

Sortdesdehasta(v,1,4)

Sortdesdehasta(v,4,5)

Sortdesdehasta(v,3,4)

ORDENACIN RPIDA,
CLCULO DE SU COMPLEJIDAD ALGORTMICA
El peor caso: Si se elige como pivote el primer elemento del vector y adems se considera que el vector esta ordenado decrecientemente entonces, el bucle ... Para cada elemento... se ejecutar en total: (n-1)+(n-2)+(n-3)+....+1 Cada miembro de este sumando proviene de cada una de las sucesivas ordenaciones recursivas. Este sumatorio da lugar a la siguiente expresin:

(n
i=1

) = [(n

)+
2

1 ](n 1

(n
2

Que es de orden cuadrtico T(n)O(n2) Como se puede apreciar si la eleccin del pivote es tal que los subvectores son de igual tamao y adems los vectores estn ordenados de forma aleatoria entonces el algoritmo posee una eficiencia del tipo O(n log n).
Recorrido del vector Numero de divisiones

ORDENACIN POR MEZCLA

En este caso se sigue un esquema similar a la ordenacin rpida, el esquema de divide y venceras. Sin embargo el mayor esfuerzo no se realiza dividiendo el vector y reorganizando cada divisin, sino que tiene lugar cuando finalmente se construye el vector ordenado a partir de la mezcla de los subvectores que se generan. La idea consiste en dividir el vector v en dos subvectores para posteriormente mezclar ordenadamente las soluciones obtenidas al ordenar A y B, aplicando nuevamente el algoritmo Merge Sort a ambos subvectores.

ORDENACIN POR MEZCLA, PSEUDOCDIGO

Si v es de tamao 1 entonces el vector v ya est ordenado sino dividir v en dos subvectores A y B fin {si} Ordenar A y B usando Mergesort Mezclar las ordenaciones de A y B para generar el vector ordenado.

Donde dividir v en dos subvectores se puede refinar: Asignar a A el subvector [v1,.....,vnDIV2] Asignar a B el subvector [vnDIV2+1,......vn] Mientras que mezclar las ordenaciones de A y B consiste en ir entremezclando adecuadamente las componentes ya ordenadas de A y B.

ORDENACIN POR MEZCLA,

IMPLEMENTACIN EN PASCAL
PROCEDURE Mergesort( var v:tvector); {Efecto. Se ordena v ascendentemente} PROCEDURE Mergedesdehasta(var v:tvector; izq, der: tintervalo); {Efecto. Se ordena v[izq..der] ascendentemente} VAR centro :tIntervalo PROCEDURE Merge(var v:tvector; iz, ce, de:tintervalo; var w:tvector); BEGIN {Mergedesdehasta} centro:=(izq+der)DIV2; if izq<centro then Mergedesdehasta(v,izq,centro); if centro<der then Mergedesdehasta(v,centro+1,der); Merge(v,izq,centro,der,v) END; {Mergedesdehasta}

ORDENACIN POR MEZCLA,

IMPLEMENTACIN EN PASCAL

BEGIN {Mergesort} Mergedesdehasta(v,1,n) END; {Mergesort}

ORDENACIN POR MEZCLA,

IMPLEMENTACIN EN PASCAL
PROCEDURE Merge(v:tvector; iz, ce, de:tintervalo; var w:tvector); {Efecto.w: mezcla ordenada de los subvec. v[iz..ce],v[ce+1..de] } VAR i, j,k:tIntervalo; BEGIN i:=iz; j:=ce+1; k:=iz; {k recorre w} while( i ce) and (j de) do begin if v[i]<v[j] then begin w[k]:=v[i]; i:=i+1 end; {if} else begin w[k]:=v[j]; j:=j+1; end; {else} k:=k+1 end; {while}

ORDENACIN POR MEZCLA,

IMPLEMENTACIN EN PASCAL
for k:=j to de do w[k]:=v[k] for k:=i to ce do w[k+de-ce]:=v[k] END; {Merge}

ORDENACIN POR MEZCLA,

TRAZA DE UN EJEMPLO

V=[8,5,7,3] 1. Mergedesdehasta(v,1,4)centro=2 1.1. Izq(1) <centro(2) Mergedesdehasta(v,1,2) centro=1 1.1.1. izq(1) not< centro(1) 1.1.2. centro(1)< der(2) 1.1.2.1 izq(2) not< centro(2) 1.1.2.2. centro(2) not< der(2) 1.1.2.3. Merge(v,2,2,2,v) trivial Merge(v1,1,2,v)-------- w1[5,8]

ORDENACIN POR MEZCLA,

TRAZA DE UN EJEMPLO
1.2. Centro(2) < der(4) Mergedesdehasta(v,3,4) centro=3 1.2.1. izq(3) not< centro(3) 1.2.2. centro(3) < der(4) 1.2.2.1. izq(4) not< centro(4) 1.2.2.2. centro(4) not< der(4) 1.1.2.3. Merge(v,4,4,4,v) trivial Merge(v3,3,4,v)-------- w2[3,7] 1.3. Merge(v,1,2,4,v)------------w[3,5,7,8] Mezcla ordenada de w1 y w2

ORDENACIN POR MEZCLA,

TRAZA DE UN EJEMPLO
Mergedesdehasta(v,1,4) centro=2 Merge(v,1,2,4,v) fin de programa

Izq<centro 1<2 Mergedesdehasta(v,1,2) centro=1 Izq<centro Merge(v,1,1,2,v) 1not <1 Centro<der 1<2 Mergedesdehasta(v,2,2) centro=2 Izq<centro 2not <2 Merge(v,2,2,2,v) Centro< der 2 not <2

Centro<der 2<4 Mergedesdehasta(v,3,4) centro=3

Izq<centro Merge(v,3,3,4,v) 3not <3 Centro<der 3<4 Mergedesdehasta(v,4,4) centro=4 Izq<centro 4not <4 Centro< der 4 not <4 Merge(v,4,4,4,v)

ORDENACIN POR MEZCLA,

CLCULO DE SU COMPLEJIDAD ALGORTMICA
El peor caso: Puesto que la mezcla se ejecuta en un tiempo proporcional a n (la longitud del vector a ordenar) el coste en tiempo vendr dado por la siguiente recurrencia:
k1 T (n ) = n 2T + k 2 si
2

n = 1 n > 1

n + k

si

Esta ecuacin se resuelve mediante sustituciones sucesivas cuando n es una potencia de 2 (j tal que n=2j).
T ( n ) = 2 (2 T = 4T = 8T = 2
j

= 4 (2 T

(n

(n

(n
8

)+
8

(n
2 k k
2 2

)+

k 4
5

2 4

(n
= k =

)+

)+
2

n + k =

)+

)+

n + k
2

(n

)+

)+

2 k

n + k . =

3k jk

n + k

= ..........

..........
2

.......... n + k
j

..........

..........

T (1 ) +

De donde sustituyendo jlog n lo que da una funcin de orden O(n logn) (una vez aplicadas las reglas de la suma y de la escalabilidad).