MÉTODO DE ORDENAMIENTO QUICKSORT

ESTRUCTURAS DE DATOS II
 HISTORIA DEL MÉTODO QUICKSORT
 El método Quicksort fue ideado por el científico inglés Charles
Anthony Hoare en 1960.
 Hoare, quien se hallaba en Rusia, trabajaba en un proyecto de
traducción en computadora (del ruso al inglés).
 Él usó este método al principio para ordenar las palabras en
ruso, para poder traducirlas.
 Luego se observó la utilidad de este método en otros campos
de la informática.
 DEFINICIÓN DEL MÉTODO QUICKSORT

 Se trata de un método de ordenamiento de intercambio.

 También se le conoce como método rápido o método de

ordenación por partición.

 Es considerado el más rápido de todos los métodos de

ordenamiento, aun en el peor de los casos; de ahí su
nombre (inglés para Ordenamiento Rápido).
 DEFINICIÓN DEL MÉTODO QUICKSORT

 Actualmente es uno de los más usados por su eficiencia y

velocidad para la ordenación interna.

 Se basa en la premisa Divide y Vencerás, es decir, divide el

problema en sub-problemas.

 También usa la recursividad y la iteración dentro de su

algoritmo.
 ALGORITMO DEL QUICKSORT
Pasos para ordenar mediante la técnica Quicksort.
Se toma un elemento cualquiera de una posición cualquiera del arreglo. Este será
nuestro elemento Pivote.
Se trata de ubicar al Pivote en la posición correcta del arreglo, de tal forma que todos
los elementos que se encuentran a su izquierda sean menores o iguales al pivote y
todos los elementos que se encuentren a su derecha sean mayores o iguales.
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 del pivote en el arreglo.
Una vez que los elementos menores al pivote quedan a su izquierda y los mayores a su
derecha, el pivote queda exactamente en el lugar que ocupara dentro del arreglo
ordenado. De esta manera, por cada recursión(o iteración según sea el caso), los
pivotes de las sublistas quedaran ordenados.
Optimización: Elección del pivote.
Se elige desde un conjunto de tres elementos: lista[inferior], lista[mitad] y
lista[superior]. El elemento elegido es el que tenga el valor medio según el criterio de
comparación. Esto evita el comportamiento degenerado cuando la lista está
prácticamente ordenada.
 ALGORITMO DEL QUICKSORT
Mejor de los casos: el pivote termina en el centro del arreglo, generando dos sublistas para
cada iteración. En este caso, el orden de complejidad del algoritmo es O(n•log(n)).
Peor de los casos: el pivote termina en un extremo del arreglo, generando una sola sublista
para cada iteración. Este caso es, por consiguiente, cuando la lista esta completamente
ordenada. El orden de complejidad del algoritmo es entonces de 0(n²).
Caso promedio: el orden es O(n•log(n)). Nótese que el mejor de los casos y el casi intermedio
tienen exactamente el mismo orden, lo que vuelve a este algoritmo muy eficiente.
La mayoría de los problemas de rendimiento se pueden solucionar algunas optimizaciones,
principalmente en el pivote, esto complicara mas la implementación del algoritmo, que ya de
por si no suele resultar sencillo para principiantes de programación.
 Pseudocodigo de Quicksort
function quicksort($A) { // intercambiar pivot = j;
pivot = 0; aux = A[i]; Fin si__1
si__1 tamaño A <= 1) (si el vector es A[i] = A[j]; der = pivot;
mayor de un elemento) A[j] = aux; array = quicksort( vector( 0, $der);
devuelve A; Hacer_3 $izq = tamaño vector$A - pivot - 1;
no__1 I=i+1 $array2 = quicksort(vector ($pivot + 1,
p = A[0]; Mientras_3 A[i] < p; $izq));
i = 0; Hacer_4 Devuelvo $array1+ A[pivot]+$array2;
j =tamaño de A; -j=j-1 }
hacer__1 Mientras_4 A[j] > p; }
i=i+1; } $A =defino array;
mientras_1 A[i] <= p y i< tamaño // intercambiar $Ai = $A;(guardo vector inicial sin ordenar)
A-1 $A = quicksort($A); (llamo a la función
aux = A[0];
hacer__2 quicksort)
A[0] = A[$j];
j=j-1; Muestro vector inicial Ai
A[$j] = aux;
mientras A[j] > p; Muestro vector ordenado A
mientras (i < j)
Se ordena una lista de números enteros aplicando el algoritmo quicksort,
como pivote se elige elelemento central de la lista.
Lista original: 8 1 4 9 6 3 5 2 7 0
Pivote (elemento central) 6
La etapa 2 requiere mover todos los elementos menores que el pivote a la
parte izquierda del array y los elementos mayores a la parte derecha. Para
ello, se recorre la lista de izquierda a derecha utilizando un índice i que se
inicializa a la posición más baja (inferior) buscando un elemento mayor al
pivote. También se recorre la lista de derecha a izquierda buscando un
elemento menor. Para hacer esto se utilizará un índice j inicializado a la
posición más alta (superior).
El índice i se detiene en el elemento 8 (mayor que el pivote) y el índice j se
detiene en el elemento 0 (menor que el pivote)
Declaremos un arreglo de 9 posiciones con
numeros aleatorios...
 1 2 3 4 5 6 7 8 9
Pivote
44 75 23 43 55 12 64 77 33
44

Primero Ult imo

Up Down

Colocamos a Up como Primero y Down como Ultimo.

 1 2 3 4 5 6 7 8 9

Pivote 44 75 23 43 55 12 64 77 33
44
Primero Ult imo

Up Up Down

Muevo Up al primer valor mayor que el pivote

Despues movemos Down al primer valor de derecha a izquierda
menor que el pivote (en este caso Down no se mueve).
 1 2 3 4 5 6 7 8 9

Pivote 44 75 23 43 55 12 64 77 33
44
Primero Ultimo
Up Down

Ahora intercambiamos los valores de Up y Down

1 2 3 4 5 6 7 8 9
44 33 23 43 55 12 64 77 75
 1 2 3 4 5 6 7 8 9

Pivote 44 33 23 43 55 12 64 77 75
44
Primero
Ultimo Up Down
Desde la posicion en que se encuentra movemos Up a un valor mayor
que el pivote. 1 2 3 4 5 6 7 8 9

44 33 23 43 55 12 64 77 75

Primero Ulti mo
Up Down
 1 2 3 4 5 6 7 8 9
Pivote
44 44 33 23 43 55 12 64 77 75

Primero
Up Down Ultimo
Down

Cambiamos Down a la posicion menor que el pivote recorriendo de

Derecha a Izquierda
 1 2 3 4 5 6 7 8 9
Pivote
44 44 33 23 43 55 12 64 77 75

Primero
Up Down Ultimo
Down

Intercambiamos los valores de Up y Down…

1 2 3 4 5 6 7 8 9
44 33 23 43 12 55 64 77 75
 1 2 3 4 5 6 7 8 9

Pivote 44 33 23 43 12 55 64 77 75
44
Primero Up Down Ultimo
Movemos Up desde la posicion en que se encuetra a la
primera posicion mayor que el pivote y Down a la primera
posicion de derecha a Izquierda menor que el pivote.
1 2 3 4 5 6 7 8 9
44 33 23 43 12 55 64 77 75

Primero Up Down Ultimo

Como Up y Down se cruzaron, entonces debemos
intercambiar el valor de Down por el pivote.

Pivote 1 2 3 4 5 6 7 8 9
44
12 33 23 43 44 55 64 77 75

Primero Down
Ultimo
PivIndex
Ahora notemos que todos los valores debajo de PivIndex son
menores que el y los que estan por encima son mayores que el.
 Esto nos da ahora dos nuevos subarreglos
que hay que ordenar

1 2 3 4 5 6 7 8 9

12 23 43 44 55 64 77 75

33 Ultimo 1 Primero 2 Ultimo 2

PivIndex
SePrimero 1 el proceso hasta que los subarreglos
debe repetir
estén ordenados, lo cual nos dará como resultado el
arreglo ordenado.
El algoritmo del método de ordenamiento estará formado
por tres procesos:

• QuickSort, proceso que inicia el ordenamiento.

• Encuentra Pivote, busca el mejor pivote a partir
del primer elemento del vector
• Partición, va comparando por ambos extremos e
intercambia en caso de ser necesario
1. Inicio quicksort( i , j : enteras)
2. indice-pivoteencuentra-pivote( i , j)
3. Si indice-pivote < > 0 entonces
1. pivote  A[indice-
pivote].data
2. kparticion( i , j , pivote)
3. quicksort( i , k – 1)
4. quicksort(k , j )
4. Fin quicksort
1. Inicio encuentra-pivote( i , j : enteras)
2. primera-claveA[i].data
3. Para k i +1 hasta j hacer
3.1 Si a[k].data > primera-clave entonces
returna k
de lo contrario,
Si A[k].data > primera-clave entonces
returna i
4. returna 0
5. Fin
1. Inicio partición( i , j : enteras, pivote:tipo-clave) :
entero
2. z i;
3. dj;
4. Repetir
intercambiar(A[z],A[d])
Mientras A[z].data < pivote
hacer z  z + 1
Mientras A[d].data >= pivote
hacer d d + 1
hasta
z>d
4. returna z
5. Fin
El primer problema a resolver en el diseño del algoritmo de quicksort es
seleccionar el pivote.
Aunque su posición, en principio, puede ser cualquiera, una de las decisiones
más ponderadas es aquella que considera el pivote como el elemento central
o próximo al central de la lista. La Figura 6.2 muestra las operaciones del
algoritmo para ordenar la lista a[] de n elementos enteros.
Los pasos que sigue el algoritmo quicksort son: 
1. Seleccionar el elemento central de a[] como pivote.
2. Dividir los elementos restantes en particiones izquierda y derecha, de
modo que ningún elemento de la izquierda tenga una clave (valor) mayor
que el pivote y que ningún elemento a la derecha tenga una clave menor
que la del pivote.
3. Ordenar la partición izquierda utilizando quicksort recursivamente.
4. Ordenar la partición derecha utilizando quicksort recursivamente.
5. La solución es partición izquierda seguida por el pivote y, a continuación,
partición derecha.
Ventaja y desventajas

Ventajas
 Muy rápido
 No requiere memoria adicional.
Desventajas
 Implementación un poco más complicada.
 Recursividad.
 Mucha diferencia entre el peor y el mejor caso.