Ordenamiento de VectoresMétodo QuickSort

Carolina Escobar RestrepoMelissa Escobar Restrepo

Evelyn Quinchia Velásquez

FundamentosProfesor(a): XXX

Universidad YYYMedellín, 2015

Contenido

Introducción........................................................................................................................2Generalidades....................................................................................................................3

Qué es un algoritmo........................................................................................................3Qué es un vector.............................................................................................................3Tipos de algoritmos de ordenamiento.............................................................................3Algoritmos basados en métodos iterativos:.....................................................................3Algoritmos basados en métodos recursivos....................................................................3

Método Quicksort (Ordenamiento Rápido)..........................................................................4Algoritmo fundamental....................................................................................................4Características del algoritmo QuickSort..........................................................................4El algoritmo es el siguiente:............................................................................................5Diagrama de flujo ordenamiento rápido..........................................................................6Descripción del algoritmo................................................................................................7¿Cómo elegimos el pivote?..............................................................................................7Análisis del algoritmo......................................................................................................7Complejidad computacional del Quicksort......................................................................8Comparación de tiempos................................................................................................9Eligiendo el pivote...........................................................................................................9Pseudocódigo en C........................................................................................................10Un ejemplo....................................................................................................................11

Algoritmo en Matlab.........................................................................................................12Ejemplo 1:.....................................................................................................................12Ejemplo 2:.....................................................................................................................15Ejemplo 3:.....................................................................................................................16

Referencias.......................................................................................................................17Documentación:............................................................................................................17Videos:..........................................................................................................................17Ejemplo Matlab:............................................................................................................17

Introducción

Los algoritmos de ordenamiento nos permiten, como su nombre lo dice, ordenar. En este caso, nos servirán para ordenar vectores o matrices con valores asignados aleatoriamente. Nos centraremos en los métodos más populares, analizando la cantidad de comparaciones que suceden, el tiempo que demora y revisando el código, escrito en Java, de cada algoritmo.

Este informe nos permitirá conocer más a fondo cada método distinto de ordenamiento, desde uno simple hasta el más complejo. Se realizaran comparaciones en tiempo de ejecución, pre-requisitos de cada algoritmo, funcionalidad, alcance, etc.

Generalidades

Qué es un algoritmo

Qué es un vector

Tipos de algoritmos de ordenamiento

Para poder ordenar una cantidad determinada de números almacenados en un vector o matriz, existen distintos métodos (algoritmos) con distintas características y complejidad.

Existe desde el método más simple, como el Bubblesort (o Método Burbuja), que son simples iteraciones, hasta el Quicksort (Método Rápido), que al estar optimizado usando recursión, su tiempo de ejecución es menor y es más efectivo.

Algoritmos basados en métodos iterativos:

Estos métodos son simples de entender y de programar ya que son iterativos, simples ciclos y sentencias que hacen que el vector pueda ser ordenado.

Dentro de los Algoritmos iterativos encontramos:

Burbuja Inserción Selección Shellsort

Algoritmos basados en métodos recursivos

Estos métodos son aún más complejos, requieren de mayor atención y conocimiento para ser entendidos. Son rápidos y efectivos, utilizan generalmente la técnica “Divide y Vencerás”, que consiste en dividir un problema grande en varios pequeños para que sea más fácil resolverlos.

Mediante llamadas recursivas a sí mismos, es posible que el tiempo de ejecución y de ordenación sea más óptimo.

Dentro de los algoritmos recursivos encontramos:

Ordenamiento por Mezclas (merge) Ordenamiento Rápido (quick)

Método Quicksort (Ordenamiento Rápido)

Es el algoritmo de ordenamiento más eficiente de todos, se basa en la técnica de "Divide y Vencerás", que permite en promedio, ordenar n elementos en un tiempo proporcional a n*log(n).

Algoritmo fundamental

Elegir un elemento de la lista de elementos a ordenar, al que llamaremos pivote. Resituar los demás elementos de la lista a cada lado del pivote, de manera que a un

lado queden todos los menores que él, y al otro los mayores. Los elementos iguales al pivote pueden ser colocados tanto a su derecha como a su izquierda, dependiendo de la implementación deseada. En este momento, el pivote ocupa exactamente el lugar que le corresponderá en la lista ordenada.

La lista queda separada en dos sublistas, una formada por los elementos a la izquierda del pivote, y otra por los elementos a su derecha.

Repetir este proceso de forma recursiva para cada sublista mientras éstas contengan más de un elemento. Una vez terminado este proceso todos los elementos estarán ordenados.

El método Quicksort basa su estrategia en la idea intuitiva de que es más fácil ordenar una gran estructura de datos subdividiéndolas en otras más pequeñas introduciendo un orden relativo entre ellas. En otras palabras, si dividimos el arreglo a ordenar en dos subarreglos de forma que los elementos del subarreglo inferior sean más pequeños que los del subarreglo superior, y aplicamos el método reiteradamente, al final tendremos el arreglo inicial totalmente ordenado. Existen además otros métodos conocidos, el de ordenación por montículo y el de shell.

Características del algoritmo QuickSort

El algoritmo Quicksort fue desarrollado en 1962 por Sir Charles Antony Richard Hoare (C. A. R. Hoare), antes de que se implementaran los primeros lenguajes con capacidad para ejecutar funciones recursivas.

El ordenamiento por partición (Quick Sort) se puede definir en una forma más conveniente como un procedimiento recursivo.

Tiene aparentemente la propiedad de trabajar mejor para elementos de entrada desordenados completamente, que para elementos semiordenados. Esta situación es precisamente la opuesta al ordenamiento de burbuja.

Este tipo de algoritmos se basa en la técnica "divide y vencerás", o sea es más rápido y fácil ordenar dos arreglos o listas de datos pequeños, que un arreglo o lista grande.

Normalmente al inicio de la ordenación se escoge un elemento aproximadamente en la mitad del arreglo, así al empezar a ordenar, se debe llegar a que el arreglo este ordenado respecto al punto de división o la mitad del arreglo.

Se podrá garantizar que los elementos a la izquierda de la mitad son los menores y los elementos a la derecha son los mayores.

Los siguientes pasos son llamados recursivos con el propósito de efectuar la ordenación por partición al arreglo izquierdo y al arreglo derecho, que se obtienen de la primera fase. El tamaño de esos arreglos en promedio se reduce a la mitad.

Así se continúa hasta que el tamaño de los arreglos a ordenar es 1, es decir, todos los elementos ya están ordenados.

En promedio para todos los elementos de entrada de tamaño n, el método hace O(n log n) comparaciones, el cual es relativamente eficiente.

El algoritmo es el siguiente:

Iniciovariables A: arreglo[1..100] enterovariables i,j,central:enterovariables primero, ultimo: enteropara i = 1 hasta 100

leer(A[i])Fin paraprimero = 1ultimo = 100qsort(A[],100)

Fin

Funcion qsort(primero, ultimo:entero)i = primeroj = ultimocentral = A[(primero,ultimo) div 2]

repetirmientras A[i]central

j = j - 1fin mientrassi i < = j

aux = A[i]A[j] = A[i]A[i] = auxi = i + 1j = j - 1

fin sihasta que i > jsi primero < j

partir(primero,j)fin sisi i < ultimo

partir(i, ultimo)fin si

fin funcion qsort

Diagrama de flujo ordenamiento rápido

Descripción del algoritmo

Elegir un elemento de la lista de elementos a ordenar, al que llamaremos pivote.La idea central de este algoritmo consiste en lo siguiente:

Se toma un elemento x de una posición cualquiera del arreglo. Se trata de ubicar a x en la posición correcta del arreglo, de tal forma que todos los

elementos que se encuentran a su izquierda sean menores o iguales a x y todos los elementos que se encuentren a su derecha sean mayores o iguales a x.

Se repiten los pasos anteriores pero ahora para los conjuntos de datos que se encuentran a la izquierda y a la derecha de la posición correcta de x en el arreglo.

Resituar los demás elementos de la lista a cada lado del pivote, de manera que a un lado queden todos los menores que él, y al otro los mayores. En este momento, el pivote ocupa exactamente el lugar que le corresponderá en la lista ordenada.

Repetir este proceso de forma recursiva para cada sublista mientras éstas contengan más de un elemento. Una vez terminado este proceso todos los elementos estarán ordenados.

Como se puede suponer, la eficiencia del algoritmo depende de la posición en la que termine el pivote elegido.

¿Cómo elegimos el pivote?

Método 1: Lo ideal sería que el pivote fuera la mediana del vector para que las partes izquierda y derecha tuvieran el mismo tamaño.

Método 2: recorremos el vector con un índice i desde 0 a n-1, y otro índice j inversamente y cuando se crucen, es decir, tenga el mismo valor, ese se seleccionara como pivote.

Método 3: Elegir el valor de la primera posición del vector o la última

Método 4: Elegir un valor en una posición aleatoria del vector

En esta figura se ilustra de mejor manera un vector con más elementos, usando como pivote el primer elemento:

Análisis del algoritmo

Estabilidad: No es estable.

Requerimientos de memoria: No requiere memoria adicional en su forma recursiva. En su forma iterativa la necesita para la pila.

Ventajas: Muy rápido. No requiere memoria adicional.

Desventajas: Implementación un poco más complicada. Recursividad (utiliza muchos recursos). Mucha diferencia entre el peor y el mejor caso.

Complejidad computacional del Quicksort

En el mejor de los casos tiene un costo de O(n*log (n)). Que es cuando el pivote siempre queda al medio del arreglo.

En el caso promedio también tiene un costo de O(n*log (n)). Se produce cuando el pivote se inclina más hacia un lado y los 2 subarreglos tienen distinto tamaño de elementos.

En el peor de los casos tiene un costo de O(n^2). Cuando el pivote siempre se inclina hacia a un lado, es decir, genera un arreglo de sólo 1 elemento y una segunda con el resto de elementos.

Para calcular el tiempo de ejecución se usó la función clock() que determina el tiempo usado por el procesador. En este caso defino 3 variables ini, final y total.

1 ini=clock(); // Antes del quicksort:

2 final = clock(); //Después que se ejecuta el quicksort 3 total =((double)(final – ini)) / 4 CLOCKS_PER_SEC; // El valor retornado por clock() 5 debe ser dividido por el valor de la macro CLOCKS_PER_SEC

Cada algoritmo de ordenamiento por definición tiene operaciones y cálculos mínimos y máximos que realiza (complejidad), a continuación una tabla que indica la cantidad de cálculos que corresponden a cada método de ordenamiento:

Algoritmo Operaciones máximasBurbujaInserciónSelecciónShellMergeQuick (Rápido)

Ω(n²)Ω(n²/4)Ω(n²)Ω(n log²n)Ω(n logn)Ω(n²) en peor de los casos y Ω(n logn) en el promedio de los casos.

Comparación de tiempos

Se han ordenado una cantidad determinada de elementos aleatorios en una lista mediante distintos métodos de ordenamiento (en segundos).

256 elementos 512 elementosBurbuja: 0.0040Selección: 0.0030Inserción: 0.0040Rápido: 0.0010Shell: 0.0010Merge: 0.0040

Burbuja: 0.0050Selección: 0.0040Inserción: 0.0050Rápido: 0.0010Shell: 0.0020Merge: 0.003

2048 elementos 16384 elementosBurbuja: 0.022Selección: 0.015Inserción: 0.013Rápido: 0.0010Shell: 0.0060Merge: 0.0050

Burbuja: 1.055Selección: 0.9Inserción: 0.577Rápido: 0.0080Shell: 0.0090Merge: 0.014

Como podemos analizar, el algoritmo que se va demorando cada vez más tiempo es el de la burbuja, luego de selección y tercero el inserción. Los algoritmos que los siguen son el Shell y el de ordenación por mezcla, pero el más óptimo es el “Rápido”.

Eligiendo el pivote

La velocidad de ejecución del algoritmo depende en gran medida de cómo se implementa este mecanismo, una mala implementación puede suponer que el algoritmo se ejecute a una velocidad mediocre o incluso pésima. La elección del pivote determina las particiones de la lista de datos, por lo tanto, huelga decir que esta es la parte más crítica de la implementación del algoritmo QuickSort. Es importante intentar que al seleccionar el pivote v las particiones L1 y L3 tengan un tamaño idéntico dentro de lo posible.

Elegir el primero o el último de la lista nunca es una buena idea ya que los elementos de la lista no están uniformemente distribuidos. Por otro lado, si contamos con un buen

generador de números aleatorios, podemos elegir un pivote al azar de entre todos los elementos de la lista. Esta estrategia es segura puesto que es improbable que un pivote al azar dé como resultado una partición mala, pero tiene como contrapartida que en algunas ocasiones si puede arrojar un resultado de O(n2), además, la elección de números aleatorios puede incrementar el tiempo de ejecución del algoritmo.

Una buena estrategia para solucionar la selección del pivote ampliamente extendida es la conocida como “a tres bandas”. En esta estrategia lo que se persigue es hacer una media con los valores de tres de los elementos de la lista. Por ejemplo si nuestra lista es [ 8, 4, 9, 3, 5, 7, 1, 6, 2 ] la media sería ( 8 + 2 + 5 ) / 3 = 5 lo que daría lugar a las siguientes particiones:

L1 = [ 8, 9, 7, 6 ]L2 = [ 5 ]L3 = [ 1, 2, 4, 3 ]

Esta estrategia no nos asegura que siempre nos dará la mejor selección del pivote, sino que estadísticamente, la elección del pivote sea buena.

Pseudocódigo en C

Tabla de variablesNombre Tipo Usolista Cualquiera Lista a ordenarinf Entero Elemento inferior de la listasup Entero Elemento superior de la listaelem_div

El mismo que los elementos de la lista El elemento divisor

temp El mismo que los elementos de la lista Para realizar los intercambios

i Entero Contador por la izquierdaj Entero Contador por la derecha

cont Entero El ciclo continua mientras cont tenga el valor 1

Nombre Procedimiento: OrdRap Parámetros: lista a ordenar (lista) índice inferior (inf) índice superior (sup) // Inicialización de variables 1. elem_div = lista[sup]; 2. i = inf - 1; 3. j = sup; 4. cont = 1; // Verificamos que no se crucen los límites 5. if (inf >= sup) 6. retornar; // Clasificamos la sublista 7. while (cont) 8. while (lista[++i] < elem_div); 9. while (lista[--j] > elem_div); 10. if (i < j) 11. temp = lista[i];

12. lista[i] = lista[j]; 13. lista[j] = temp; 14. else 15. cont = 0;

// Copiamos el elemento de división // en su posición final 16. temp = lista[i]; 17. lista[i] = lista[sup]; 18. lista[sup] = temp; // Aplicamos el procedimiento // recursivamente a cada sublista 19. OrdRap (lista, inf, i - 1); 20. OrdRap (lista, i + 1, sup);

Nota: La primera llamada debería ser con la lista, cero (0) y el tamaño de la lista menos 1 como parámetros.

Un ejemplo

Esta vez voy a cambiar de lista5 - 3 - 7 - 6 - 2 - 1 - 4Comenzamos con la lista completa. El elemento divisor será el 4:5 - 3 - 7 - 6 - 2 - 1 - 4Comparamos con el 5 por la izquierda y el 1 por la derecha.5 - 3 - 7 - 6 - 2 - 1 - 45 es mayor que cuatro y 1 es menor. Intercambiamos:1 - 3 - 7 - 6 - 2 - 5 - 4Avanzamos por la izquierda y la derecha:1 - 3 - 7 - 6 - 2 - 5 - 43 es menor que 4: avanzamos por la izquierda. 2 es menor que 4: nos mantenemos ahí.1 - 3 - 7 - 6 - 2 - 5 - 47 es mayor que 4 y 2 es menor: intercambiamos.1 - 3 - 2 - 6 - 7 - 5 - 4Avanzamos por ambos lados:1 - 3 - 2 - 6 - 7 - 5 - 4En este momento termina el ciclo principal, porque los índices se cruzaron. Ahora intercambiamos lista[i] con lista[sup] (pasos 16-18):1 - 3 - 2 - 4 - 7 - 5 - 6Aplicamos recursivamente a la sublista de la izquierda (índices 0 - 2). Tenemos lo siguiente:1 - 3 - 21 es menor que 2: avanzamos por la izquierda. 3 es mayor: avanzamos por la derecha. Como se intercambiaron los índices termina el ciclo. Se intercambia lista[i] con lista[sup]:1 - 2 - 3Al llamar recursivamente para cada nueva sublista (lista[0]-lista[0] y lista[2]-lista[2]) se retorna sin hacer cambios (condición 5.).Para resumir te muestro cómo va quedando la lista:Segunda sublista: lista[4]-lista[6]7 - 5 - 65 - 7 - 65 - 6 - 7Para cada nueva sublista se retorna sin hacer cambios (se cruzan los índices).Finalmente, al retornar de la primera llamada se tiene el arreglo ordenado:1 - 2 - 3 - 4 - 5 - 6 – 7

Algoritmo en Matlab

Ejemplo 1:

quicksort(x)function x = quicksort(x)%--------------------------------------------------------------------------% Syntax: sx = quicksort(x);% % Inputs: x is a vector of length n% % Outputs: sx is the sorted (ascending) version of x% % Description: This function sorts the input array x in ascending order% using the quicksort algorithm% % Complexity: O(n * log(n)) best-case performance% O(n * log(n)) average-case performance% O(n^2) worst-case performance% O(log(n)) auxiliary space (stack)% % Author: Brian Moore% brimoor@umich.edu% % Date: January 5, 2014%--------------------------------------------------------------------------

% Knobskk = 15; % Insertion sort threshold, kk >= 1

% Quicksortn = length(x);x = quicksorti(x,1,n,kk);

end

function x = quicksorti(x,ll,uu,kk)% Sort x(ll:uu) via quick sort % Note: In practice, x xhould be passed by reference

% Select pivot and partition data around it[x mm] = partition(x,ll,uu);

% Divide-and-conquerif ((mm - ll) <= kk) % Sort x(ll:(mm - 1)) via insertion sort x = insertionsorti(x,ll,mm - 1);else % Sort x(ll:(mm - 1)) via quick sort x = quicksorti(x,ll,mm - 1,kk);endif ((uu - mm) <= kk) % Sort x((mm + 1):uu) via insertion sort

x = insertionsorti(x,mm + 1,uu);else % Sort x((mm + 1):uu) via quick sort x = quicksorti(x,mm + 1,uu,kk);end

end

function [x mm] = partition(x,ll,uu)% Partition x(ll:uu) around index mm% Note: In practice, x xhould be passed by reference

%--------------------------------------------------------------------------% Select pivot%--------------------------------------------------------------------------% Method 1: Median-of-3 pivotpp = medianofthree(x,ll,uu); % Median-of-three pivot index

% Method 2: Random pivot%pp = randi([ll uu]); % Random pivot index%--------------------------------------------------------------------------

% Partition around pivotx = swap(x,ll,pp);mm = ll;for j = (ll + 1):uu if (x(j) < x(ll)) mm = mm + 1; x = swap(x,mm,j); endendx = swap(x,ll,mm);

end

function pp = medianofthree(x,ll,uu)% Compute median of {x(ll),x(mm),x(uu)}% Note: In practice, x xhould be passed by reference

% Middle element (avoiding overflow)mm = ll + floor((uu - ll) / 2);

% Compute median of {x(ll),x(mm),x(uu)}if (x(ll) <= x(mm)) if (x(uu) >= x(mm)) pp = mm; elseif (x(uu) >= x(ll)) pp = uu; else pp = ll; endelse if (x(uu) >= x(ll)) pp = ll; elseif (x(uu) >= x(mm)) pp = uu;

else pp = mm; endend

end

function x = insertionsorti(x,ll,uu)% Sort x(ll:uu) via insertion sort % Note: In practice, x xhould be passed by reference

% Insertion sortfor j = (ll + 1):uu pivot = x(j); i = j; while ((i > ll) && (x(i - 1) > pivot)) x(i) = x(i - 1); i = i - 1; end x(i) = pivot;end

end

function x = swap(x,i,j)% Swap x(i) and x(j)% Note: In practice, x xhould be passed by reference

val = x(i);x(i) = x(j);x(j) = val;

end

Ejemplo 2:

Script:A = [3 6 2 5 1 7 4];rightIndex = length(A);E = QuickSort(A,1,rightIndex);QuickSort:function [pvt, B] = QuickSort(A,left,right)

if left < right [B, pvt] = PartnPivot1(A, left, right); %chosen pivot QuickSort(B, left, pvt-1); QuickSort(B, pvt+1, right);endPartition:function [sortedSubArray, pivot] = PartnPivot1(subArray,leftIndex,rightIndex)

%% InitializationsS = subArray;left = leftIndex;right = rightIndex;

P = S(left); %pivoti = left+1;

%% Partitionfor j = i:right if S(j) < P temp1 = S(j); % temp2 = S(i); % swap S(i) with S(j) S(j) = temp2; % S(i) = temp1; % i = i+1; %increment i only when swap occurs endendswap1 = S(left); %swap2 = S(i-1); % final swap S(left) = swap2; %S(i-1) = swap1; %

sortedSubArray = S;pivot = P;

Ejemplo 3:

function [y]=quicksort(x)  % Uses quicksort to sort an array. Two dimensional arrays are sorted column-wise.

[n,m]=size(x);if(m>1)

y=x;for j=1:m

y(:,j)=quicksort(x(:,j));endreturn;

end% The trivial casesif(n<=1);y=x;return;end;if(n==2)

if(x(1)>x(2))x=[x(2); x(1)];

endy=x;return;

end% The non-trivial case% Find a pivot, and divide the array into two parts.% All elements of the first part are less than the% pivot, and the elements of the other part are greater % than or equal to the pivot.m=fix(n/2);

pivot=x(m);ltIndices=find(x<pivot); % Indices of all elements less than pivot.if(isempty(ltIndices)) % This happens when pivot is miniumum of all

elements.ind=find(x>pivot); % Find the indices of elements greater

than pivot.if(isempty(ind));y= x;return;end; % This happens when all

elements are the same.pivot=x(ind(1)); % Use new pivot.ltIndices=find(x<pivot);

end  % Now find the indices of all elements not less than pivot.

% Since the pivot is an element of the array, % geIndices cannot be empty.geIndices=find(x>=pivot);% Recursively sort the two parts of the array and concatenate % the sorted parts.y= [quicksort(x(ltIndices));quicksort(x(geIndices))];

Referencias

Documentación:

Algoritmos de ordenación. Alejandro Alcalde. Recuperado dehttp://elbauldelprogramador.com/algoritmos-de-ordenacion/

Algoritmo Quicksort. Javier Vilugrón. Recuperado dehttps://javiervilugrong.wordpress.com/algoritmo-quicksort/

Algoritmo Método Quicksort. Patricia Correa. Recuperado dehttp://es.slideshare.net/PatriciaCorrea6/algoritmo-metodo-quicksort

Los 3 métodos de ordenamiento más populares. Recuperado dehttp://gl-epn-programacion-ii.blogspot.com/2010/06/metodos-de-ordenamiento.html

Mis Algoritmos. Ordenamiento Rápido (Quicksort). Recuperado dehttp://mis-algoritmos.com/ordenamiento-rapido-quicksort

Ordenamiento de vectores. Ingeniero Néstor Díaz Fiet – Unicauca. 2005. Recuperado dehttp://artemisa.unicauca.edu.co/~nediaz/EDDI/cap03.htm

Videos:

Quicksort. Recuperado dehttp://www.neoteo.com/quicksort-algoritmo-de-ordenamiento-rapido/

Quick-sort with Hungarian (Küküllőmenti legényes) folk dance. Recuperado dehttps://youtu.be/ywWBy6J5gz8

Método de Ordenamiento Quicksort. Recuperado de https://youtu.be/TtBXHSHtCfk

Ordenamiento Quicksort. Cristian Vargas. Recuperado de https://youtu.be/kqmXS-L-LBg

Visualization of Quick Sort. Recuperado dehttps://youtu.be/vxENKlcs2Tw

Visualization of Quick sort (HD). Recuperado de https://youtu.be/aXXWXz5rF64

Ejemplo Matlab:

http://www.mathworks.com/matlabcentral/fileexchange/45125-sorting-methods/content/Sorting%20Methods/quicksort.m

http://stackoverflow.com/questions/15047606/quicksort-debugging-in-matlab

http://www.codecodex.com/wiki/Quicksort#MATLAB