ALGORITMOS DE CLASIFICACIÓN INTERNA

1) Inserción directa. Mejoras:

1) Inserción Binaria
2) Selección directa
2) Intercambio directo (Burbuja)
3) Inserción con incrementos decrecientes (Shell)
4) Método del montículo (“Heapsort”)
5) Método rápido (“Quicksort”)
 QUICKSORT = METODO DE
ORDENAMIENTO RÁPIDO
El ordenamiento rápido (quicksort
en ingles) es un algoritmo basado en la
técnica de divide y vencerás, que permite,
en promedio, ordenar n elementos en una
complejidad de n log n. Es la técnica de
ordenamiento más rápida conocida.
Fue Charles Antony Richard
Hoare un científico Británico en
computación, quien en 1960
invento el método de
ordenación mas rápido,
“Quicksort”,. También se le
conoce por el desarrollo de la
Lógica de Hoare, y el lenguaje
formal CSP.
 El algoritmo fundamental es el
siguiente :
1º Elegimos un elemento del vector, puede
ser cualquiera. Lo llamaremos elemento
de división o pivote.

Pivote o elemento de división

La forma más efectiva es coger como pivote el elemento intermedio

2º Buscamos la posición que le corresponde
en el vector al pivote y ordenamos los
elementos de la lista de manera que a
lado queden los menores y a otro los
mayores.

Menores Mayores

PIVOTE
3º Realizamos esto de
forma recursiva para
que cada “subvector”
mientras este tengan
un largo mayor que 1
 EJEMPLO. QUICKSORT ITERATIVO 

8 1 4 9 6 3 5 2 7 0
cima=0 
izq=1  Pivote  = 6  der=10 
inf=1  sup=10 

0 1 4 9 6 3 5 2 7 8

izq=1  inf=2  Pivote  = 6  sup=9  der=10 

0 1 4 9 6 3 5 2 7 8

izq=1  inf=3  Pivote  = 6  sup=9  der=10 

0 1 4 9 6 3 5 2 7 8

izq=1  inf=4  Pivote  = 6  sup=9  der=10 

 EJEMPLO. QUICKSORT ITERATIVO 

0 1 4 9 6 3 5 2 7 0

izq=1  inf=4  Pivote  = 6  sup=8  der=10 

0 1 4 2 6 3 5 9 7 8

izq=1  Pivote  = 6  sup=7  der=10 

      inf=5 

0 1 4 2 5 3 6 9 7 8

izq=1     inf=6  Pivote  = 6  der=10 

sup=6 

0 1 4 2 5 3 6 9 7 8

izq=1  sup=6  Pivote  = 6  der=10 

    inf=7 
 EJEMPLO. QUICKSORT ITERATIVO 

0 1 4 2 5 3 6 9 7 8
cima=1  izq=7  Pivote  = 9 
Lim_izq=1  der=10 
inf=7 
Lim_der=6  sup=10 

0 1 4 2 5 3 6 9 7 8

izq=7  Pivote = 9  der=10 

     inf=8  sup=10 

0 1 4 2 5 3 6 8 7 9

izq=7  sup=9  der=10 

Inf=9  Pivote = 9 

0 1 4 2 5 3 6 8 7 9
cima=2 
Lim_izq=7 
izq=7  sup=9  der=10 
Lim_der=9  Inf = 10 
Pivote = 9 
 Algoritmo Quicksort recursivo
PROCEDIMIENTO quicksort (a: tipo_vector (E/S), izq: entero (E), der: entero (E))
VAR
i,j: entero
x,w: tipo_elemento
INICIO

iizq
jder
xa [(izq+der)/2]
Mientras (i<=j) hacer
Mientras (a[i].clave<x.clave) hacer
ii+1
Fin_mientras
Mientras (x.clave<a[j].clave) hacer
jj-1
Fin_mientras
Si (i<=j) entonces
wa[i]
a[i]a[j]
a[j]w
ii+1
jj-1
Fin_si
Fin_mientras
Si (izq<j) entonces
LLAMAR A quicksort (a,izq,j)
Fin_si
Si (i<der) entonces
LLAMAR A quicksort (a,i,der)
Fin_si
FIN_PROCEDIMIENTO
Algoritmo Quicksort iterativo [1]
TIPO tipo_pila= REGISTRO
izq, der : entero
FIN_REGISTRO
TIPO tpila=vector [Max] de tipo_pila

PROCEDIMIENTO quicksort_pila (a: tipo_vector (E/S))

VAR
i, j, izq, der, cima: entero
x,w: tipo_elemento
pila: tpila

INICIO

cima0
pila [0].izq0
pila [0].dern-1
Mientras (cima>=0) hacer
izqpila [cima].izq
derpila [cima].der
cimacima-1

1 2
Algoritmo Quicksort iterativo [2]
1 2

Mientras (izq<der) hacer

iizq
jder
xa [(izq+der)/2
Mientras (i<=j) hacer
Mientras (a[i].clave<x.clave) hacer
ii+1
Fin_mientras
Mientras (x.clave<a[j].clave) hacer
jj-1
Fin_mientras
Si (i<=j) entonces
wa[i]
a [i]a[j]
a [j]w
ii+1
jj-1
Fin_si
Fin_mientras

1 2
Algoritmo Quicksort iterativo [3]
1 2

Si ((j-izq) < (der-i)) entonces

Si (i<der) entonces
cimacima+1
pila [cima].izqi
pila [cima].derder
Fin_si
derj
Si_no
Si (j>izq) entonces
cimacima+1
pila [cima].izqizq
pila [cima].derj
Fin_si
izqi
Fin_si
Fin_mientras
Fin_mientras
FIN_PROCEDIMIENTO
 COMPLEJIDAD
•  Mejor caso: Pivote en el centro de la lista.
Orden de complejidad del algoritmo: O(n·logn).

•  Peor caso: Pivote en un extremo de la lista.

Orden de complejidad del algoritmo: O (n²).
Suele producirse en algoritmos ordenados o
casi ordenados.

•  Caso promedio: el orden es O (n·log n).

 Conclusiones

Ventajas:

•  Su orden de complejidad.
•  Muy rápido.
•  No requiere memoria adicional para su forma
recursiva, aunque para la iterativa sí que
necesita espacio adicional (para la pila).
 Conclusiones
Desventajas:

•  Es muy poco estable.

•  La complejidad depende de donde elijamos el pivote,
aunque lo más adecuado es elegirlo en el centro.
•  Implementación algo complicada.
•  El algoritmo en su forma recursiva emplea muchos
recursos.
•  Mucha diferencia entre el peor y el mejor caso.