Capítulo VI. Algoritmos: Ordenamiento

Transcripción

1 Capítulo VI Algoritmos: Ordenamiento VI.1. Algoritmos Un algoritmo es una secuencia de instrucciones precisas para llevar a cabo una tarea. Ya hemos visto algunos ejemplos: un algoritmo para resolver el problema de la torre de Hanoi, y algunos algoritmos numéricos (multiplicación, división). En este capítulo usamos el problema de ordenamiento como ejemplo para exponer algunas temas relevantes: métodos generales, análisis del número de operaciones que realizan, etc. Vamos a usar principalmente pseudocódigo para describir los algoritmos de manera relativamente precisa. Esto se precisa un poco en la primera sección. Además del pseudocódigo también se proveen los algoritmos en el lenguaje python, el cual puede ser fácilmente descargado de la red ( VI.1.1. Instrucciones Pseudocódigo El pseudocódigo consiste de instrucciones que se ejecutan en la secuencia que aparecen. La instrucción más básica es una asignación: se asigna un valor a una variable. Usamos una flecha para indicar una asignación (en lugar del signo igual, el cual se reserva para comparaciones): variable valor Es esencial tener instrucciones especiales que afectan la secuencia de ejecución del algoritmo: si: si la condición se satisface se realiza el Bloque-A de instrucciones, y de lo contrario se realza el Bloque-B. Cada uno de los bloques aparece indentado: si condicion Bloque-A si-no Bloque-B 1

2 2 CAPÍTULO VI. ALGORITMOS: ORDENAMIENTO Es posible tener más de dos casos: si condicion-1 Bloque-A si-no si condicion-2 Bloque-B si-no Bloque-C para: se ejecuta el bloque de instrucciones que aparece a continuación indentado para cada valor de la variable en el rango (en orden): para variable en rango Bloque mientras: mientras la condición es verdadera, se realiza el bloque de instrucciones que aparece a continuación indentado: mientras condicion Bloque Comentarios se escriben después del símbolo. Variables Además de variables que representan números u otros tipos de datos básicos (carácteres, valores lógicos V ó F, etc), se tienen arreglos que son variables indexadas en un rango que tomamos desde 0 hasta su longitud menos 1. Por ejemplo A[5] es la sexta posición del arreglo A. Un rango se especifica como i : j donde por conveniencia adoptamos la convención en python de considerar rangos cerrados por la izquierda y abiertos por la derecha. Es decir, i : j corresponde al rango i, i + 1, i + 2,..., j 1. Además : j y i : son rangos que van desde el comienzo en el primer caso, y hasta el final en el segundo caso. Por ejemplo, A[4 : 8] es el subarreglo que consiste de A[4], A[5], A[6], A[7]; A[: 3] es el subarreglo que consiste de A[0], A[1], A[2]. En algunos casos es más conveniente manejar listas las cuales permiten otras operaciones como eliminar el primer elemento (pop en python), agregar un elemento al final (append en python), y concatenar dos listas (lo cual denotamos L + L como se hace en pyhton). Notamos que el tipo de variable lista en python permite tanto las operaciones de un arreglo como las de una lista, y es esta la que usamos en todos los ejemplos de código python.

3 VI.1. ALGORITMOS 3 VI.1.2. Python Para la mayoría de los algoritmos se incluye además de pseudocódigo también una implementación en python, la cual en general es muy similar (pero con las palabras claves de python). Aquí sólo mencionamos que líneas que comienzan con el carácter son comentarios. El interpretador de pyhton se puede descargar de VI.1.3. Ejemplo: Torres de Hanoi Ya se ha discutido el problema y algoritmo anteriormente. Ahora lo escribimos en pseudocódigo, y en código python como ejemplo. Pseudocódigo Hanoi (n, A, C, B) 1. si n 0 2. Hanoi (n 1, A, B, C) 3. Mueva el anillo (de encima) de A a C 4. Hanoi (n 1, B, C, A) Código Python torres de Hanoi: Mueve n anillos del polo A al polo C con polo B como intermedio def Hanoi(n, A, C, B): if n!= 0: Hanoi(n - 1, A, B, C) print("mueva el anillo de", A, "a", C) Hanoi(n - 1, B, C, A)

4 4 CAPÍTULO VI. ALGORITMOS: ORDENAMIENTO Ejemplo Ejecución (python) >>> Hanoi(4, A, C, B ) Mueva el anillo de A a B Mueva el anillo de A a C Mueva el anillo de B a C Mueva el anillo de A a B Mueva el anillo de C a A Mueva el anillo de C a B Mueva el anillo de A a B Mueva el anillo de A a C Mueva el anillo de B a C Mueva el anillo de B a A Mueva el anillo de C a A Mueva el anillo de B a C Mueva el anillo de A a B Mueva el anillo de A a C Mueva el anillo de B a C VI.2. Búsqueda Una motivación para el problema de ordenamiento, es que una lista ordenada facilita la búsqueda de un ítem en la lista. Si la lista no está ordenada, no hay mejor alternativa que simplementa escanear la lista secuencialmente, es decir, en el orden que los ítems aparecen en ella (que no corresponde al orden de los ítems). El siguiente pseudocódigo busca el ítem K en la lista L: Buscar1 (K, L) 1. para i 0 a longitud(l) 1 2. si K = L[i] 3. devolver (i) 4. devolver ( 1) Esta búsqueda secuencial requiere un número de comparaciones (línea 2) igual al tamaño de la lista en el peor de los casos. Esto sucede cuando el ítem que se busca es el último ó no está en la lista (entonces se regresa 1 en la línea 4). Si n es la longitud de la lista, entonces el número de comparaciones es n en el peor de los casos. Se dice que la búsqueda secuencial tiene complejidad O(n) (se lée O de n, ó O grande de n, porque existe otra notación con o pequeña). (Puede leer acerca de esta notación O en Johnsonbaugh, sec 4.3.) VI.2.1. Búsqueda Binaria: Versión Recursiva Si la lista está ordenada, entonces búsqueda binaria es considerablemente más eficiente. En la búsqueda binaria se examina el ítem en el centro de la lista, si es el que se busca se devuelve el índice correspondiente, si no lo es, se continúa la búsqueda recursivamente en la primera ó segunda mitad de la lista/arreglo, dependiendo del resultado de la comparación. En el siguiente pseudocódigo, se

5 VI.2. BÚSQUEDA 5 tienen como parámetros, además de la lista L y el ítem a buscar K, los índices que determinan el intervalo de búsqueda: Buscar2 (K, A, i, j) 1. si i > j 2. devolver (-1) 3. m (i + j)/2 4. si K = A[m] 5. devolver (m) 6. si-no si K < A[m] 7. devolver (Buscar2 (K, A, i, m 1)) 8. si-no 9. devolver (Buscar2 (K, A, m + 1, j)) Invariante: El algoritmo mantiene en cada llamada recursiva la propiedad de que si K está en la lista, entonces su celda L[l] satisface i l j. Por esto devuelve 1 en la línea 1, si i > j (ya no es posible que K esté en L). El bloque del si (líneas 4-9) se encarga de que se mantenga este invariante a la siguiente llamada recursiva: para esto elimina la mitad del rango que no puede contener K. Código Python busqueda binaria recursiva: busca llave K en el arreglo A entre indices i y j def buscar(a,i,j,k): if i>j: return(-1) m=(i+j)//2 if K==A[m]: return(m) elif K<A[m]: return(buscar(a,i,m-1,k)) else: return(buscar(a,m+1,j,k)) VI.2.2. Búsqueda Binaria: Versión Iterativa Como lo ilustra el algoritmo anterior, la recursión es una herramienta muy poderosa. Sin embargo, recursión agrega carga computacional a la ejecución de un algoritmo (el procesador debe tener una tabla que contiene la información de que las ejecuciones recursivas que están pendientes de completar, y cual se está realizando en el momento), y si se puede evitar es deseable hacerlo. En el caso de la búsqueda binaria es muy fácil hacerlo:

6 6 CAPÍTULO VI. ALGORITMOS: ORDENAMIENTO Buscar3 (K, A) 1. i 0; j longitud(a) 1 inicializa indices i, j 2. mientras i j 3. m (i + j)/2 calcula indice medio 4. si K = A[m] 5. devolver (m) item K esta en posicion m 6. si-no si K < A[m] 7. j m 1 busqueda en la sublista izquierda 8. si-no 9. i m + 1 busqueda en la sublista derecha 10. devolver ( 1) item K no esta en L Código Python busqueda binaria no recursiva: busca llave K en el arreglo A entre indices i y j def buscar(k,a): i=0; j=len(a)-1 while i<=j: m=(i+j)//2 if K==A[m]: return(m) elif K<A[m]: j=m-1 else: i=m+1 return(-1) VI.2.3. Número de Comparaciones Nos interesa analizar cuánto se demora el algoritmo de búsqueda binaria en completar su tarea. Como indicativo de esto, vamos a determinar el número de comparaciones que realiza (línea 4 de la versión iterativa) en el peor de los casos. Si la lista/arreglo es vacía, entonces el número de comparaciones es 0. Si no lo es, después de hacer una comparación continúa buscando en una subarreglo de longitud a lo más n/2 (si la longitud del arreglo es impar entonces ambos subarreglos de elementos menores y mayores que el elemento medio tienen longitud n/2 ; si la longitud del arreglo es par entonces el arreglo de elementos menores tiene longitud n/2 1 y el de elementos mayores tiene longitud n/2 ). Sea a n el número de comparaciones realizado en el peor de los casos para un arreglo de longitud n. Continuando con el análisis, el peor caso se realiza cuando el ítem que se busca es mayor que todos los elementos del arreglo (y así la búsqueda es siempre en la mitad superior). Por lo tanto, esto muestra entonces que se satisface la recurrencia a n = a n/2 + 1

7 VI.2. BÚSQUEDA 7 con a 1 = 1. La presencia de la función piso en la derecha dificulta un poco resolver esta ecuación. Veamos primero el caso en que n = 2 l, el cual es más fácil porque sigue siendo entero al dividir por 2 iterativamente hasta que se llaga a 1 (y en un paso más se llega a 0): a 2 l = a 2 l = (a 2 l 2 + 1) + 1 = a 2 l = a 2 l l + l = a 1 + l = l + 1. Así que a n = log 2 n + 1 en el caso que n = 2 l. Para generalizar esto a cualquier n es útil calcular varios valores de a n usando la recurrencia: n : a n : Se observa que a n = log 2 n + 1 Esto lo podemos verificar por inducción. El caso base es a 1 = 1, y para n tenemos (paso de inducción fuerte) dos casos (usando como hipótesis de inducción que a k = log k + 1): si n es par: entonces n = 2k y se tiene que a n = a 2k = a k +1 = log 2 k +1+1 = log 2 k+1 +1 = log 2 (2k) +1 = log 2 n +1. si n es impar: entonces n = 2k + 1 y se tiene que a n = a 2k+1 = a k +1 = log 2 k +1+1 = log 2 k+1 +1 = log 2 (2k) +1 = log 2 n +1. Para la última igualdad, note que log 2 (2k) = log 2 (2k + 1) porque el log cambia al sigueinte entero en una potencia de 2, y 2k + 1 no es una potencia de 2. Por lo tanto log 2 (2k) = log 2 n. Concluímos que el número de comparaciones realizadas por el algoritmo de búsqueda binaria con una arreglo de longitud n es en el peor de los casos. a n = log 2 n + 1

8 8 CAPÍTULO VI. ALGORITMOS: ORDENAMIENTO Alternativa. Una forma alternativa de extender el análisis del caso n = 2 l al caso general, aunque ya no con igualdad es notar que a n es creciente (es decir a n a n+1 ), y que cualquier n está entre dos potencias de 2: 2 l 1 < n 2 l En este caso log 2 n = l. Entonces a n a 2 l = l + 1 = log 2 n + 1, lo que es muy cercano al valor exacto obtenido arriba. VI.3. Ordenamiento En el problema de ordenamiento se da como entrada una lista L de elementos, números u otro tipo de dato que tiene un orden, y el objetivo es ordenarlos, es decir, producir otra lista en la cual los mismos elementos aparecen en orden creciente ó decreciente (pueden haber copias del mismo elemento, de tal manera que el resultado puede no ser estrictamente creciente ó decreciente). Asumimos el caso de salida creciente para la presentación de los algoritmos. A continuación exploramos cuatro métodos diferentes de resolver este problema. Sea n el tamaño (ó longitud) de la lista de entrada. Un parámetro representativo de que tanto se demora el algoritmo en realizar el odenamiento es el número de comparaciones que realiza entre elementos de la lista (no contamos otras posibles comparaciones que son parte del control del algoritmo, es decir contadores de ciclos, etc). De los algoritmos que estudiamos, los dos primeros realizan un número de comparaciones O(n 2 ) y el tercero realiza un número de comparaciones O(n log n). El último realiza un número de comparaciones que es también O(n 2 ) en el peor de los casos, pero en promedio el número es O(n log n). VI.3.1. Ordenamiento por Inserción (Insertion Sort) Este algoritmo iterativo que comienza la i-ésima iteración con los primeros i elementos (es decir L[0], L[1],..., L[i 1]) ya ordenados, y busca la posición que debe ocupar el siguiente elemento (L[i]) y lo inserta en esa posición. En el proceso de buscar la posición, se mueven hacia adelante los elementos para desocupar la nueva posición de L[i].

9 VI.3. ORDENAMIENTO 9 Ordenar-por-Insercion (L) 1. para i 1 a longitud(l) 1 2. K L[i] L[i] es el item a insertar se busca la posicion donde L[i] debe ser insertado 3. j i 1 4. mientras j 0 y L[j] > K 5. L[j + 1] L[j] L[j] se mueve hacia adelante 6. j j 1 L[i] es insertado en posicion 7. L[j + 1] K Ejemplo: A continuación se muestra un arreglo/lista inicial L, y esta misma al final de cada una de las iteraciones del ciclo principal del algoritmo (para en la línea 1): L= [9, 7, 3, 5, 2, 4, 1, 0, 8, 6] 1, [7, 9, 3, 5, 2, 4, 1, 0, 8, 6] 2, [3, 7, 9, 5, 2, 4, 1, 0, 8, 6] 3, [3, 5, 7, 9, 2, 4, 1, 0, 8, 6] 4, [2, 3, 5, 7, 9, 4, 1, 0, 8, 6] 5, [2, 3, 4, 5, 7, 9, 1, 0, 8, 6] 6, [1, 2, 3, 4, 5, 7, 9, 0, 8, 6] 7, [0, 1, 2, 3, 4, 5, 7, 9, 8, 6] 8, [0, 1, 2, 3, 4, 5, 7, 8, 9, 6] 9, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] Se observa que Invariante: Al terminar la i-ésima iteración del para (línea 1), la porción del arreglo L[0 : i + 1] está ordenada (recuerde que por convención, esto no incluye L[i + 1]). En la siguiente iteración, las líneas 3-6 determinan determinan la posición j + 1 donde K = L[i] es insertado, de tal manera que el invariante se mantiene. Número de Comparaciones: Nos interesa contar el número de comparaciones que el algoritmo realiza en el peor de los casos. Esto sucede, cuando la posición en que se debe insertar L[i] es el comienzo del arreglo, y esto puede ocurrir en cada iteración si el arreglo está inicialmente en orden decreciente. Por lo tanto el número de comparaciones es a lo más (n 1) = 1 2 n(n 1) = 1 2 n2 1 2 n. Se dice que el número de comparaciones realizadas es cuadrático (ya que el término n/2 es comparativamente menor a medida que n aumenta).

10 10 CAPÍTULO VI. ALGORITMOS: ORDENAMIENTO Código Python VI.3.2. def ordenar_por_insercion(l): for i in range(1,len(l)): K = L[i] j = i-1 while j >= 0 and L[j] > K: L[j+1]=L[j] j=j-1 L[j+1]=K return(l) Ordenamiento por Selección (Selection Sort) Este algoritmo iterativo comienza la i-ésima iteración con los primeros i elementos (es decir L[0], L[1],..., L[i 1]) ya ordenados y en su posición final (los siguientes elementos no pueden ser menores que alguno de estos), y busca (selecciona) el menor de los restantes y lo intercambia con L[i]. (Note que inicialmente i = 0 y por lo tanto la lista de elementos L[0], L[1],..., L[i 1] es vacía.) Ordenar-por-Seleccion (L) 1. para i 0 a longitud(l) 2 se determina k, indice de min en L[i :] 2. k i k es inicialmente i 3. para j i a longitud(l) 1 4. si L[j] < L[k] 5. k j j es ahora indice de min min de L[i :] es colocado en L[i] 6. intercambiar L[i] L[k] Ejemplo: A coninuación se muestra un arreglo inicial L, y esta misma después de cada una de las iteraciones del ciclo principal del algoritmo (para en la línea 1): L= [9, 7, 3, 5, 2, 4, 1, 0, 8, 6] 0, [0, 7, 3, 5, 2, 4, 1, 9, 8, 6] 1, [0, 1, 3, 5, 2, 4, 7, 9, 8, 6] 2, [0, 1, 2, 5, 3, 4, 7, 9, 8, 6] 3, [0, 1, 2, 3, 5, 4, 7, 9, 8, 6] 4, [0, 1, 2, 3, 4, 5, 7, 9, 8, 6] 5, [0, 1, 2, 3, 4, 5, 7, 9, 8, 6] 6, [0, 1, 2, 3, 4, 5, 6, 9, 8, 7] 7, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 8, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] Se observa que

11 VI.3. ORDENAMIENTO 11 Invariante: Al terminar la i-ésima iteración del para (línea 1), la porción del arreglo L[0 : i + 1] está ordenada, y los elementos restantes son mayores ó iguales que L[i]. Las líneas 2 5 determinan un elemento mínimo entre los restantes (puede no ser único) y lo intercambia con L[i] de tal manera que el invariante se preserva. Número de Comparaciones: Con un arreglo de longitud n, en la i-ésima iteración, la detección del mínimo puede requerir n i 1 comparaciones. Por lo tanto el número de comparaciones es a lo más (n 1) + (n 2) + (n 3) = 1 2 n(n 1) = 1 2 n2 1 2 n. Aquí también el número de comparaciones realizadas es cuadrático. Código Python def ordenar_por_seleccion(l): for i in range(len(l)-1): k=i for j in range(i+1,len(l)): if L[j]<L[k]: k=j temp=l[i] L[i]=L[k] L[k]=temp return(l) VI.3.3. División y Conquista: Mezcla (Merge Sort) La idea de ordenar con mezcla es dividir la lista a ordenar en dos partes (lo más iguales posibles), ordenar cada una recursivamente, y luego mezclar ó combinar las dos listas ordenadas (entrada) en una sola lista ordenada (salida). Mezclar funciona de forma bastante intuitiva: iterativamente considera el primer elemento de las dos listas, y toma el elemento menor de ellos (ó uno cualquiera de los dos si son iguales) y lo coloca al final de la lista resultante, después de haberlo eliminado de su lista de entrada. Al final cuando una lista de entrada llega a ser vacía, lo que queda de la otra se agrega a la lista de salida. El seudocódigo a continuación, asume la existencia de funciones para agregar al final de una lista y eliminar al comienzo de una lista, y para concatenar dos listas (se usa + para representar esta operación porque ese es el símbolo usado en python). Note que en las líneas 9 y 10, una de las listas L 1 ó L 2 es vacía; sólo hay que concatenar la no vacía, pero la operación con la otra no tiene efecto (y así se simplifica algo el código).

12 12 CAPÍTULO VI. ALGORITMOS: ORDENAMIENTO Mezclar (L 1, L 2 ) 1. L [] 2. mientras L 1 [] y L 2 [] 3. si L 1 [0] L 2 [0] 4. agregar L 1 [0] a L agrega L 1 [0] al final de L 5. eliminar L 1 [0] elimina L 1 [0] de L 1 6. si-no 7. agregar L 2 [0] a L agrega L 2 [0] al final de L 8. eliminar L 2 [0] elimina L 2 [0] de L 2 9. L L + L 1 concatena L y L L L + L 2 concatena L y L devolver (L) Ordenar-por-Mezcla (L) si longitud(l) 1 devolver (L) si-no m longitud(l)/2 L 1 Ordenar-por-Mezcla(L[: m]) L 2 Ordenar-por-Mezcla(L[m :]) L Mezclar(L 1, L 2 ) devolver (L) Ejemplo. El siguiente es un ejemplo de las listas L, L 1, L 2 al final de cada una de las iteraciones del mientras en Mezclar, y al final del algoritmo: >>> mezclar([2,4,5,6,9,12],[1,1,4,7,8,10,13,14,15]) L= [1] L1= [2, 4, 5, 6, 9, 12] L2= [1, 4, 7, 8, 10, 13, 14, 15] L= [1, 1] L1= [2, 4, 5, 6, 9, 12] L2= [4, 7, 8, 10, 13, 14, 15] L= [1, 1, 2] L1= [4, 5, 6, 9, 12] L2= [4, 7, 8, 10, 13, 14, 15] L= [1, 1, 2, 4] L1= [5, 6, 9, 12] L2= [4, 7, 8, 10, 13, 14, 15] L= [1, 1, 2, 4, 4] L1= [5, 6, 9, 12] L2= [7, 8, 10, 13, 14, 15] L= [1, 1, 2, 4, 4, 5] L1= [6, 9, 12] L2= [7, 8, 10, 13, 14, 15] L= [1, 1, 2, 4, 4, 5, 6] L1= [9, 12] L2= [7, 8, 10, 13, 14, 15] L= [1, 1, 2, 4, 4, 5, 6, 7] L1= [9, 12] L2= [8, 10, 13, 14, 15] L= [1, 1, 2, 4, 4, 5, 6, 7, 8] L1= [9, 12] L2= [10, 13, 14, 15] L= [1, 1, 2, 4, 4, 5, 6, 7, 8, 9] L1= [12] L2= [10, 13, 14, 15] L= [1, 1, 2, 4, 4, 5, 6, 7, 8, 9, 10] L1= [12] L2= [13, 14, 15] L= [1, 1, 2, 4, 4, 5, 6, 7, 8, 9, 10, 12] L1= [] L2= [13, 14, 15] L=[1, 1, 2, 4, 4, 5, 6, 7, 8, 9, 10, 12, 13, 14, 15] Número de Comparaciones: Sea a n el número de comparaciones entre elementos de la lista L realizadas por Ordenar-por-Mezcla en el peor de los casos para listas L de longitud n. Decimos en el peor de los casos porque dependiendo de L se pueden realizar más o menos comparaciones. El algoritmo realiza comparaciones en las ejecuciones recursivas con listas L 1 y L 2, y en el algoritmo

13 VI.3. ORDENAMIENTO 13 Mezclar. Note que si n es la longitud de L, entonces las longitudes de L 1 y L 2 son n/2 y n/2. Así que el número de comparaciones realizadas en estas ejecuciones recursivas es menor ó igual a a n/2 y a n/2. Por otra parte: Observación. Mezclar realiza un número de comparaciones menor ó igual a L 1 + L 2 1 si al menos una de las listas no es vacía, ó 0 is ambas listas son vacías. Prueba. Si inicialmente ambas listas son vacías, entonces Mezclar no ejecuta el mientras y no realiza comparaciones, es decir realiza 0 comparaciones. Si inicialmente una lista es vacía y la otra no, entonces Mezclar tampoco ejecuta el mientras y no realiza comparaciones; pero como L 1 + L 2 1 entonces podemos decir que realiza a lo más L 1 + L 2 1 comparaciones. Si inicialmente ninguna de las listas es vacía, entonces se ejecuta el mientras, y cada vez que se realiza una comparación en la línea 2 de Mezclar (en el mientras), se elimina un elemento de L 1 ó de L 2 (y se agrega a L), excepto al menos un elemento al final cuando una lista llega a ser vacía) pero la la otra no lo es) y la ejecución del mientras termina. Así que el número de comparaciones realizadas es la lo más L 1 + L 2 1. Note que es posible que se realicen menos de L 1 + L 2 1 comparaciones. Por ejemplo, si L 1 = [3, 5, 6, 8] y L 2 = [9, 11, 15, 16], entonces se realizan 4 comparaciones hasta que L 1 es vacía, luego se agrega L 2 a L sin realizar más comparaciones. Como se tiene que L 1 + L 2 = n, entonces el número de comparaciones realizadas por Ordenar-por-Mezcla con listas de longitud L en el peor de los casos, lo que hemos denotado con a n satisface: a n a n/2 + a n/2 + n 1. (A diferencia de la recurrencia para la búsqueda binaria, donde teníamos igualdad, aquí no escribimos igualdad porque no sabemos en general de un ejemplo que es el peor de los casos para longitud n, y que en la recursión resulte en el peor de los casos para los problemas de taño n/2 y n/2, pero esos problemas ciertamente no son peores que los peores.) El caso base para esta recurrencia es a 1 = 0 (note la recurrencia expresa los demás en términos de a 1 ; por ejemplo, a 2 a 1 + a 1 + 1, a 3 a 1 + a 2 + 2, etc.). Al tratar de resolver esta recurrencia encontramos dos problemas. Primero, es una desigualdad, mientras que estamos acostumbrados a resolver recurrencias en la forma de igualdades. Segundo, la presencia de las funciones piso y techo van complicar la solución. Manejamos estas dificultades de la siguiente manera: Desigualdad: Resolvemos la ecuación reemplazando la desigualdad con igualdad. El resultado es una cota superior para a n. Más precisamente, para el ejemplo a mano, si reemplazamos la desigualdad con igualdad, cambiando al mismo tiempo a n por b n (porque al cambiar por igualdad ya no se trata del mismo a n ), se tiene ( ) b n = b n/2 + b n/2 + n 1,

14 14 CAPÍTULO VI. ALGORITMOS: ORDENAMIENTO con b 1 = 0. Si ahora resolvemos esta recurrencia y obtenemos una expresión para b n, entonces podemos concluir que a n b n. Por qué? Esto se puede verificar por inducción (fuerte): Para n = 1 se tiene a 1 = b 1 y por lo tanto a 1 b 1, y para n < 1 se tiene a n a n/2 + a n/2 + n 1 por recurrencia de a n b n/2 + b n/2 + n 1 por hipótesis de inducción, a n/2 b n/2 y a n/2 b n/2 = b n por la recurrencia de b n. Cuando se hace esto, normalmente por simplicidad de notación no se introduce b n sino que simplemente se asume igualdad en la recurrencia de a n, con el conocimiento de que el resultado no es exacto sino una cota superior. Pisos y techos: Se resuelve la ecuación primero para valores de n tal que el piso y el techo que aparecen en ella se manejan fácilmente cuando se itera la recurrencia. Esto es el caso por n = 2 l donde l 0 es un entero, porque al dividir por 2 se sigue obteniendo una potencia de 2. Luego se usa que a n es creciente, es decir b n b n+1 para concluir una cota superior para el caso general. Por qué b n b n+1? Esto se puede verificar por inducción: EL caso base es b 1 b 2 (porque b 1 = 0 y b 2 = 1), y para n > 1 tenemos que b n b n/2 + b n/2 + n 1 por recurrencia de a n b (n+1)/2 + b (n+1)/2 + (n + 1) 1 por hipótesis de inducción = b n+1 por recurrencia de b n (note que n/2 (n + 1)/2 y n/2 (n + 1)/2 se ha usado en la segunda línea para usar la hipótesis de inducción).

15 VI.3. ORDENAMIENTO 15 Entonces resolvemos ahora ( ) con igualdad para n = 2 l iterando la relación de recurrencia (con igualdad) a 2 l = a 2 l 1 + a 2 l 1 + (2 l 1) = 2a 2 l 1 + (2 l 1) = 2(2a 2 l l 1 1) + (2 l 1) = 2 2 a 2 l 2 + (2 l 2) + (2 l 1) = 2 2 (2a 2 l 3 + (2 l 2 1) + (2 l 2) + (2 l 1) = 2 3 a 2 l 3 + (2 l 2 2 ) + (2 l 2) + (2 l 1). = 2 i a 2 l i + (2 l 2 i 1 ) + (2 l 2 i 2 ) + + (2 l 2 2 ) + (2 l 2) + (2 l 1). = 2 l a 2 l l + (2 l 2 l 1 ) + (2 l 2 l 2 ) + + (2 l 2 2 ) + (2 l 2) + (2 l 1) = l 2 l (2 l l ) = l 2 l (2 l 1) = (l 1) 2 l + 1, donde se ha usado que a 1 = 0 y 2 l l = 2 l 1. En términos de n, esto es a n = n (log 2 n 1) + 1 si n es de la forma 2 l. Veamos como extender esto a cualquier n: Si n no es de la forma 2 l entonces está entre dos potencias de 2: y puesto que a n es creciente, entonces Pero, teniendo en cuenta ( ), 2 l 1 < n < 2 l ( ) a n a 2 l = 2 l (l 1) l = 2 2 l 1 < 2n y Por lo tanto l 1 < log 2 n. a n < 2n log 2 n + 1, lo cual es válido tambien cuando n es una potencia de 2. Se concluye entonces que a n = O(n log 2 n).

16 16 CAPÍTULO VI. ALGORITMOS: ORDENAMIENTO Código Python ordenamiento: division y mezcla def mezclar(l1,l2): L=[] while L1!=[] and L2!=[]: if L1[0]<=L2[0]: L.append(L1[0]) L1.pop(0) else: L.append(L2[0]) L2.pop(0) L=L+L1 L=L+L2 return(l) def ordenar_por_mezcla(l): if len(l)<=1: return(l) else: m=int(len(l)/2) L1=ordenar_por_mezcla(L[:m]) L2=ordenar_por_mezcla(L[m:]) L=mezclar(L1,L2) return(l) VI.3.4. División y Conquista: Pivote y Separación Este otro método de ordenar también usa el principio de división y conquista. La idea es escoger un pivote, el cual se usa para separar la lista entre elementos menores, iguales y mayores que el pivote. La primera y tercera lista se ordenan recursivamente y el resultado es la concatenación de las tres. Ordenar-por-Separacion (L) si longitud(l) 1 devolver (L) pivote Seleccione-Pivote(L) L 1 []; L 2 []; L p [] para x en L si x < pivote agregar x a L 1 si-no si L[i] > pivote agregar x a L 2 si-no agregar x a L p devolver (Ordenar-por-Separacion(L 1 )+ L p + Ordenar-por-Separacion(L 2 )) Ejemplo: La figura muestra el diagrama de recursión resultante para la lista [3, 5, 1, 4, 8, 9, 2, 7, 6] cuando en cada caso el pivote es el primer elemento del subarreglo siendo ordenado. Número de Comparaciones: El número de comparaciones realizadas depende de la escogencia del pivote. En el peor de los casos, el pivote es siempre el máximo ó mínimo elemento y entonces una recursión es sobre una lista vacía y la otra sobre una lista con un elemento menos. Se obtiene una situación representada

17 VI.3. ORDENAMIENTO 17 (3,5,1,4,8,9,2,7,6) (1,2) (5,4,8,9,7,6) (2) (4) (8,9,7,6) (7,6) (9) (6) por el diagrama en la figura (izquierda), donde el número en un nodo indica el tamaño de la lista a ordenar. El número de comparaciones es entonces cuadrático (los detalles son similares a los de ordenamiento por inserción y selección). Por otra parte, si el pivote resulta ser el elemento medio, entonces la partición es balanceada como se muestra en la figura (derecha). En este caso el análisis es como el de ordenamiento por mezcla y el resultado es O(n log n). En el diagrama se ignora que n/2, n/4 etc. no son necesariamente enteros (además hace falta restar 1, lo que es menos importante ya que nos interesa una cota superior), pero es útil para entender por qué el resultado es O(n log n): Si se suman los valores de los nodos en un mismo nivel, el resultado es n (porque es n/2 i sumado 2 i veces). Y el número de niveles es casi exactamente log 2 n, porque este es el número de veces que n debe ser dividido por 2 para llegar al caso base de la recursión. Por lo tanto el número de comparaciones es O(n log n). La siguiente sección (incluída sólo por información; no fué discutida en clase) muestra que si el pivote se escoge aleatoriamente, entonces en promedio el número de comparaciones realizadas es O(n log n). n 0 n 1 n 0 n 2 n/2 n/2 0 n 3 0 n 4 0 n/4 n/4 n/4 n/4 n 5 n/8 n/8 n/8 n/8 n/8 n/8 n/8 n/8

18 18 CAPÍTULO VI. ALGORITMOS: ORDENAMIENTO Código Python VI.3.5. def seleccion_pivote(l): selecciona un pivote return(l[0]) def ordenar_por_separacion(l): if len(l)<=1: return(l) pivote=seleccion_pivote(l) L1=[]; L2=[]; Lp=[] for item in L: if item<pivote: L1.append(item) elif item>pivote: L2.append(item) elif item==pivote: Lp.append(pivote) return(ordenar_por_separacion(l1)+lp+ordenar_por_separacion(l2)) Separación con Pivote Aleatorio: Quick Sort QuickSort es el algoritmo de ordenamiento por separación, con la adición de que el pivote se escoge aleatoriamente: cada elemento de la lista puede ser escogido como pivote con igual probabilidad. El siguiente análisis muestra que el número de comparaciones es O(n log n). (Nota: Esto no se hizo en clase y es sólo por beneficio de quien quiera leerlo.) Ecuación de Recurrencia Sea T(n) el número esperado de comparaciones para una lista de entrada de longitud n (el valor esperado es el promedio sobre todas las posibles elecciones del pivote). Por simplicidad asumimos que los elementos de la lista son diferentes. Supongamos que se escoge como pivote el k-ésimo elemento en orden creciente. Entonces, después de compararlo a todos los otros n 1 elementos, la ejecuciones recursivas tienen listas de longitud k 1 (elementos menores que el pivote) y de longitud n k (elementos mayores que el pivote). Así que el número esperado de comparaciones en este caso es (n 1) + T(k 1) + T(n k). Puesto que cada uno de los elementos de la lista tiene igual probabilidad de ser elegido como pivote, es decir probabilidad 1/n, entonces el valor esperado teniendo en cuenta todas las posibles elecciones de pivote es T(n) = 1 n n ((n 1) + T(k 1) + T(n k)) k=1 = (n 1) + 1 n n (T(k 1) + T(n k)), k=1

19 VI.3. ORDENAMIENTO 19 con T(0) = T(1) = 0, como casos base. Note que en la suma el primer término resulta en la suma de los términos T(0), T(1), T(2),..., T(n 1) y el segundo en los términos T(n 1), T(n 2),..., T(0). Así que esto se puede reescribir como T(n) = (n 1) + 2 n 1 T(k). n Ahora nos ocupamos de resolver esta ecuación de recurrencia. Alternativa I: Solución aproximada de la ecuación de recurrencia Una posible forma de resolver esta ecuación es verificar que para alguna constante C (por determinar), se tiene que k=1 T(n) Cn ln n. Esto se hace usando inducción (fuerte). El caso base n = 1 es claro puesto que T(1) = 0. Entonces, usando la hipótesis de inducción para k = 1, 2,..., n 1, es decir que T(k) Ck ln k, se tiene (el paso a la segunda línea se aclara adelante) T(n) (n 1) + 2C n n 1 k ln k k=1 = (n 1) + 2C ( n 2 n ln n 2 n ) 4 = Cn ln n + (n 1) (C/2)n = Cn ln n + (1 C/2)n 3 4 Cn ln n + (1 C/2)n. Si C 2, esto es menor ó igual a Cn ln n. En la segunda línea hemos usado la desigualdad n 1 k ln k n2 ln n n k=1 la cual se puede obtener acotando la suma con una integral: n 1 k ln k k=1 = n 1 k ln k ( 1 2 k2 ln k 1 ) n 4 k2 = 1 2 n2 ln n 1 4 n

20 20 CAPÍTULO VI. ALGORITMOS: ORDENAMIENTO Alternativa II: Solución exacta de la ecuación de recurrencia. Aunque la recurrencia no se ajusta a algún método de solución que ya conocemos, con algo de manipulación se puede transformar en una que si es fácil de resolver. Primero, multiplicamos la recurrencia por n y restamos de ella la misma expresión para n 1 (en lugar de n): y entonces nt(n) (n 1)T(n 1) = (n 1)n (n 2)(n 1) + 2T(n 1), T(n) = 2 2 n + n T(n 1) = 4 2n n n + n + 1 T(n 1). n Ahora substituímos t(n) = T(n)/(n + 1) y entonces obtenemos t(n) = 4 n t(n 1), n con t(0) = 0. De aquí, iterando la recurrencia, obtenemos, usando la notación H n = n i=1 1, i Finalmente, t(n) = 4 n i=1 1 n i i=1 = 4(H n+1 1) 2H n = 2H n n i T(n) = (n + 1)t(n) = 2(n + 1)H n 4(n + 1) + 4. H n es llamado el n-ésimo número armónico, y su valor es muy aproximadamente log n, de hecho log(n + 1) H n log n + 1 lo que se puede obtener acotando con integrales. Por lo tanto se obtiene T(n) = O(n log n).