Ordenación por el método QuickSort

Durán Navarro Reinaldo José

Pavajeau Max Carlos Andrés
El método de ordenación QuickSort es actualmente el más eficiente
y veloz de todos los métodos de ordenación interna. Este método es una
mejora sustancial del método de intercambio directo y se denomina
QuickSort por la velocidad con la que ordena los elementos del
arreglo.
 Historia del algoritmo

Creado en 1960 por Sir Charles Antony Richard Hoare, desarrolló el

algoritmo de ordenación QuickSort casi por casualidad mientras ideaba la
forma de facilitar la búsqueda de palabras en el diccionario.
 ¿En qué se basa?

El algoritmo QuickSort se basa en la técnica de "divide y vencerás" por

la que en cada recursión, el problema se divide en sub-problemas de menor
tamaño y se resuelven por separado (aplicando la misma técnica) para
ser unidos de nuevo una vez resueltos.
Arreglo de 10 elementos

8 1 4 9 6 3 5 2 7 0
n
Se toma el índice del primer elemento de la lista, se suma con el índice del
ultimo elemento y se divide entre 2.
Eso nos da la posición del elemento central de la lista que será nuestro pivote.

8 1 4 9 6 3 5 2 7 0
Se toma el índice del primer elemento de la lista, se suma con el índice del
ultimo elemento y se divide entre 2.
Eso nos da la posición del elemento central de la lista que será nuestro pivote.

8 1 4 9 6 3 5 2 7 0
io jn-1
Se toma el índice del primer elemento de la lista, se suma con el índice del
ultimo elemento y se divide entre 2.
Eso nos da la posición del elemento central de la lista que será nuestro pivote.

0 1 2 3 4 5 6 7 8 9

8 1 4 9 6 3 5 2 7 0
0 9
Se toma el índice del primer elemento de la lista, se suma con el índice del
ultimo elemento y se divide entre 2.
Eso nos da la posición del elemento central de la lista que será nuestro pivote.

0 1 2 3 4 5 6 7 8 9

8 1 4 9 6 3 5 2 7 0
0 9
pivote = n[(0 + 9) / 2]
Se toma el índice del primer elemento de la lista, se suma con el índice del
ultimo elemento y se divide entre 2.
Eso nos da la posición del elemento central de la lista que será nuestro pivote.

0 1 2 3 4 5 6 7 8 9

8 1 4 9 6 3 5 2 7 0
0 pivote = n[4] 9
Primero se itera desde la posición i = 0 buscando una clave mayor que el
pivote.

0 1 2 3 4 5 6 7 8 9

8 1 4 9 6 3 5 2 7 0
0 9
Primero se itera desde la posición i = 0 buscando una clave mayor que el
pivote.

0 1 2 3 4 5 6 7 8 9

8 1 4 9 6 3 5 2 7 0
0 9
Primero se itera desde la posición i = 0 buscando una clave mayor que el
pivote.

0 1 2 3 4 5 6 7 8 9

8 1 4 9 6 3 5 2 7 0
0 9
Luego se itera desde la posición j = 9 buscando una clave menor que el
pivote.

0 1 2 3 4 5 6 7 8 9

8 1 4 9 6 3 5 2 7 0
0 9
Luego se itera desde la posición j = 9 buscando una clave menor que el
pivote.

0 1 2 3 4 5 6 7 8 9

8 1 4 9 6 3 5 2 7 0
0 9
Una vez encontremos una clave mayor que el pivote a su izquierda y una
clave menor que el pivote a su derecha. Hacemos un intercambio entre
dichas claves. Si y solo si i es menor o igual a j.

0 1 2 3 4 5 6 7 8 9

8 1 4 9 6 3 5 2 7 0
0 9
Una vez encontremos una clave mayor que el pivote a su izquierda y una
clave menor que el pivote a su derecha. Hacemos un intercambio entre
dichas claves. Si y solo si i es menor o igual a j.

0 1 2 3 4 5 6 7 8 9

0 1 4 9 6 3 5 2 7 8
0 9
Luego de hacer el intercambio, aumentamos i una unidad y reducimos j
una unidad. Si i es menor o igual a j repetimos el proceso de buscar otra
clave mayor que el pivote a su izquierda y, una clave menor a su derecha.

0 1 2 3 4 5 6 7 8 9

0 1 4 9 6 3 5 2 7 8
1 8
Primero, volvemos a iterar, pero ahora desde la posición i = 1 buscando
una clave mayor que el pivote.

0 1 2 3 4 5 6 7 8 9

0 1 4 9 6 3 5 2 7 8
1 8
Primero, volvemos a iterar, pero ahora desde la posición i = 1 buscando
una clave mayor que el pivote.

0 1 2 3 4 5 6 7 8 9

0 1 4 9 6 3 5 2 7 8
1 8
Primero, volvemos a iterar, pero ahora desde la posición i = 1 buscando
una clave mayor que el pivote.

0 1 2 3 4 5 6 7 8 9

0 1 4 9 6 3 5 2 7 8
2 8
Primero, volvemos a iterar, pero ahora desde la posición i = 1 buscando
una clave mayor que el pivote.

0 1 2 3 4 5 6 7 8 9

0 1 4 9 6 3 5 2 7 8
3 8
Luego volvemos a iterar, ahora desde la posición j = 8 buscando una clave
menor que el pivote.

0 1 2 3 4 5 6 7 8 9

0 1 4 9 6 3 5 2 7 8
3 8
Luego volvemos a iterar, ahora desde la posición j = 8 buscando una clave
menor que el pivote.

0 1 2 3 4 5 6 7 8 9

0 1 4 9 6 3 5 2 7 8
3 8
Luego volvemos a iterar, ahora desde la posición j = 8 buscando una clave
menor que el pivote.

0 1 2 3 4 5 6 7 8 9

0 1 4 9 6 3 5 2 7 8
3 7
Luego volvemos a iterar, ahora desde la posición j = 8 buscando una clave
menor que el pivote.

0 1 2 3 4 5 6 7 8 9

0 1 4 9 6 3 5 2 7 8
3 7
Nuevamente, una vez que volvamos a encontrar tanto la clave mayor que el
pivote a su izquierda como la clave menor que el pivote a su derecha. Hacemos un
intercambio entre dichas claves. Si y solo si i es menor o igual a j.

0 1 2 3 4 5 6 7 8 9

0 1 4 9 6 3 5 2 7 8
3 7
Nuevamente, una vez que volvamos a encontrar tanto la clave mayor que el
pivote a su izquierda como la clave menor que el pivote a su derecha. Hacemos un
intercambio entre dichas claves. Si y solo si i es menor o igual a j.

0 1 2 3 4 5 6 7 8 9

0 1 4 2 6 3 5 9 7 8
3 7
Y nuevamente aumentamos i una unidad y reducimos j en una unidad.

0 1 2 3 4 5 6 7 8 9

0 1 4 2 6 3 5 9 7 8
3 7
Y nuevamente aumentamos i una unidad y reducimos j en una unidad.

0 1 2 3 4 5 6 7 8 9

0 1 4 2 6 3 5 9 7 8
4 6
Y nuevamente iteramos desde i = 4.

0 1 2 3 4 5 6 7 8 9

0 1 4 2 6 3 5 9 7 8
4 6
Y nuevamente iteramos desde i = 4.

0 1 2 3 4 5 6 7 8 9

0 1 4 2 6 3 5 9 7 8
4 6
Y nuevamente iteramos desde i = 4.

0 1 2 3 4 5 6 7 8 9

0 1 4 2 6 3 5 9 7 8
4 6
Y nuevamente iteramos desde j = 6.

0 1 2 3 4 5 6 7 8 9

0 1 4 2 6 3 5 9 7 8
4 6
Y nuevamente iteramos desde j = 6.

0 1 2 3 4 5 6 7 8 9

0 1 4 2 6 3 5 9 7 8
4 6
Y nuevamente hacemos el intercambio. Si y solo si i es menor o igual a
j.

0 1 2 3 4 5 6 7 8 9

0 1 4 2 6 3 5 9 7 8
4 6
 Y nuevamente hacemos el intercambio. Si y solo si i es menor o igual a
j.

0 1 2 3 4 5 6 7 8 9

0 1 4 2 5 3 6 9 7 8
4 6

Nota: Aunque el valor de 6 se halla intercambiado con 5, el pivote sigue siendo 6.

Aumentamos nuevamente i y reducimos j.

0 1 2 3 4 5 6 7 8 9

0 1 4 2 5 3 6 9 7 8
5 5
Nuevamente iteramos desde i = 5.

0 1 2 3 4 5 6 7 8 9

0 1 4 2 5 3 6 9 7 8
5 5
Nuevamente iteramos desde i = 5.

0 1 2 3 4 5 6 7 8 9

0 1 4 2 5 3 6 9 7 8
5 6
Nuevamente iteramos desde i = 5.

0 1 2 3 4 5 6 7 8 9

0 1 4 2 5 3 6 9 7 8
5 6
Luego, nuevamente iteramos desde j = 5.

0 1 2 3 4 5 6 7 8 9

0 1 4 2 5 3 6 9 7 8
5 6
Luego, nuevamente iteramos desde j = 5.

0 1 2 3 4 5 6 7 8 9

0 1 4 2 5 3 6 9 7 8
5 6
Como i no es menor o igual a j, no se hace el intercambio y no se continua
comparando.

0 1 2 3 4 5 6 7 8 9

0 1 4 2 5 3 6 9 7 8
5 6
Las dos sub-listas han sido “creadas”.

0 1 2 3 4 5 6 7 8 9

0 1 4 2 5 3 6 9 7 8
Las dos sub-listas han sido “creadas”.

0 1 2 3 4 5
6 7 8 9

0 1 4 2 5 3 9 7 8
Sub-lista-01 Sub-lista-02
Si el índice que apunta al primer elemento de nuestra lista es menor que
nuestro iterador j, se le aplica el algoritmo QuickSort a la sub-lista
izquierda.
6

0 1 2 3 4 5
6 7 8 9

0 1 4 2 5 3 9 7 8
Sub-lista-01 Sub-lista-02
Si nuestro iterador i es menor que el índice que apunta a la ultima posición
de nuestra lista, se le aplica el algoritmo QickSort a la sub-lista derecha.

0 1 2 3 4 5
6 7 8 9

0 1 4 2 5 3 9 7 8
Sub-lista-01 Sub-lista-02
Estas sub-listas serán divididas en más sub-listas una vez se les aplique el
algoritmo QuickSort.

0 1 2 3 4 5
6 7 8 9

0 1 4 2 5 3 9 7 8
Sub-lista-01 Sub-lista-02
Al final tendremos la lista ordenada.

0 1 2 3 4 5 6 7 8 9
En resumen:
• Seleccionar el elemento central de n[] como pivote.
En resumen:
• Seleccionar el elemento central de n[] como pivote.
• Dividir los elementos restantes en particiones izquierda y derecha, de modo
que ningún elemento de la izquierda tenga una clave mayor que el pivote y
que ningún elemento a la derecha tenga una clave más pequeña que la del
pivote.
En resumen:
• Seleccionar el elemento central de n[] como pivote.
• Dividir los elementos restantes en particiones izquierda y derecha, de modo
que ningún elemento de la izquierda tenga una clave mayor que el pivote y
que ningún elemento a la derecha tenga una clave más pequeña que la del
pivote.
• Ordenar la partición izquierda utilizando QuickSort recursivamente
En resumen:
• Seleccionar el elemento central de n[] como pivote.
• Dividir los elementos restantes en particiones izquierda y derecha, de modo
que ningún elemento de la izquierda tenga una clave mayor que el pivote y
que ningún elemento a la derecha tenga una clave más pequeña que la del
pivote.
• Ordenar la partición izquierda utilizando QuickSort recursivamente
• Ordenar la partición derecha utilizando QuickSort recursivamente
En resumen:
• Seleccionar el elemento central de n[] como pivote.
• Dividir los elementos restantes en particiones izquierda y derecha, de modo
que ningún elemento de la izquierda tenga una clave mayor que el pivote y
que ningún elemento a la derecha tenga una clave más pequeña que la del
pivote.
• Ordenar la partición izquierda utilizando QuickSort recursivamente
• Ordenar la partición derecha utilizando QuickSort recursivamente
• La solución es la partición izquierda seguida por el pivote y la partición
derecha.
En resumen:
• Seleccionar el elemento central de n[] como pivote.
• Dividir los elementos restantes en particiones izquierda y derecha, de modo
que ningún elemento de la izquierda tenga una clave mayor que el pivote y
que ningún elemento a la derecha tenga una clave más pequeña que la del
pivote.
• Ordenar la partición izquierda utilizando QuickSort recursivamente
• Ordenar la partición derecha utilizando QuickSort recursivamente
• La solución es la partición izquierda seguida por el pivote y la partición
derecha.
 quickSort(decimal n[], entero primero, entero ultimo)
definir i, j, central como entero
definir pivote como decimal
central <- (primero + ultimo) / 2
pivote <- n[central]
i <- primero
j <- ultimo
HAGA
MQ(n[i] < pivote)
i <- i + 1
FinMQ
MQ(n[j] > pivote)
j <- j – 1
FinMQ
SI (i <= j) ENTONCES
aux <- a[i]
a[i] <- a[j]
a[j] <- aux
i <- i + 1
j <- j – 1
FinSI
HASTA(i > j)
SI (primero < j) ENTONCES
quickSort(n, primero, j)
FinSI
SI (i < ultimo) ENTONCES
QuickSort(n, i, ultimo)
FinSi
FIN quicSort
 Análisis de eficiencia
•En mejor de los casos: 𝑂(𝑛 ∗ log 𝑛)

•En el caso medio: 𝑂(𝑛 ∗ log 𝑛)

2
•En el peor de los casos: 𝑂(𝑛 )
Gracias por tu tiempo. Codifica el algoritmo en tu lenguaje favorito.
Te quiero.