Algoritmos de Ordenamiento

Ordenacin por Insercin

Operaciones bsicas
Comparacin: una comparacin binaria entre dos valores de clave. Intercambio: intercambiar dos elementos en el arreglo.

.
A[0] A[n-1]

Ordenacin por Insercin

Ordenar-Insercin(elemento A[], entero n)

1 para i 1 hasta n-1 hacer 2 para j i hasta 1 hacer en pasos de -1 3 si clave[A[j]] < clave[A[j - 1]] entonces 4 intercambiar A[j] con A [j - 1]
Calcular la eficiencia de este algoritmo

Ordenacin por Insercin

A. Est correcto el algoritmo ?

Este algoritmo ordena de izquierda a derecha Supongamos que los n-1 elementos ya estn ordenados. Al ordenar el n-simo elemento, ste es insertado en la posicin correspondiente (lneas 2-4), quedando ordenado lo n elementos

Ordenacin por Insercin

B. calcular T(n) :nmero de comparaciones para n = 5

i 1 2 3 j 1 2 1 3 2 1 4 4 3 2 1 TOTAL Comparaciones A[1] con A[0] A[2] con A[1] A[1] con A[0] A[3] con A[2] A[2] con A[1] A[1] con A[0] A[4] con A[3] A[3] con A[2] A[2] con A[1] A[1] con A[0] 1+2+3+4 comparaciones

i=n-1 T(n) =

i=1

T(n) =

n(n-1) 2

Ordenacin por Insercin

C : calcular T(n) = O(g(n))

n(n-1)
2

Sabemos que: T(n) =

Debemos obtener c y no talque T(n) c g(n) para todo n no Desarrollo: n(n-1)/2 c g(n) (n2- 1) 2c n2 luego g(n) = n2 Por lo tanto T(n) = O(n2), con c=1/2 y n0 =1

n2- 1 n2

con c=1/2 y n0 =1

Ordenacin por Insercin

D: Responder T(n) = (g(n)) = (n2) ?

n(n-1)
2

Sabemos que: T(n) =

Debemos obtener c y no talque T(n) c g(n) para todo n no Desarrollo: n(n-1)/2 c n2 n2- n 2c n2 n2(1- 2c) n n(1- 2c) 1 n(1-2c) 1 con c=1/4 y n0 =2

Luego T(n) = (n2), con c=1/4 y n0 =2

Ordenacin por Insercin

E: Responder T(n) = (g(n)) = (n2) ?

Resultados Anteriores 1. T(n) = O(n2), con c=1/2 y n0 =1

2. T(n) = (n2), con c=1/4 y n0 =2

De estos dos resultados podemos concluir que:

T(n) = (n2), con c1=1/2 , c2=1/4 , n0 =2

Ordenacin por Insercin

B. calcular T(n) :nmero de Intercambios, tambin para n = 5. Se supone que las entrada son totalmente aleatorias, as que podemos pensar que los intercambios ocurren de manera intercalada
i 1 j 1 Comparaciones A[1] con A[0] Intercam. 1

2
3

2
1 3 2 1

A[2] con A[1]

A[1] con A[0] A[3] con A[2] A[2] con A[1] A[1] con A[0] A[4] con A[3] A[3] con A[2] A[2] con A[1] A[1] con A[0]

0
1 0 1 0 1 0 1 0

i=n-1 T(n) =

i=1

i 2

4 3 2 1

T(n) =

n(n-1) 4

TOT AL

1+2+3+4 comparaciones (1+2+3+4)/2

Ordenacin por Insercin

C : calcular T(n) = O(g(n))

n(n-1)
4

Sabemos que: T(n) =

Debemos obtener c y no talque T(n) c g(n) para todo n no Desarrollo: n(n-1)/2 c g(n) (n2- 1) 4c n2 luego g(n) = n2 Por lo tanto T(n) = O(n2), con c=1/4 y n0 =1

n2- 1 n2

con c=1/4 y n0 =1

Ordenacin por Insercin

D: Responder T(n) = (g(n)) = (n2) ?

n(n-1)
4

Sabemos que: T(n) =

Debemos obtener c y no talque T(n) c g(n) para todo n no Desarrollo: n(n-1)/4 c n2 n2- n 4c n2 n2(1- 4c) n n(1- 4c) 1 n(1-4c) 1 con c=1/8 y n0 =2

Luego T(n) = (n2), con c=1/8 y n0 =2

Ordenacin por Insercin

E: Responder T(n) = (g(n)) = (n2) ?

Resultados Anteriores 1. T(n) = O(n2), con c=1/4 y n0 =1

2. T(n) = (n2), con c=1/8 y n0 =2

De estos dos resultados podemos concluir que:

T(n) = (n2), con c1=1/4 , c2=1/8 , n0 =2

Ordenamiento por Mezcla (MergeSort)

Este algoritmo utiliza la estrategia dividir para conquistar. Divide recursivamente el arreglo en dos partes iguales de tamao n/2. Ordena cada cada subarreglo y luego los une mezclndolos ordenadamente. Ejemplo: Ordenar un mazo de cartas Este algoritmo posee dospartes

OrdenaMezcla() Mezclar()

Ordenamiento por Mezcla (MergeSort)

OrdenarMezcla (elemento A[], entero a, entero b) 1 si a < b entonces 2 p (a + b)/2 3 OrdenarMezcla(A, a, p) 4 OrdenarMezcla(A, p + 1, b) 5 Mezclar(A, a, p, b)

Ordenamiento por Mezcla (MergeSort)

Mezclar(elemento A[], entero a, entero p, entero b) 1 k 0 ; i a; j p +1; n b - a 2 mientras i < p + 1 y j < b + 1 hacer 3 si clave[A[i]] < clave[A[i]] entonces 4 B[k] A[i]; i i + l; k k + 1 5 sino 6 B[k] A[j]; j j + l; k k + 1 7 mientras i < p + 1 hacer copiar el restode A[a..p] 8 B[k] A[i]; i i+1; k k+1 9 mientras j < b + 1 hacer copiar el resto de A[p+1..b] 10 B[k] A[j]; j j + 1; k k +1 11 i a 12 para k 0 hasta n hacer T(n) = (n) ? 13 A[i] B[k]; i i +1

Ordenamiento por Mezcla (MergeSort)

Anlisis de la eficiencia
(1) Si n = 1 Si n > 1

T(n) =

2T(n/2) + (n)

OrdenarMezcla (A[], a, b) 1 si a < b entonces 2 p (a + b)/2 3 OrdenarMezcla(A, a, p) 4 OrdenarMezcla(A, p + 1, b) 5 Mezclar(A, a, p, b)

Ordenamiento por Mezcla (MergeSort)

Anlisis de la eficiencia
(1) Si n = 1 Si n > 1

T(n) =

2T(n/2) + (n)

Considerando la solucin general para algoritmos dividir para conquistar, Con a = b , b = 2 , k=1

T(n) = (n log n)

Ordenamiento Rpido (QuickSort)

Utiliza la estrategia dividir para conquistar Consiste en los siguientes pasos:

El primer elemento del arreglo se elije como elemento pivote A[a]. Mueve hacia la izquierda todos los elementos menores a A[a], y a la derecha los mayores El pivote A[a] se inserta en medio de ambos grupos Se ordena el subarreglo izquierdo Se ordena el subarreglo derecho

Ordenamiento Rpido (QuickSort)

El algoritmo

OrdenarRapida(elemento A[], entero a, entero b) 1 si a < b entonces 2 k Particion(A, a, b) 3 OrdenarRapida(A, a, k - 1) 4 OrdenarRapida(A, k + 1, b)

Ordenamiento Rpido (QuickSort)

Particion (elemento A[], entero a, entero b) 1 pivoteclave[A[a]]; inferior a +1; superior b 2 hacer 3 mientras clave[A[inferior]] pivote y inferior superior hacer 4 inferior inferior + 1 5 mientras clave[A[superior]] > pivote y inferior superior hacer 6 superior superior - 1 7 si inferior superior entonces 8 intercambiar A[inferior] con A[superior] 9 inferior inferior + 1; superior superior - 1 10 mientras inferior superior 11 intercambiar A [a] con A [superior] mover el pivote a la componente apropiada 12 devolver superior

Ordenamiento Rpido (QuickSort)

Anlisis de la eficiencia
Caso peor: el pivote elegido siempre es el menor quedando en el extremo izquierdo
(1) T(n) = T (n-1) + (n) Si n = 1 Si n > 1

T(n) = (n2) ?

OrdenarRapida(A[], a, b) 1 si a < b entonces 2 k Particion(A, a, b) 3 OrdenarRapida(A, a, k - 1) 4 OrdenarRapida(A, k + 1, b)

Ordenamiento Rpido (QuickSort)

Anlisis de la eficiencia
Caso Mejor: el pivote elegido siempre queda ubicado en el centro del arreglo
(1) T(n) = Si n = 1

T(n) = (n log n) ?

2T (n/2) + (n)

Si n > 1

OrdenarRapida(A[], a, b) 1 si a < b entonces 2 k Particion(A, a, b) 3 OrdenarRapida(A, a, k - 1) 4 OrdenarRapida(A, k + 1, b)

Ordenamiento Rpido (QuickSort)

Anlisis de la eficiencia
Caso promedio (Tm(n) = Tiempo promedio) Se supone que cualquier combinacin de entrada de n elementos son equiprobables Supongamos que el pivote queda insertado en la posicin p Quedan dos subarreglos:

Uno de tamao p-1 Otro de tamao n-p

p-1

n-p

a=0

b=n-1

Ordenamiento Rpido (QuickSort)

Anlisis de la eficiencia
Caso promedio (Tm(n) = Tiempo promedio)

(1) T(n) =

Si n = 1

T (n-p) + T (p-1) + (n)

Si n > 1

OrdenarRapida(A[], a, b) 1 si a < b entonces 2 k Particion(A, a, b) 3 OrdenarRapida(A, a, k - 1) 4 OrdenarRapida(A, k + 1, b)

Ordenamiento Rpido (QuickSort)

Anlisis de la eficiencia
Caso promedio (Tm(n) = Tiempo promedio)

Tm(n) = cn + 1/n

[T
p=1

m(p-1)

+ Tm(n-p)]

Ordenamiento Rpido (QuickSort)

Anlisis de la eficiencia
Caso promedio (Tm(n) = Tiempo promedio)

Tm(n) = cn + 1/n

[T
p=1

m(p-1)

+ Tm(n-p)]

Tiempo requerido para ordenar todas las particiones posibles multiplicado por la probabilidad de cada particin (1/n)

Ordenamiento Rpido (QuickSort)

Anlisis de la eficiencia
Caso promedio (Tm(n) = Tiempo promedio)

Como

p=1

Tm(p-1) =

T
p=1 n

m(n-p)

entonces

Tm(n) = cn + 2/n

p=1

Tm(p-1)

Ordenamiento Rpido (QuickSort)

Anlisis de la eficiencia
Caso promedio (Tm(n) = Tiempo promedio)
n

Tm(n) = cn + 2/n

p=1

Tm(p-1)

/* n

Tambin

Tm(n-1) = c(n-1) + 2/(n-1)

n-1
Tm(p-1) /* (n-1) / Tm(n-1)-Tm(n-1)

p=1

Ordenamiento Rpido (QuickSort)

Anlisis de la eficiencia
Caso promedio (Tm(n) = Tiempo promedio)
n Tm(n) = cn2 + 2

p=1

/* n Tm(p-1) /* (n-1) / 2Tm(n-1)-2Tm(n-1)

Restar
(n-1) Tm(n-1) = c(n-1)2 + 2

Tm(p-1) - 2Tm(n-1) p=1

nTm(n) = (n+1) Tm(n-1) + c (2n-1)

Ordenamiento Rpido (QuickSort)

Anlisis de la eficiencia
Caso promedio (Tm(n) = Tiempo promedio)
nTm(n) = (n+1) Tm(n-1) + c (2n-1)
Tm(n)
(n+1) Tm(n) (n+1) Tm(n) (n+1) = /* (n+1)/2

Tm(n-1)
n Tm(n-2) n-1 Tm(2) 3

c(2n-1)
+ n (n+1) c(2(n-1)-1) + (n-1) n n + + n (n+1) c(2n-1)

i=3

c(2i-1) i (i+1)

Ordenamiento Rpido (QuickSort)

Anlisis de la eficiencia
Caso promedio (Tm(n) = Tiempo promedio)
n+1 c(2x-1) x(x+1)

n
dx

n c(2i-1) i (i+1)

i=3

c(2x-1) x(x+1)

dx

Resolviendo las integrales, se obtiene que:

i=3

c(2i-1) i (i+1)

= (log n)

Ordenamiento Rpido (QuickSort)

Anlisis de la eficiencia
Caso promedio (Tm(n) = Tiempo promedio)
Tm(n) (n+1) Tm(2) 3

n
+

i=3

c(2i-1) i (i+1)

= (log n)
/ * (n+1)

Tm(n) = ( n log n)