Anlisis de Algoritmos de Ordenacin

1. Resumen

En ste documento se analizarn los algoritmos de ordenacin en un array de elementos de tipo Int. Los algoritmos de este documento sern escritos en C++, todos aceptan los mismos parmetros: un array A de datos y un entero que representa el tamao del array. Los algoritmos con lo que se realizar el experimento son: Bubble Sort, Select Sort, Insert Sort, Shell Sort y Quick Sort. La PC que estamos usando tiene las siguientes caractersticas: SO : W indows7U ltimate32bits F abricante : Intel M odelo : W BIBX10J P rocesador : Inteli3@3,07GHzde4CP U s RAM : 4096M B Cabe resaltar que hemos utilizado el peor caso al momento de ejecutar dichos algoritmos: Una lista decreciente.

2.
2.1.

Marco Terico
BubbleSort

Este algoritmo de ordenacin consiste en comparar cada elemento del vector con el elemento siguiente; intercambindolos si no estn en el orden correcto. Es conocido como el Mtodo de intercambio directo y es el ms sencillo de implementar.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

void bubblesort(int a[],int n) { int mem; for(int i=1; i<n; i++) { for(int j=1; j<=n; j++) { if(a[j-1]>a[j]) { mem=a[j]; a[j]=a[j-1]; a[j-1]=mem; } } } }

En la ordenacin Burbuja siempre se realizan el mismo nmero de comparaciones, ya sea en el mejor o peor de los casos; al ser una lista ordenada decreciente (peor de los casos) se realiza un mayor nmero de intercambios; pero en el mejor de los casos no se realiza ningn intercambio. Es un algoritmo ineciente dado que su rendimiento es n2 .

2.2.

SelectSort

Este algoritmo consiste en seleccionar el menor elemento entre una posicin i y el nal del vector; e intercambiarlo con el elemento en la posicin i.
1 2 3 4 5 6 7 8 9 10 11 12 13

void selectsort(int a[],int n) { int mem; for(int i=0;i<n-1;i++) { int min=i; for(int j=i+1;j<n;j++) if(a[j]<a[min]) min=j; mem = a[i]; a[i] = a[min]; a[min] = mem; } }

Es ligeramente ms eciente que el mtodo burbuja ya que realiza menos intercambios. Select sort no mejora su rendimiento cuando la lista est ordenada o parcialmente ordenada; siempre se realiza el mismo procedimiento. El rendimiento de este algoritmo en el peor de los casos es n2 .

2.3.

InsertSort

Se tiene un vector, y se toma un valor i que comienza en 1, y un valor j en (i-1); compara i con los elementos anteriores y se posiciona en el orden correcto; todos los elementos que no han sido comparados corren una la a la derecha. i va en aumento mientras que j decrece hasta cuando (i=1).
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

void insertsort(int a[],int n) { int mem; for(int i=1;i<n;i++) { for(int j=i;j>0;j--) { if(a[j]<a[j-1]) { mem=a[j-1]; a[j-1]=a[j]; a[j]=mem; } else break; } } }

Este algoritmo no es tan eciente como quicksort, pero en listas pequeas puede ser una buena opcin. Es bastante sencillo de programar y su tiempo de demora es n2 .

2.4.

ShellSort

A diferencia del algoritmo de ordenacin por insercin, este algoritmo intercambia elementos distantes. Es por esto que puede deshacer ms de una inversin en cada intercambio, hecho del cual nos aprovechamos para ganar velocidad. 2

La velocidad del algoritmo depender de una secuencia de valores (llamados incrementos, de los cuales hablaremos ms abajo) con los cuales trabaja utilizndolos como distancias entre elementos a intercambiar. Veremos que con algunas secuencias podremos obtener ordenes de tiempo de ejecucin en el peor caso de O(n2 ), O(n3/2 )yO(n4/3 ). Se considera la ordenacin de Shell como el algoritmo ms adecuado para ordenar entradas de datos moderadamente grandes (decenas de millares de elementos) ya que su velocidad, si bien no es la mejor de todos los algoritmos, es aceptable en la prctica y su implementacin (cdigo) es relativamente sencillo.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

void shellsort(int a[], int n) { int incr = n / 2, p, j; int tmp; do{ for (p = incr + 1; p < n; p++){ tmp = a[p]; j = p - incr; while ((j >= 0) && (tmp < a[j])){ a[j + incr] = a[j]; j -= incr;} a[j + incr] = tmp;} incr /= 2;} while (incr > 0); }

2.5.

QuickSort

"Divide y vencers" Este algoritmo fue creado por el britnico C. A. R. Hoare; quicksort permite ordenar un vector con un tiempo de demora de n.logn. El algoritmo consiste en elegir un pivote, y separar a un lado los elementos menores que el pivote y al otro los elementos mayores. Al hacer esto, el pivote queda en la posicin que le corresponde; se aplica el algoritmo de forma recursiva a ambos lados del pivote y cuando este procedimiento termine, el vector ya estar ordenado.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

int partir(int a[], int ini, int fin) { int i, pivote = ini, temp, valor_pivote = a[pivote]; for (i=ini+1; i<=fin; i++){ if (a[i] < valor_pivote){ pivote++; temp=a[i]; a[i]=a[pivote]; a[pivote]=temp;} } temp=a[ini]; a[ini]=a[pivote]; a[pivote]=temp; return pivote; } void quickSort(int a[], int ini, int fin) {

22 23 24 25 26 27

if(ini>=fin)return; int Pospiv=partir(a, ini, fin); quickSort(a, ini, Pospiv-1); quickSort(a, Pospiv+1, fin); }

El tiempo de demora promedio es de n.logn; pero en el peor de los casos, cuando el pivote termina siempre en un extremo del vector el tiempo de demora es n2 . El tiempo de demora es n.logn.

3.

Experimentos

A continuacin mostraremos una grca con los tiempos de Demora que han tenido los algoritmos, los tiempos de demora se han obtenido usando el siguiente Cdigo:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39

#include <iostream> #include <Windows.h> #include <sys/time.h> using namespace std; double performancecounter_diff(LARGE_INTEGER *a,LARGE_INTEGER *b) { LARGE_INTEGER freq; QueryPerformanceFrequency(&freq); return (double)(a->QuadPart - b->QuadPart) / (double)freq.QuadPart; } {\large \textbf{[...]}} void doingFunc(int a[], int n) { LARGE_INTEGER t_ini, t_fin; double secs; QueryPerformanceCounter(&t_ini); bubblesort(a,n); QueryPerformanceCounter(&t_fin); secs = performancecounter_diff(&t_fin, &t_ini); cout <<"Se ha demorado "<<secs*1000.0<< " En bubbleSort con "<<n<<" elementos"<<endl; QueryPerformanceCounter(&t_ini); selectsort(a,n); QueryPerformanceCounter(&t_fin); secs = performancecounter_diff(&t_fin, &t_ini); cout <<"Se ha demorado "<<secs*1000.0<< " En SelectSort con "<<n<<" elementos"<<endl; QueryPerformanceCounter(&t_ini); shellsort(a,n); QueryPerformanceCounter(&t_fin); secs = performancecounter_diff(&t_fin, &t_ini); cout <<"Se ha demorado "<<secs*1000.0<< " En ShellSort con "<<n<<" elementos"<<endl;

40 41 42 43 44 45 46 47 48 49 50 51 52 53 54

QueryPerformanceCounter(&t_ini); insertsort(a,n); QueryPerformanceCounter(&t_fin); secs = performancecounter_diff(&t_fin, &t_ini); cout <<"Se ha demorado "<<secs*1000.0<< " En InsertSort con "<<n<<" elementos"<<endl; QueryPerformanceCounter(&t_ini); quickSort(a,0,n-1); QueryPerformanceCounter(&t_fin); secs = performancecounter_diff(&t_fin, &t_ini); cout <<"Se ha demorado "<<secs*1000.0<< " En QuickSort con "<<n<<" elementos"<<endl; }

En la siguiente gura podemos ver la grca (Tiempo vs Cantidad de Elementos)

4.

Conclusin

Como programadores, debemos buscar la manera ms eciente para realizar un algoritmo, quizs los mejores ejemplos sean los algoritmos de bsqueda y de ordenacin, cada uno de ellos va variando en su complejidad (Eciencia), existen distintos modos de calcularla: por medio de la cota superior asinttica o por la medicin de tiempo de Reloj. Segn el grco que se encuentra arriba vemos que el mejor algoritmo (el ms eciente) es Quick Sort, seguido de Shell Sort; los otros mtodos tienen una eciencia de n2 as que concluimos que Bubble Sort, Select Sort e Insert Sort son los menos ecientes.

Bibliografa
[Wikipedia] http://en.wikipedia.org/wiki/Insertion_sort Insertion Sort [Wikipedia] http://en.wikipedia.org/wiki/Selection_sort Selection Sort [Wikipedia] http://en.wikipedia.org/wiki/Bubble_sort Bubble Sort [Wikipedia] http://en.wikipedia.org/wiki/Shellsort Shell Sort [Sorting Algorithms] http://www.sorting-algorithms.com/shell-sort Shell Sort [Knol beta] http://knol.google.com/k/analisis-de-rendimiento-de-algoritmos-de-ordenacin Analisis de rendimiento de algoritmos de ordenacin (Java) [C ms o menos] http://cmasomenos.blogspot.com/2008/03/medir-el-tiempo-de-una-rutina.html Medir el tiempo de una rutina