Práctica 4 El algoritmo QuickSort, comparación de algoritmos de ordenación

Transcripción

1 Práctica 4 El algoritmo QuickSort, comparación de algoritmos de ordenación Estructuras de datos y algoritmos Facultad de Informática curso Introducción El objetivo de esta práctica consiste en estudiar experimentalmente diversos algoritmos de ordenación. Al finalizar la práctica dispondrás de los tiempos utilizados para ordenar un vector usando varios algoritmos, de modo que tendrás criterios objetivos para poder elegir la alternativa que creas más adecuada. Se aplicará el mejor de los algoritmos para la lectura de imágenes en un formato artificial pensado exclusivamente para el uso en esta práctica. Te proporcionamos la implementación del algoritmo Shellsort con la que, además, podrás generar medidas que utilizarás en prácticas de Estadística. 1. El formato OIF. El formato de imágenes OIF (Obfuscated Image Format) es un formato de imágenes pensado exclusivamente para el uso en esta práctica. Éste es un formato ofuscado, como su nombre indica, en el cual se propone una solución innecesariamente compleja al problema de dar un formato a una imágen. El OIF es un formato ASCII al igual que el PPM (P3) con el que venimos trabajando. El formato es el siguiente: OIF El formato empieza con la palabra OIF. A continuación se encuentra el ancho y alto de la imágen (número de columnas y de filas respectivamente). En total se tienen n = alto ancho píxeles. A continuación el formato contiene n líneas, cada una de las cuales es una tupla de 4 valores. El primero de ellos es un número real y los otros tres son la componente RGB del píxel Conversión a PPM El objetivo de la práctica es leer un fichero en formato OIF y convertir la imágen al formato PPM. Para poder obtener la imágen se debe de ordenar las n tuplas de acuerdo con el valor real asociado. Una vez ordenadas dichas tuplas se corresponden con los píxeles de la imagen en el orden usual (recorrido por filas de la imagen vista como matriz). Por ejemplo: Este sería un fichero completo en formato OIF: 1

2 OIF Éste debería ser el fichero en formato PPM: P A continuación veremos varios algoritmos de ordenación candidatos a formar parte de la implementación de la lectura del formato OIF. Para elegir el mejor, vamos a realizar una medida experimental del tiempo de CPU necesario para ordenar un vector de una talla determinada. Obviamente, que un algoritmo sea mejor en una talla no significa que lo sea mejor en todas las tallas. El coste de ordenar un vector varía entre individuos (vectores) de una misma talla. Nos han dicho que el formato OIF ordena aleatoriamente los píxelse, así que nos vamos a centrar en estudiar el coste de ordenar vectores desordenados aleatoriamente. 2. Shellsort La siguiente información ha sido obtenida de la wikipedia: El Shell sort es una generalización del ordenamiento por inserción directa, así que en primer lugar vamos a recordar su idea general: 2.1. Inserción directa El ordenamiento por inserción directa (insertion sort en inglés) es una manera muy natural de ordenar para un ser humano, y puede usarse fácilmente para ordenar un mazo de cartas numeradas en forma arbitraria. Inicialmente se tiene un solo elemento, que obviamente es un conjunto ordenado. Después, cuando hay k elementos ordenados de menor a mayor, se toma el elemento k + 1 y se compara con todos los elementos ya ordenados, deteniéndose cuando se encuentra un elemento mayor. En este punto se inserta el elemento k + 1 debiendo desplazarse los demás elementos. El coste de este algoritmo puede variar mucho para una misma talla según las instancias a ordenar. Si el vector a ordenar ya está ordenado o está casi ordenado, el coste será casi lineal. Para un vector desordenado, el coste puede ser cuadrático O(n 2 ), lo cual es mucho peor que otros algoritmos basados en comparaciones (como heapsort) que tienen como caso peor el menos malo posible para este tipo de algoritmos. Una posible implementación de este algoritmo se muestra a continuación: inline void swap ( T &a, T& b) { T tmp =a; a=b; b= tmp ; void insertion_ sort ( T A[], int size ) { for ( int i =1; i < size ; ++ i) for ( int j=i; j >= 1 && A[j -1] > A[ j]; j -= 1) swap (A[j],A[j - 1]);

3 2.2. El shellsort El Shell sort es una generalización del ordenamiento por inserción que siendo también relativamente fácil de implementar mejora el coste de la inserción directa. Está basado en inserción directa pero teniendo en cuenta estas dos observaciones: El ordenamiento por inserción es eficiente si la entrada está casi ordenada. El ordenamiento por inserción es ineficiente, en general, porque mueve los valores sólo una posición cada vez. El algoritmo Shell sort mejora el ordenamiento por inserción comparando elementos separados por un espacio de varias posiciones. Esto permite que un elemento haga pasos más grandes hacia su posición esperada. Los pasos múltiples sobre los datos se hacen con tamaños de espacio cada vez más pequeños. El último paso del Shell sort es un simple ordenamiento por inserción, pero para entonces, ya está garantizado que los datos del vector están casi ordenados. Veamos un ejemplo ilustrativo de cómo funciona. Supongamos que vamos a ordenar el siguiente vector de números: [ ]. Imaginemos que este vector representa una matriz con 5 columnas recorrida por filas. La matriz quedaría así: Entonces lo que podemos hacer es ordenar cada columna, lo que nos da Cuando interpretamos de nuevo estos datos como vector, hemos obtenido: [ ] Para ordenar el conjunto de columnas de un vector visto como matriz con gap (salto) columnas, basta con modificar el algoritmo de inserción directa de la manera siguiente: inline void swap ( T &a, T& b) { T tmp =a; a=b; b= tmp ; inline void insertion_ sort_ with_ gap ( T A[], int size, int gap ) { for ( int i= gap ; i < size ; ++i) for ( int j=i; j >= gap && A[j- gap ] > A[ j]; j -= gap ) swap (A[j],A[j - gap ]); Es interesante observar que los movimientos de elementos para ordenar una fila mueve los elementos convenientemente para ordenar el vector. Es más, cada movimiento en 1 posición en la fila corresponde a 5 posiciones en el vector original. Si ahora hacemos lo mismo viendo una matriz de 3 filas: Y ordenamos de nuevo cada columna:

4 Cuando interpretamos de nuevo estos datos como vector, hemos obtenido: A pesar de no estar todavía ordenado, es un vector menos desordenado que el orginal. Cuando finalmente shellsort utiliza una matriz con una única columna, dicha columna corresponde a la matriz y en esa última iteración lo que hace no es ni más ni menos que el inserción directa original. En este ejemplo hemos usado la secuencia de incrementos o gap de 5,3 y 1, existen diversos estudios que muestran que algunas secuencias son mejores que otras. En esta práctica vamos a utilizar la secuencia siguiente: ,463792,198768,86961,33936, 13776,4592,1968,861,336,112,48,21,7,3,1 Aquí tienes una posible implementación del algoritmo Shellsort en C++: void shell_sort (T A[], int size ) { const int increments_ size = 16; static const int increment_ vector [ increments_ size ] = { ,463792,198768,86961,33936, 13776,4592,1968,861,336,112,48,21,7,3,1 ; for ( int index = 0; index < increments_ size ; ++ index ) insertion_sort_with_gap (A,size, increment_vector [ index ]); Otra posiblidad es desenrrollar el bucle: void shell_sort (T A[], int size ) { insertion_sort_with_gap (A,size, ); insertion_sort_with_gap (A,size,463792); insertion_sort_with_gap (A,size,198768); insertion_sort_with_gap (A,size,86961); insertion_sort_with_gap (A,size,33936); insertion_sort_with_gap (A,size,13776); insertion_ sort_ with_ gap (A, size,4592); insertion_ sort_ with_ gap (A, size,1968); insertion_ sort_ with_ gap (A, size,861); insertion_ sort_ with_ gap (A, size,336); insertion_ sort_ with_ gap (A, size,112); insertion_sort_with_gap (A,size,48); insertion_sort_with_gap (A,size,21); insertion_sort_with_gap (A,size,7); insertion_sort_with_gap (A,size,3); insertion_sort_with_gap (A,size,1); 3. El algoritmo Quicksort El algoritmo Quicksort se basa en la técnica de programación conocida como Divide y vencerás. Este algoritmo consiste básicamente en disponer los elementos del vector menores que un pivote en la parte inicial del vector y los mayores en la parte final. Aplicando repetidamente esta idea sobre estas dos partes se consigue ordenar el vector.

5 void quicksort ( T *v, int l, int r) { if (l<r) { int q= partition (v, l, r); quicksort (v, l, q); quicksort (v, q+1, r); El algoritmo de partición se encarga de disponer los elementos del vector tal como hemos comentado anteriormente Algoritmo de partición Existen diferentes versiones del algoritmo de partición, y la elección de una u otra versión es fundamental para el buen comportamiento del algoritmo de ordenación. En este apartado presentamos un posible algoritmo de partición para el algoritmo Quicksort. A continuación describimos la estrategia a seguir: Elegimos como pivote p un elemento de v[l..r]. Por ejemplo, se puede tomar el primer elemento v[l]. Se hace un recorrido del vector a partir de l, situando los elementos menores o iguales que p en una zona a la izquierda del vector, y los elementos mayores o iguales que p en una zona a la derecha. Para realizar este recorrido, usaremos dos variables i y j, de forma que: v l elementos<=p i j r elementos>=p Al final del recorrido, llegaremos al siguiente estado v l elementos<=p j i elementos>=p r Nótese que los elementos del vector entre las posiciones l y j son todos menores o iguales que los elementos del vector entre las posiciones i y r. El algoritmo de partición devuelve la posición j del vector que marca ambas partes del vector. int partition ( int *v, int l, int r) { int i = l -1, j = r+1, pivote = v[l]; do j - -; while ( pivote < v[j ]); do i ++; while ( v[ i] < pivote ); if (i<j) { int aux = v[ i]; v[i] = v[j]; v[j] = aux ; while (i <j); return j; Con este recorrido se resuelve el problema con un coste Θ(n) siendo n el número de elementos que hay entre las posiciones l y r.

6 4. Medida de tiempos 4.1. Determinación de tiempos de ejecución: primitiva clock Medir el tiempo de ejecución de una rutina es una forma empírica de determinar la calidad de una implementación del algoritmo correspondiente. En el lenguaje C++ se dispone de la librería entandar ctime que corresponde a la librería time.h del lenguaje C. Esta librería nos ofrece algunos tipos de datos y funciones: clock_t clock_t clock() CLOCKS_PER_SEC Tipo similar a un long Retorna un número de tics de reloj Constante para transformar tics a segundos Con ellos podemos medir el tiempo de ejecución entre dos llamadas a la función clock(). Este tiempo no se corresponde con tiempo realmente transcurrido, sino más bien es el tiempo de procesador consumido por el proceso que invoca clock. De esta manera las mediciones resultan bastante independientes de la carga que tenga el sistema debida a otros procesos. Por ejemplo veamos el siguiente código, donde {B es cualquier bloque de instrucciones cuyo tiempo de ejecución se desea determinar: t1 = clock(); {B t2 = clock(); Después de la ejecución de este fragmento de programa el tiempo de proceso consumido por el bloque {B será t2-t1 (en tics). La precisión de clock es limitada. En sistemas Unix/Linux estándar un tic equivale a 0.01 segundos (100 tics/s). Dada la gran potencia computacional que en la actualidad tienen la mayoría de procesadores, esta precisión es realmente muy limitada. Por ejemplo, en un modesto procesador PentiumIII a 450Mhz, una buena implementación del algoritmo Quicksort es capaz de ordenar 200 vectores de 10,000 enteros de 16 bits en 1 segundo; es decir el tiempo necesario para realizar una ordenación es de unos segundos. Si quisiéramos medir este tiempo mediante clock obtendríamos muy probablemente 0 tics. En realidad, se obtendrá aleatoriamente 0 o 1 tics, dependiendo del instante exacto en el que se invoque a clock, y la probabilidad depende del tiempo real y del tiempo entre dos tics. Aunque existen otros métodos de medición que permiten obtener resoluciones por debajo del microsegundo, de momento, por simplicidad, trataremos de arreglárnoslas con la función clock. Obviamente, dadas las limitaciones indicadas, si queremos medir el tiempo de proceso de una instancia deberemos recurrir a medir el tiempo de procesar muchas instancias para sacar la media. Esto plantea el problema de decidir cuántas son las instancias necesarias para obtener una precisión aceptable. En general, el número adecuado de instancias a procesar depende de lo que tarde en procesarse una instancia. Por ejemplo, con el mismo procesador e implementación del Quicksort anteriores, el tiempo de ordenar un vector de de enteros de 16 bits es de 1 segundo aproximadamente. En este caso, el tiempo por instancia se obtiene directamente con una precisión del 1 %, procesando una sola instancia. Por todas estas razones, el método ideal para medir tiempos con la función clock consiste en fijar un tiempo total (mínimo) de proceso, tt, y determinar cuántas instancias completas pueden procesarse en ese tiempo (o algo más). Aquí tienes un esquema para medir tiempos tal y como se propone: clock_t t_inicial, t_final ; double t = 0.0; // tiempo en segundos int iteraciones = 0; // aquí código para preparar lo que queremos medir t_ inicial = clock (); // aquí situamos el código que queremos medir t_final = clock (); t += ( t_final - t_ inicial )/( double ) CLOCKS_ PER_ SEC ; iteraciones ++; while ( t < tt ); // el valor tt podría ser por ejemplo 0.05 t /= iteraciones ; // ahora t tiene el tiempo por instancia

7 4.2. Generación de datos para la práctica de estadística En muchas ocasiones es inmediato ver que un algoritmo es mucho más rápido que otro que resuelve un mismo problema. Pero en otras ocasiones no es tan sencillo, especialmente cuando nos centramos en una talla dada y observamos que el tiempo varía con cada instancia del problema. Uno de los objetivos de esta práctica es aprender a medir tiempos para diversas instancias de un mismo problema con una misma talla. En función de la forma de tomar muestras de esta población (la población de las instancias de un problema para una talla fijada) podemos hablar de datos apareados o no. Como los datos obtenidos en esta práctica podrás aplicar las técnicas que estudias en la asignatura de Estadística. En esta sección te proporcionamos indicaciones concretas para que prepares los datos que debes llevar a la próxima práctica de Estadística. El objetivo de la práctica de Estadística es comparar dos versiones del algoritmo de ordenación Shellsort aplicado a vectores de una talla dada. Es decir, nos vamos a centrar en una sola talla y vamos a generar diversas instancias (distintos vectores de esa talla). La talla elegida es 3000 y vamos a generar 20 vectores y medir el tiempo utilizado para ordenarlos con dos versiones del algoritmo. La diferencia entre las dos versiones radica en la secuencia de saltos aplicados. void shell_sort_a (T A[], int size ) { insertion_sort_with_gap (A,size, ); insertion_sort_with_gap (A,size,463792); insertion_sort_with_gap (A,size,198768); insertion_sort_with_gap (A,size,86961); insertion_sort_with_gap (A,size,33936); insertion_sort_with_gap (A,size,13776); insertion_ sort_ with_ gap (A, size,4592); insertion_ sort_ with_ gap (A, size,1968); insertion_ sort_ with_ gap (A, size,861); insertion_ sort_ with_ gap (A, size,336); insertion_ sort_ with_ gap (A, size,112); insertion_sort_with_gap (A,size,48); insertion_sort_with_gap (A,size,21); insertion_sort_with_gap (A,size,7); insertion_sort_with_gap (A,size,3); insertion_sort_with_gap (A,size,1); y la versión B cambia en la secuencia de saltos aplicados, simplemente hemos eliminado algunos de los saltos: void shell_sort_b (T A[], int size ) { insertion_sort_with_gap (A,size,463792); insertion_sort_with_gap (A,size,86961); insertion_sort_with_gap (A,size,13776); insertion_ sort_ with_ gap (A, size,1968); insertion_ sort_ with_ gap (A, size,336); insertion_sort_with_gap (A,size,48); insertion_sort_with_gap (A,size,7); insertion_sort_with_gap (A,size,1);

8 5. Actividades en el laboratorio 5.1. Comparación de algoritmos Shellsort Estudia y utiliza el programa medirtiempos.cc para generar los datos que necesitarás en la asignatura Estadística para relizar un análisis de datos apareados y no apareados con una muestra de la población formada por 20 muestras de vectores de talla 3000 en cada caso Estudio del algoritmo Quicksort 1. Añade el algoritmo Quicksort en el programa que mide los tiempos para poder compararlo con las dos versiones de Shellsort. Utiliza la versión del algoritmo de partición que toma como pivote la mediana de tres elementos: inline void swap ( T &a, T& b) { T tmp =a; a=b; b= tmp ; T med3 (T v[], int low, int high ) { int cnt = ( low + high )/2; if (v[ cnt ] <v[ low ]) swap (v[ low ],v[ cnt ]); if (v[ high ]<v[ low ]) swap (v[ low ],v[ high ]); if (v[ high ]<v[ cnt ]) swap (v[ cnt ],v[ high ]); swap (v[ cnt ],v[high -1]); return (v[high -1]); inline int partition ( T v[], int low, int high ) { int izq =low, der =high -1; T piv = med3 (v,low, high ); izq ++; while (v[ izq ]< piv ); der - -; while (piv <v[ der ]); swap (v[ izq ],v[ der ]); while (izq < der ); swap (v[ izq ],v[ der ]); swap (v[ izq ],v[high -1]); return izq ; 2. Un estudio para tallas bajas de Inserción directa y de Quicksort, revela que el mejor comportamiento del segundo se manifiesta tempranamente. Aún así, se puede mejorar su comportamiento buscando un umbral óptimo de recursión, por debajo del cual se ordene el subvector mediante Inserción directa. Un método directo y fiable para estimar el umbral óptimo de recursión, consiste en calcularlo experimentalmente. Proponed un experimento que determine un umbral óptimo de recursión, y que al mismo tiempo indique la mejora de tiempos que se puede obtener para tallas del orden de 50,000. Como hipótesis de partida, suponed que el umbral buscado estará como mucho en n = 25, y como muy poco en n = 2. A continuación tienes el código de inserción directa: void InsertionSort ( T v[], int low, int high ) { int i,j; T aux ; for ( i = low +1; i <= high ; i ++) { aux =v[i]; for (j = i -1; j >= low && aux <v[j]; j - -) v[j +1]= v[j]; v[j +1]= aux ; 3. En ocasiones puede resultar adecuado estudiar el comportamiento de los algoritmos en función del número de comparaciones que se realizan entre elementos. Esto es especialmente importante cuando las

9 comparaciones entre elementos son costosas (comparaciones entre estructuras complejas, comparación de imágenes, etc.). Estudia el comportamiento de los algoritmos propuestos en la práctica calculando las comparaciones entre elementos. Para ello debes incluir contadores en dos de los algoritmos a comparar. 4. Como ejercicio opcional puedes probar y comparar la versión del algoritmo de partición que elige un pivote aleatorio del vector. 5. Como ejercicio opcional puedes añadir en la lista de algoritmos a comparar el algoritmo Mergesort Lectura de imágenes en formato OIF Se pretende realizar un programa que convierta del formato OIF al formato PPM. Para ello se pide que implementes el método read_oif en la clase ImageColor. Así mismo, deberás realizar un programa principal llamado oif2ppm que recibe el nombre de una imagen en formato OIF y escribe la misma imagen en formato ppm: $ oif2ppm ejemplo.oif > ejemplo.ppm Referencias [1] C. A. R. Hoare, Quicksort, Computer Journal, Vol. 5 (4), [2] R. Sedgewick, Implementing Quicksort Programas, Communications of ACM, Vol. 21 (10), [3] M. A. Weiss, Estructuras de datos y algoritmos, Addison-Wesley Iberoamericana, 1995.