Este documento describe y compara varios algoritmos de ordenamiento como el quicksort, burbuja, inserción y selección. Explica que el quicksort es uno de los más rápidos, con un costo promedio de O(n log n), aunque en el peor caso es O(n2). También analiza la importancia de elegir el pivote de manera efectiva para mejorar el rendimiento del quicksort. Finalmente, concluye que no existe un algoritmo perfecto y la elección depende del uso particular que se le dará.

1. SEDE CONCEPCIÓN TALCAHUANO
Algoritmo de Ordenamiento
Quicksort
Asignatura
Análisis de Algoritmos
Integrantes:
Patricia Espinoza Correa
Javier Vilugrón Gozález
Alvaro Paredes
Daniel Quiñones
Jonh Fornerot
Docente:
Pilar Pardo H
Fecha:
Junio 2014

2. Contenido
Contenido...........................................................................................................................................2
I Introducción.....................................................................................................................................1
1.ALGORITMOS DE ORDENAMIENTO ................................................................................................2
Tipos de Algoritmos .......................................................................................................................2
Algoritmos basados en métodos Iterativos: ..................................................................................2
Algoritmos basados en métodos Recursivos: ................................................................................2
Método Quicksort..............................................................................................................................3
Descripción del Algoritmo:.............................................................................................................5
Análisis del algoritmo:....................................................................................................................6
Ventajas:.....................................................................................................................................6
Desventajas:...............................................................................................................................6
Complejidad computacional del Quicksort: ...................................................................................6
COMPARACION DE TIEMPOS..........................................................................................................8
Eligiendo el Pivote..........................................................................................................................9
CONCLUSIÓN:...................................................................................................................................11
BIBLIOGRAFÍA...................................................................................................................................12

3. I Introducción
Es común que siempre tengamos la interrogante o el deseo de conocer el lugar en
donde se encuentra almacenado un dato o si es que efectivamente está dentro de
nuestra estructura de datos, el problema es la “BÚSQUEDA”…..
¿Cuánto tiempo tardaría una Secretaria si tuviera que buscar entre decenas de
carpetas el archivo de uno de los clientes de la empresa en la cual trabaja....?, de
acuerdo a la eficiencia de la Secretaria, la experiencia que tenga y asumiendo que
estos archivos están perfectamente ordenados y catalogados, se podría especular
que tardaría en promedio unos 15 minutos. Ahora si la misma secretaria pudiera
extraer la información solicitada desde un computador, ¿cuánto tiempo tardaría su
procesador en mostrar el requerimiento que ella está haciendo?
Este es tan sólo un ejemplo de la importancia de las operaciones de búsqueda en
un computador, las cuales se realizan a todos los niveles y con infinidad de
implementaciones distintas, de la cuales, a continuación se examinarán los
algoritmos de búsqueda en una estructura de datos lineal.
1 | P á g i n a

4. 1. ALGORITMOS DE ORDENAMIENTO
Tipos de Algoritmos
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 Burbúja), 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)
2 | P á g i n a

5. – Ordenamiento Rápido (quick)
Método Quicksort
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.
El algoritmo Quicksort fue desarrollado en 1962 por 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.
3 | P á g i n a

6. 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:
public void _Quicksort(int matrix[], int a, int b)
{
this.matrix = new int[matrix.length];
int buf;
int from = a;
int to = b;
int pivot = matrix[(from+to)/2];
do
{
while(matrix[from] < pivot)
{
from++;
}
while(matrix[to] > pivot)
{
to--;
}
if(from <= to)
{
buf = matrix[from];
matrix[from] = matrix[to];
4 | P á g i n a

7. matrix[to] = buf;
from++; to--;
}
}while(from <= to);
if(a < to)
{
_Quicksort(matrix, a, to);
}
if(from < b)
{
_Quicksort(matrix, from, b);
}
this.matrix = matrix;
}
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.
5 | P á g i n a

8.  Como se puede suponer, la eficiencia del algoritmo depende de la posición en
la que termine el pivote elegido.
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 pibote
siempre queda al medio del arreglo.
En el peor de los casos tiene un costo de O(n^2). Cuando el pibote 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.
6 | P á g i n a

9. En el caso promedio también tiene un costo de O(n*log (n)). Se produce cuando el
pibote se inclina más hacia un lado y los 2 subarreglos tienen distinto tamaño 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.
1ini=clock(); // Antes del quicksort:
2final = clock(); //Después que se ejecuta el quicksort
3total =((double)(final – ini)) /
4CLOCKS_PER_SEC; // El valor retornado por clock()
5debe ser dividido por el valor de la macro CLOCKS_PER_SEC
7 | P á g i n a

10. 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áximas
Burbuja
Inserción
Selección
Shell
Merge
Quick (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.
COMPARACION 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 elementos
Burbuja: 0.0040
Selección: 0.0030
Inserción: 0.0040
Rápido: 0.0010
Shell: 0.0010
Merge: 0.0040
Burbuja: 0.0050
Selección: 0.0040
Inserción: 0.0050
Rápido: 0.0010
Shell: 0.0020
Merge: 0.003
8 | P á g i n a

11. 2048 elementos 16384 elementos
Burbuja: 0.022
Selección: 0.015
Inserción: 0.013
Rápido: 0.0010
Shell: 0.0060
Merge: 0.0050
Burbuja: 1.055
Selección: 0.9
Inserción: 0.577
Rápido: 0.0080
Shell: 0.0090
Merge: 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
9 | P á g i n a

12. 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.
10 | P á g i n a

13. CONCLUSIÓN:
La característica fundamental que debe tener un algoritmo es que sea
correcto, es decir, que produzca el resultado deseado en tiempo finito.
Adicionalmente puede interesarnos que sea claro, que esté bien estructurado, que
sea fácil de usar, que sea fácil de implementar y que sea eficiente.
De acuerdo a esta lógica y en la búsqueda constante por encontrar
algoritmos de búsqueda correctos que mantengan tan bajo como sea posible el
consumo de recursos, es decir, que sean lo más eficientes posible, concluimos
que de todos los que investigamos, ningún tipo de búsqueda es mala y a la vez
ninguna es perfecta, depende exclusivamente del uso dado , como por ejemplo la
búsqueda binaria es la más rápida pero a su vez no nos sirve si los datos no están
ordenados de lo contrario la búsqueda lineal a pesar de ser más lenta funcionará
aunque los datos no tengan un orden, por lo tanto el concepto de eficiencia de un
algoritmo es un concepto relativo, esto quiere decir que ante dos algoritmos
correctos que resuelven el mismo problema, lo que prima es la necesidad
individual de cada caso que tengamos que resolver.
11 | P á g i n a

14. BIBLIOGRAFÍA
- http://books.google.cl/books?
id=2sSvS0pDfpAC&pg=PA74&lpg=PA74&dq=PARA+QUE+SIRVEN+LOS+ALGORITMOS+
DE+BUSQUEDA&source=bl&ots=J98yyOpBya&sig=I4h05CaXdGJ7EY16mZLCGNt880g&hl
=es&sa=X&ei=_dFOU9PvLJTNsQSwyYLICw&ved=0CFEQ6AEwBw#v=onepage&q=PARA
%20QUE%20SIRVEN%20LOS%20ALGORITMOS%20DE%20BUSQUEDA&f=false
- http://es.wikibooks.org/wiki/Estructuras_de_datos_din
%C3%A1micas/Algoritmos_de_b%C3%BAsqueda
- http://colabora.inacap.cl/sedes/ssur/Asignatura%20Indtroduccion%20a%20la
%20Programacn/An%C3%A1lisis%20de%20Algoritmo/Manual-Analisis
%20de%20Algoritmos_v1.pdf
12 | P á g i n a